Merge "C++ Avoid crash in case of Invalid/Empty Payload"
[iotivity.git] / 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 /// @file OCResourceResponse.h
22
23 /// @brief  This file contains the declaration of classes and its members related to
24 ///         ResourceResponse.
25
26 #ifndef __OCRESOURCERESPONSE_H
27 #define __OCRESOURCERESPONSE_H
28
29 #include "OCApi.h"
30 #include <IServerWrapper.h>
31 #include <ocstack.h>
32 #include <OCRepresentation.h>
33
34 using namespace std;
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         virtual ~OCResourceResponse(void) {}
61
62         /**
63         *  This API sets the error code for this response
64         *  @param eCode error code to set
65         */
66         void setErrorCode(const int eCode) { m_errorCode = eCode; }
67
68         /**
69         *  gets new resource uri
70         *  @return std::string new resource uri
71         */
72         std::string getNewResourceUri(void)
73         {
74             return m_newResourceUri;
75         }
76
77         /**
78         *  sets new resource uri
79         *  @param newResourceUri specifies the resource uri of the resource created
80         */
81         void setNewResourceUri(const std::string newResourceUri)
82         {
83             m_newResourceUri = newResourceUri;
84         }
85
86         /**
87         * This API allows to set headerOptions in the response
88         * @param headerOptions HeaderOptions vector consisting of OCHeaderOption objects
89         */
90         void setHeaderOptions(const HeaderOptions& headerOptions)
91         {
92             m_headerOptions = headerOptions;
93         }
94
95         /**
96         * This API allows to set request handle
97         *
98         * @param requestHandle - OCRequestHandle type used to set the request handle
99         */
100         void setRequestHandle(const OCRequestHandle& requestHandle)
101         {
102             m_requestHandle = requestHandle;
103         }
104
105         /**
106         * This API allows to set the resource handle
107         *
108         * @param resourceHandle - OCResourceHandle type used to set the resource handle
109         */
110         void setResourceHandle(const OCResourceHandle& resourceHandle)
111         {
112             m_resourceHandle = resourceHandle;
113         }
114
115         /**
116         * This API allows to set the EntityHandler response result
117         *
118         * @param responseResult - OCEntityHandlerResult type to set the result value
119         */
120         void setResponseResult(const OCEntityHandlerResult& responseResult)
121         {
122             m_responseResult = responseResult;
123         }
124
125         /**
126         *  API to set the entire resource attribute representation
127         *  @param attributeMap reference containing the name value pairs representing
128         *         the resource's attributes
129         *  @param interface specifies the interface
130         */
131         void setResourceRepresentation(OCRepresentation& rep, std::string interface) {
132             m_interface = interface;
133             m_representation = rep;
134         }
135
136         /**
137         *  API to set the entire resource attribute representation
138         *  @param attributeMap rvalue reference containing the name value pairs representing
139         *         the resource's attributes
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 attributeMap reference containing the name value pairs representing the resource's
149         *  attributes
150         */
151         void setResourceRepresentation(OCRepresentation& rep) {
152             // Call the default
153             m_interface = DEFAULT_INTERFACE;
154             m_representation = rep;
155         }
156
157         /**
158         *  API to set the entire resource attribute representation
159         *  @param attributeMap rvalue reference containing the name value pairs representing the
160         *  resource's attributes
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