resource/include/OCResourceResponse.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  * ResourceResponse.
  26  */
  27
  28 #ifndef OC_RESOURCERESPONSE_H_
  29 #define OC_RESOURCERESPONSE_H_
  30
  31 #include "OCApi.h"
  32 #include <IServerWrapper.h>
  33 #include <ocstack.h>
  34 #include <OCRepresentation.h>
  35
  36 namespace OC
  37 {
  38     class InProcServerWrapper;
  39
  40     /**
  41     *   @brief  OCResourceResponse provides APIs to set the response details
  42     */
  43     class OCResourceResponse
  44     {
  45     public:
  46         typedef std::shared_ptr<OCResourceResponse> Ptr;
  47
  48         OCResourceResponse():
  49             m_newResourceUri{},
  50             m_errorCode{},
  51             m_headerOptions{},
  52             m_interface{},
  53             m_representation{},
  54             m_requestHandle{0},
  55             m_resourceHandle{nullptr},
  56             m_responseResult{}
  57         {
  58         }
  59
  60 #if defined(_MSC_VER) && (_MSC_VER < 1900)
  61         OCResourceResponse(OCResourceResponse&& o):
  62             m_newResourceUri(std::move(o.m_newResourceUri)),
  63             m_errorCode(o.m_errorCode),
  64             m_headerOptions(std::move(o.m_headerOptions)),
  65             m_interface(std::move(o.m_interface)),
  66             m_representation(std::move(o.m_representation)),
  67             m_requestHandle(std::move(o.m_requestHandle)),
  68             m_resourceHandle(std::move(o.m_resourceHandle)),
  69             m_responseResult(std::move(o.m_responseResult))
  70         {
  71         }
  72         OCResourceResponse& operator=(OCResourceResponse&& o)
  73         {
  74             m_newResourceUri = std::move(o.m_newResourceUri);
  75             m_errorCode = o.m_errorCode;
  76             m_headerOptions = std::move(o.m_headerOptions);
  77             m_interface = std::move(o.m_interface);
  78             m_representation = std::move(o.m_representation);
  79             m_requestHandle = std::move(o.m_requestHandle);
  80             m_resourceHandle = std::move(o.m_resourceHandle);
  81             m_responseResult = std::move(o.m_responseResult);
  82         }
  83 #else
  84         OCResourceResponse(OCResourceResponse&&) = default;
  85         OCResourceResponse& operator=(OCResourceResponse&&) = default;
  86 #endif
  87         virtual ~OCResourceResponse(void) {}
  88
  89         /**
  90         *  This API sets the error code for this response
  91         *  @param eCode error code to set
  92         */
  93         void setErrorCode(const int eCode) { m_errorCode = eCode; }
  94
  95         /**
  96         *  gets new resource uri
  97         *  @return std::string new resource uri
  98         */
  99         std::string getNewResourceUri(void)
 100         {
 101             return m_newResourceUri;
 102         }
 103
 104         /**
 105         *  sets new resource uri
 106         *  @param newResourceUri specifies the resource uri of the resource created
 107         */
 108         void setNewResourceUri(const std::string newResourceUri)
 109         {
 110             m_newResourceUri = newResourceUri;
 111         }
 112
 113         /**
 114         * This API allows to set headerOptions in the response
 115         * @param headerOptions HeaderOptions vector consisting of OCHeaderOption objects
 116         */
 117         void setHeaderOptions(const HeaderOptions& headerOptions)
 118         {
 119             m_headerOptions = headerOptions;
 120         }
 121
 122         /**
 123         * This API allows to set request handle
 124         *
 125         * @param requestHandle - OCRequestHandle type used to set the request handle
 126         */
 127         void setRequestHandle(const OCRequestHandle& requestHandle)
 128         {
 129             m_requestHandle = requestHandle;
 130         }
 131
 132         /**
 133         * This API allows to set the resource handle
 134         *
 135         * @param resourceHandle - OCResourceHandle type used to set the resource handle
 136         */
 137         void setResourceHandle(const OCResourceHandle& resourceHandle)
 138         {
 139             m_resourceHandle = resourceHandle;
 140         }
 141
 142         /**
 143         * This API allows to set the EntityHandler response result
 144         *
 145         * @param responseResult - OCEntityHandlerResult type to set the result value
 146         */
 147         void setResponseResult(const OCEntityHandlerResult& responseResult)
 148         {
 149             m_responseResult = responseResult;
 150         }
 151
 152         /**
 153         *  API to set the entire resource attribute representation
 154         *  @param rep reference to the resource's representation
 155         *  @param interface specifies the interface
 156         */
 157         void setResourceRepresentation(OCRepresentation& rep, std::string iface) {
 158             m_interface = iface;
 159             m_representation = rep;
 160         }
 161
 162         /**
 163         *  API to set the entire resource attribute representation
 164         *  @param rep rvalue reference to the resource's representation
 165         *  @param interface specifies the interface
 166         */
 167         void setResourceRepresentation(OCRepresentation&& rep, std::string iface) {
 168             setResourceRepresentation(rep, iface);
 169         }
 170
 171         /**
 172         *  API to set the entire resource attribute representation
 173         *  @param rep reference to the resource's representation
 174         */
 175         void setResourceRepresentation(OCRepresentation& rep) {
 176             // Call the default
 177             m_interface = DEFAULT_INTERFACE;
 178             m_representation = rep;
 179         }
 180
 181         /**
 182         *  API to set the entire resource attribute representation
 183         *  @param rep rvalue reference to the resource's representation
 184         */
 185         void setResourceRepresentation(OCRepresentation&& rep) {
 186             // Call the above function
 187             setResourceRepresentation(rep);
 188         }
 189     private:
 190         std::string m_newResourceUri;
 191         int m_errorCode;
 192         HeaderOptions m_headerOptions;
 193         std::string m_interface;
 194         OCRepresentation m_representation;
 195         OCRequestHandle m_requestHandle;
 196         OCResourceHandle m_resourceHandle;
 197         OCEntityHandlerResult m_responseResult;
 198
 199     private:
 200         friend class InProcServerWrapper;
 201
 202         OCRepPayload* getPayload() const
 203         {
 204             MessageContainer inf;
 205             OCRepresentation first(m_representation);
 206
 207             if(m_interface==LINK_INTERFACE)
 208             {
 209                 first.setInterfaceType(InterfaceType::LinkParent);
 210             }
 211             else if(m_interface==BATCH_INTERFACE)
 212             {
 213                 first.setInterfaceType(InterfaceType::BatchParent);
 214             }
 215             else
 216             {
 217                 first.setInterfaceType(InterfaceType::DefaultParent);
 218             }
 219
 220             inf.addRepresentation(first);
 221
 222             for(const OCRepresentation& rep : m_representation.getChildren())
 223             {
 224                 OCRepresentation cur(rep);
 225
 226                 if(m_interface==LINK_INTERFACE)
 227                 {
 228                     cur.setInterfaceType(InterfaceType::LinkChild);
 229                 }
 230                 else if(m_interface==BATCH_INTERFACE)
 231                 {
 232                     cur.setInterfaceType(InterfaceType::BatchChild);
 233                 }
 234                 else
 235                 {
 236                     cur.setInterfaceType(InterfaceType::DefaultChild);
 237                 }
 238
 239                 inf.addRepresentation(cur);
 240
 241             }
 242
 243             return inf.getPayload();
 244         }
 245     public:
 246
 247         /**
 248         * Get error code
 249         */
 250         int getErrorCode() const
 251         {
 252             return m_errorCode;
 253         }
 254
 255         /**
 256          * Get the Response Representation
 257          */
 258         const OCRepresentation& getResourceRepresentation() const
 259         {
 260             return m_representation;
 261         }
 262         /**
 263         * This API allows to retrieve headerOptions from a response
 264         */
 265         const HeaderOptions& getHeaderOptions() const
 266         {
 267             return m_headerOptions;
 268         }
 269
 270         /**
 271         * This API retrieves the request handle
 272         *
 273         * @return OCRequestHandle value
 274         */
 275         const OCRequestHandle& getRequestHandle() const
 276         {
 277             return m_requestHandle;
 278         }
 279
 280         /**
 281         * This API retrieves the resource handle
 282         *
 283         * @return OCResourceHandle value
 284         */
 285         const OCResourceHandle& getResourceHandle() const
 286         {
 287             return m_resourceHandle;
 288         }
 289
 290         /**
 291         * This API retrieves the entity handle response result
 292         *
 293         * @return OCEntityHandler result value
 294         */
 295         OCEntityHandlerResult getResponseResult() const
 296         {
 297             return m_responseResult;
 298         }
 299     };
 300
 301 } // namespace OC
 302
 303 #endif // OC_RESOURCERESPONSE_H_