resource/include/OCResourceRequest.h

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 /**
  22  * @file
  23  *
  24  * This file contains the declaration of classes and its members related to
  25  * ResourceRequest.
  26  */
  27
  28 #ifndef __OCRESOURCEREQUEST_H
  29 #define __OCRESOURCEREQUEST_H
  30
  31 #include "OCApi.h"
  32 #include "OCRepresentation.h"
  33
  34 void formResourceRequest(OCEntityHandlerFlag,
  35                          OCEntityHandlerRequest*,
  36                          std::shared_ptr<OC::OCResourceRequest>);
  37
  38
  39 namespace OC
  40 {
  41     /**
  42     *   @brief  OCResourceRequest provides APIs to extract details from a request URI
  43     */
  44     class OCResourceRequest
  45     {
  46     public:
  47         typedef std::shared_ptr<OCResourceRequest> Ptr;
  48
  49         OCResourceRequest():
  50             m_requestType{},
  51             m_resourceUri{},
  52             m_queryParameters{},
  53             m_requestHandlerFlag{},
  54             m_representation{},
  55             m_observationInfo{ObserveAction::ObserveRegister, 0},
  56             m_headerOptions{},
  57             m_requestHandle{nullptr},
  58             m_resourceHandle{nullptr}
  59         {
  60         }
  61
  62         OCResourceRequest(OCResourceRequest&&) = default;
  63         OCResourceRequest& operator=(OCResourceRequest&&) = default;
  64         /**
  65         *  Virtual destructor
  66         */
  67         virtual ~OCResourceRequest(void)
  68         {
  69         }
  70
  71         /**
  72         *  Retrieves the type of request string for the entity handler function to operate
  73         *  @return std::string request type. This could be 'GET'/'PUT'/'POST'/'DELETE'
  74         */
  75         std::string getRequestType() const {return m_requestType;}
  76
  77         /**
  78         *  Retrieves the query parameters from the request
  79         *  @return std::string query parameters in the request
  80         */
  81         const QueryParamsMap& getQueryParameters() const {return m_queryParameters;}
  82
  83         /**
  84         *  Retrieves the request handler flag type. This can be either INIT flag or
  85         *  REQUEST flag or OBSERVE flag.
  86         *  NOTE:
  87         *  INIT indicates that the vendor's entity handler should go and perform
  88         *  initialization operations
  89         *  REQUEST indicates that it is a request of certain type (GET/PUT/POST/DELETE)
  90         *  and entity handler needs to perform corresponding operations
  91         *  OBSERVE indicates that the request is of type Observe and entity handler
  92         *  needs to perform corresponding operations
  93         *  @return int type of request flag
  94         */
  95         int getRequestHandlerFlag() const {return m_requestHandlerFlag;}
  96
  97         /**
  98         *  Provides the entire resource attribute representation
  99         *  @return OCRepresentation reference containing the name value pairs
 100         *   representing the resource's attributes
 101         */
 102         const OCRepresentation& getResourceRepresentation() const {return m_representation;}
 103
 104         /**
 105         *  @return ObservationInfo reference provides observation information
 106         */
 107         const ObservationInfo& getObservationInfo() const {return m_observationInfo;}
 108
 109         /**
 110         *  sets resource uri
 111         *  @param resourceUri specifies the resource uri
 112         */
 113         void setResourceUri(const std::string resourceUri)
 114         {
 115             m_resourceUri = resourceUri;
 116         }
 117
 118         /**
 119         *  gets resource uri
 120         *  @return std::string resource uri
 121         */
 122         std::string getResourceUri(void)
 123         {
 124             return m_resourceUri;
 125         }
 126
 127         /**
 128         * This API retrieves headerOptions which was sent from a client
 129         *
 130         * @return std::map HeaderOptions with the header options
 131         */
 132         const HeaderOptions& getHeaderOptions() const
 133         {
 134             return m_headerOptions;
 135         }
 136
 137         /**
 138         * This API retrieves the request handle
 139         *
 140         * @return OCRequestHandle
 141         */
 142         const OCRequestHandle& getRequestHandle() const
 143         {
 144             return m_requestHandle;
 145         }
 146
 147         /**
 148         * This API retrieves the resource handle
 149         *
 150         * return OCResourceHandle
 151         */
 152         const OCResourceHandle& getResourceHandle() const
 153         {
 154             return m_resourceHandle;
 155         }
 156
 157     private:
 158         std::string m_requestType;
 159         std::string m_resourceUri;
 160         QueryParamsMap m_queryParameters;
 161         int m_requestHandlerFlag;
 162         OCRepresentation m_representation;
 163         ObservationInfo m_observationInfo;
 164         HeaderOptions m_headerOptions;
 165         OCRequestHandle m_requestHandle;
 166         OCResourceHandle m_resourceHandle;
 167
 168
 169     private:
 170         friend void (::formResourceRequest)(OCEntityHandlerFlag, OCEntityHandlerRequest*,
 171             std::shared_ptr<OC::OCResourceRequest>);
 172         void setRequestType(const std::string& requestType)
 173         {
 174             m_requestType = requestType;
 175         }
 176
 177         void setPayload(OCPayload* requestPayload);
 178
 179         void setQueryParams(QueryParamsMap& queryParams)
 180         {
 181             m_queryParameters = queryParams;
 182         }
 183
 184         void setRequestHandlerFlag(int requestHandlerFlag)
 185         {
 186             m_requestHandlerFlag = requestHandlerFlag;
 187         }
 188
 189         void setObservationInfo(const ObservationInfo& observationInfo)
 190         {
 191             m_observationInfo = observationInfo;
 192         }
 193
 194         void setHeaderOptions(const HeaderOptions& headerOptions)
 195         {
 196             m_headerOptions = headerOptions;
 197         }
 198
 199         /**
 200         * This API allows to set request handle
 201         * @param requestHandle - OCRequestHandle type used to set the
 202         * request handle
 203         */
 204         void setRequestHandle(const OCRequestHandle& requestHandle)
 205         {
 206             m_requestHandle = requestHandle;
 207         }
 208
 209         /**
 210         * This API allows to set the resource handle
 211         * @param resourceHandle - OCResourceHandle type used to set the
 212         * resource handle
 213         */
 214         void setResourceHandle(const OCResourceHandle& resourceHandle)
 215         {
 216             m_resourceHandle = resourceHandle;
 217         }
 218
 219     };
 220  }// namespace OC
 221
 222 #endif //__OCRESOURCEREQUEST_H