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 OC_RESOURCEREQUEST_H_
  29 #define OC_RESOURCEREQUEST_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_messageID{},
  55             m_representation{},
  56             m_observationInfo{},
  57             m_headerOptions{},
  58             m_requestHandle{nullptr},
  59             m_resourceHandle{nullptr}
  60         {
  61         }
  62
  63 #if defined(_MSC_VER) && (_MSC_VER < 1900)
  64         OCResourceRequest(OCResourceRequest&& o):
  65             m_requestType(std::move(o.m_requestType)),
  66             m_resourceUri(std::move(o.m_resourceUri)),
  67             m_queryParameters(std::move(o.m_queryParameters)),
  68             m_requestHandlerFlag(o.m_requestHandlerFlag),
  69             m_representation(std::move(o.m_representation)),
  70             m_observationInfo(std::move(o.m_observationInfo)),
  71             m_headerOptions(std::move(o.m_headerOptions)),
  72             m_requestHandle(std::move(o.m_requestHandle)),
  73             m_resourceHandle(std::move(o.m_resourceHandle))
  74         {
  75         }
  76         OCResourceRequest& operator=(OCResourceRequest&& o)
  77         {
  78             m_requestType = std::move(o.m_requestType);
  79             m_resourceUri = std::move(o.m_resourceUri);
  80             m_queryParameters = std::move(o.m_queryParameters);
  81             m_requestHandlerFlag = o.m_requestHandlerFlag;
  82             m_representation = std::move(o.m_representation);
  83             m_observationInfo = std::move(o.m_observationInfo);
  84             m_headerOptions = std::move(o.m_headerOptions);
  85             m_requestHandle = std::move(o.m_requestHandle);
  86             m_resourceHandle = std::move(o.m_resourceHandle);
  87         }
  88 #else
  89         OCResourceRequest(OCResourceRequest&&) = default;
  90         OCResourceRequest& operator=(OCResourceRequest&&) = default;
  91 #endif
  92
  93         /**
  94         *  Virtual destructor
  95         */
  96         virtual ~OCResourceRequest(void)
  97         {
  98         }
  99
 100         /**
 101         *  Retrieves the type of request string for the entity handler function to operate
 102         *  @return std::string request type. This could be 'GET'/'PUT'/'POST'/'DELETE'
 103         */
 104         std::string getRequestType() const {return m_requestType;}
 105
 106         /**
 107         *  Retrieves the query parameters from the request
 108         *  @return std::string query parameters in the request
 109         */
 110         const QueryParamsMap& getQueryParameters() const {return m_queryParameters;}
 111
 112         /**
 113         *  Retrieves the request handler flag type. This can be either INIT flag or
 114         *  REQUEST flag or OBSERVE flag.
 115         *  NOTE:
 116         *  INIT indicates that the vendor's entity handler should go and perform
 117         *  initialization operations
 118         *  REQUEST indicates that it is a request of certain type (GET/PUT/POST/DELETE)
 119         *  and entity handler needs to perform corresponding operations
 120         *  OBSERVE indicates that the request is of type Observe and entity handler
 121         *  needs to perform corresponding operations
 122         *  @return int type of request flag
 123         */
 124         int getRequestHandlerFlag() const {return m_requestHandlerFlag;}
 125
 126         /**
 127         *  Provides the entire resource attribute representation
 128         *  @return OCRepresentation reference containing the name value pairs
 129         *   representing the resource's attributes
 130         */
 131         const OCRepresentation& getResourceRepresentation() const {return m_representation;}
 132
 133         /**
 134         *  @return ObservationInfo reference provides observation information
 135         */
 136         const ObservationInfo& getObservationInfo() const {return m_observationInfo;}
 137
 138         /**
 139         *  sets resource uri
 140         *  @param resourceUri specifies the resource uri
 141         */
 142         void setResourceUri(const std::string resourceUri)
 143         {
 144             m_resourceUri = resourceUri;
 145         }
 146
 147         /**
 148         *  gets resource uri
 149         *  @return std::string resource uri
 150         */
 151         std::string getResourceUri(void)
 152         {
 153             return m_resourceUri;
 154         }
 155
 156         /**
 157         * This API retrieves headerOptions which was sent from a client
 158         *
 159         * @return std::map HeaderOptions with the header options
 160         */
 161         const HeaderOptions& getHeaderOptions() const
 162         {
 163             return m_headerOptions;
 164         }
 165
 166         /**
 167         * This API retrieves the request handle
 168         *
 169         * @return OCRequestHandle
 170         */
 171         const OCRequestHandle& getRequestHandle() const
 172         {
 173             return m_requestHandle;
 174         }
 175
 176         /**
 177         * This API retrieves the resource handle
 178         *
 179         * return OCResourceHandle
 180         */
 181         const OCResourceHandle& getResourceHandle() const
 182         {
 183             return m_resourceHandle;
 184         }
 185
 186         /**
 187         * This API retrieves the request message ID
 188         *
 189         * @return int16_t value of message ID
 190         */
 191         int16_t getMessageID() const {return m_messageID;}
 192
 193     private:
 194         std::string m_requestType;
 195         std::string m_resourceUri;
 196         QueryParamsMap m_queryParameters;
 197         int m_requestHandlerFlag;
 198         int16_t m_messageID;
 199         OCRepresentation m_representation;
 200         ObservationInfo m_observationInfo;
 201         HeaderOptions m_headerOptions;
 202         OCRequestHandle m_requestHandle;
 203         OCResourceHandle m_resourceHandle;
 204
 205
 206     private:
 207         friend void (::formResourceRequest)(OCEntityHandlerFlag, OCEntityHandlerRequest*,
 208             std::shared_ptr<OC::OCResourceRequest>);
 209         void setRequestType(const std::string& requestType)
 210         {
 211             m_requestType = requestType;
 212         }
 213
 214         void setPayload(OCPayload* requestPayload);
 215
 216         void setQueryParams(QueryParamsMap& queryParams)
 217         {
 218             m_queryParameters = queryParams;
 219         }
 220
 221         void setRequestHandlerFlag(int requestHandlerFlag)
 222         {
 223             m_requestHandlerFlag = requestHandlerFlag;
 224         }
 225
 226         void setMessageID(int16_t messageID)
 227         {
 228             m_messageID = messageID;
 229         }
 230
 231         void setObservationInfo(const ObservationInfo& observationInfo)
 232         {
 233             m_observationInfo = observationInfo;
 234         }
 235
 236         void setHeaderOptions(const HeaderOptions& headerOptions)
 237         {
 238             m_headerOptions = headerOptions;
 239         }
 240
 241         /**
 242         * This API allows to set request handle
 243         * @param requestHandle - OCRequestHandle type used to set the
 244         * request handle
 245         */
 246         void setRequestHandle(const OCRequestHandle& requestHandle)
 247         {
 248             m_requestHandle = requestHandle;
 249         }
 250
 251         /**
 252         * This API allows to set the resource handle
 253         * @param resourceHandle - OCResourceHandle type used to set the
 254         * resource handle
 255         */
 256         void setResourceHandle(const OCResourceHandle& resourceHandle)
 257         {
 258             m_resourceHandle = resourceHandle;
 259         }
 260
 261     };
 262  }// namespace OC
 263
 264 #endif // OC_RESOURCEREQUEST_H_