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