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