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