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