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 /// @file OCResourceRequest.h
  22
  23 /// @brief  This file contains the declaration of classes and its members related to
  24 ///         ResourceRequest.
  25
  26 #ifndef __OCRESOURCEREQUEST_H
  27 #define __OCRESOURCEREQUEST_H
  28
  29 #include "OCApi.h"
  30 #include "OCRepresentation.h"
  31
  32 void formResourceRequest(OCEntityHandlerFlag,
  33                          OCEntityHandlerRequest*,
  34                          std::shared_ptr<OC::OCResourceRequest>);
  35
  36
  37 namespace OC
  38 {
  39     /**
  40     *   @brief  OCResourceRequest provides APIs to extract details from a request URI
  41     */
  42     class OCResourceRequest
  43     {
  44     public:
  45         typedef std::shared_ptr<OCResourceRequest> Ptr;
  46
  47         /**
  48         *  Virtual destructor
  49         */
  50         virtual ~OCResourceRequest(void)
  51         {
  52         }
  53
  54         /**
  55         *  Retrieves the type of request string for the entity handler function to operate
  56         *  @return std::string request type. This could be 'GET'/'PUT'/'POST'/'DELETE'
  57         */
  58         std::string getRequestType() const {return m_requestType;}
  59
  60         /**
  61         *  Retrieves the query parameters from the request
  62         *  @return std::string query parameters in the request
  63         */
  64         const QueryParamsMap& getQueryParameters() const {return m_queryParameters;}
  65
  66         /**
  67         *  Retrieves the request handler flag type. This can be either INIT flag or
  68         *  REQUEST flag or OBSERVE flag.
  69         *  NOTE:
  70         *  INIT indicates that the vendor's entity handler should go and perform
  71         *  initialization operations
  72         *  REQUEST indicates that it is a request of certain type (GET/PUT/POST/DELETE)
  73         *  and entity handler needs to perform corresponding operations
  74         *  OBSERVE indicates that the request is of type Observe and entity handler
  75         *  needs to perform corresponding operations
  76         *  @return int type of request flag
  77         */
  78         int getRequestHandlerFlag() const {return m_requestHandlerFlag;}
  79
  80         /**
  81         *  Provides the entire resource attribute representation
  82         *  @return OCRepresentation reference containing the name value pairs
  83         *   representing the resource's attributes
  84         */
  85         const OCRepresentation& getResourceRepresentation() const {return m_representation;}
  86
  87         /**
  88         *  @return ObservationInfo reference provides observation information
  89         */
  90         const ObservationInfo& getObservationInfo() const {return m_observationInfo;}
  91
  92         /**
  93         *  sets resource uri
  94         *  @param resourceUri specifies the resource uri
  95         */
  96         void setResourceUri(const std::string resourceUri)
  97         {
  98             m_resourceUri = resourceUri;
  99         }
 100
 101         /**
 102         *  gets resource uri
 103         *  @return std::string resource uri
 104         */
 105         std::string getResourceUri(void)
 106         {
 107             return m_resourceUri;
 108         }
 109
 110         /**
 111         * This API retrieves headerOptions which was sent from a client
 112         *
 113         * @return std::map HeaderOptions with the header options
 114         */
 115         const HeaderOptions& getHeaderOptions() const
 116         {
 117             return m_headerOptions;
 118         }
 119
 120         /**
 121         * This API retrieves the request handle
 122         *
 123         * @return OCRequestHandle
 124         */
 125         const OCRequestHandle& getRequestHandle() const
 126         {
 127             return m_requestHandle;
 128         }
 129
 130         /**
 131         * This API retrieves the resource handle
 132         *
 133         * return OCResourceHandle
 134         */
 135         const OCResourceHandle& getResourceHandle() const
 136         {
 137             return m_resourceHandle;
 138         }
 139
 140     private:
 141         std::string m_requestType;
 142         std::string m_resourceUri;
 143         QueryParamsMap m_queryParameters;
 144         int m_requestHandlerFlag;
 145         OCRepresentation m_representation;
 146         ObservationInfo m_observationInfo;
 147         HeaderOptions m_headerOptions;
 148         OCRequestHandle m_requestHandle;
 149         OCResourceHandle m_resourceHandle;
 150
 151
 152     private:
 153         friend void (::formResourceRequest)(OCEntityHandlerFlag, OCEntityHandlerRequest*,
 154             std::shared_ptr<OC::OCResourceRequest>);
 155         void setRequestType(const std::string& requestType)
 156         {
 157             m_requestType = requestType;
 158         }
 159
 160         void setPayload(const std::string& requestPayload)
 161         {
 162             if(requestPayload.empty())
 163             {
 164                 return;
 165             }
 166
 167             MessageContainer info;
 168             info.setJSONRepresentation(requestPayload);
 169
 170             const std::vector<OCRepresentation>& reps = info.representations();
 171             if(reps.size() >0)
 172             {
 173                 std::vector<OCRepresentation>::const_iterator itr = reps.begin();
 174                 std::vector<OCRepresentation>::const_iterator back = reps.end();
 175                 m_representation = *itr;
 176                 ++itr;
 177
 178                 for(;itr != back; ++itr)
 179                 {
 180                     m_representation.addChild(*itr);
 181                 }
 182             }
 183             else
 184             {
 185                 throw OCException(OC::Exception::INVALID_REPRESENTATION);
 186             }
 187         }
 188
 189         void setQueryParams(QueryParamsMap& queryParams)
 190         {
 191             m_queryParameters = queryParams;
 192         }
 193
 194         void setRequestHandlerFlag(int requestHandlerFlag)
 195         {
 196             m_requestHandlerFlag = requestHandlerFlag;
 197         }
 198
 199         void setObservationInfo(const ObservationInfo& observationInfo)
 200         {
 201             m_observationInfo = observationInfo;
 202         }
 203
 204         void setHeaderOptions(const HeaderOptions& headerOptions)
 205         {
 206             m_headerOptions = headerOptions;
 207         }
 208
 209         /**
 210         * This API allows to set request handle
 211         * @param requestHandle - OCRequestHandle type used to set the
 212         * request handle
 213         */
 214         void setRequestHandle(const OCRequestHandle& requestHandle)
 215         {
 216             m_requestHandle = requestHandle;
 217         }
 218
 219         /**
 220         * This API allows to set the resource handle
 221         * @param resourceHandle - OCResourceHandle type used to set the
 222         * resource handle
 223         */
 224         void setResourceHandle(const OCResourceHandle& resourceHandle)
 225         {
 226             m_resourceHandle = resourceHandle;
 227         }
 228
 229     };
 230  }// namespace OC
 231
 232 #endif //__OCRESOURCEREQUEST_H