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