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