resource-container: Install unit tests
[iotivity.git] / resource / include / OCResourceRequest.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  * ResourceRequest.
26  */
27
28 #ifndef OC_RESOURCEREQUEST_H_
29 #define OC_RESOURCEREQUEST_H_
30
31 #include "OCApi.h"
32 #include "OCRepresentation.h"
33
34 void formResourceRequest(OCEntityHandlerFlag,
35                          OCEntityHandlerRequest*,
36                          std::shared_ptr<OC::OCResourceRequest>);
37
38
39 namespace OC
40 {
41     /**
42     *   @brief  OCResourceRequest provides APIs to extract details from a request URI
43     */
44     class OCResourceRequest
45     {
46     public:
47         typedef std::shared_ptr<OCResourceRequest> Ptr;
48
49         OCResourceRequest():
50             m_requestType(""),
51             m_resourceUri(""),
52             m_queryParameters(QueryParamsMap()),
53             m_requestHandlerFlag(0),
54             m_messageID(0),
55             m_representation(OCRepresentation()),
56             m_headerOptions(HeaderOptions()),
57             m_requestHandle(nullptr),
58             m_resourceHandle(nullptr)
59         {
60             m_observationInfo.action = ObserveAction::ObserveRegister;
61             m_observationInfo.obsId = 0;
62             m_observationInfo.connectivityType = OCConnectivityType::CT_DEFAULT;
63             m_observationInfo.address = "";
64             m_observationInfo.port = 0;
65         }
66
67 #if defined(_MSC_VER) && (_MSC_VER < 1900)
68         OCResourceRequest(OCResourceRequest&& o):
69             m_requestType(std::move(o.m_requestType)),
70             m_resourceUri(std::move(o.m_resourceUri)),
71             m_queryParameters(std::move(o.m_queryParameters)),
72             m_requestHandlerFlag(o.m_requestHandlerFlag),
73             m_representation(std::move(o.m_representation)),
74             m_observationInfo(std::move(o.m_observationInfo)),
75             m_headerOptions(std::move(o.m_headerOptions)),
76             m_requestHandle(std::move(o.m_requestHandle)),
77             m_resourceHandle(std::move(o.m_resourceHandle))
78         {
79         }
80         OCResourceRequest& operator=(OCResourceRequest&& o)
81         {
82             m_requestType = std::move(o.m_requestType);
83             m_resourceUri = std::move(o.m_resourceUri);
84             m_queryParameters = std::move(o.m_queryParameters);
85             m_requestHandlerFlag = o.m_requestHandlerFlag;
86             m_representation = std::move(o.m_representation);
87             m_observationInfo = std::move(o.m_observationInfo);
88             m_headerOptions = std::move(o.m_headerOptions);
89             m_requestHandle = std::move(o.m_requestHandle);
90             m_resourceHandle = std::move(o.m_resourceHandle);
91         }
92 #else
93         OCResourceRequest(OCResourceRequest&&) = default;
94         OCResourceRequest& operator=(OCResourceRequest&&) = default;
95 #endif
96
97         /**
98         *  Virtual destructor
99         */
100         virtual ~OCResourceRequest(void)
101         {
102         }
103
104         /**
105         *  Retrieves the type of request string for the entity handler function to operate
106         *  @return std::string request type. This could be 'GET'/'PUT'/'POST'/'DELETE'
107         */
108         std::string getRequestType() const {return m_requestType;}
109
110         /**
111         *  Retrieves the query parameters from the request
112         *  @return std::string query parameters in the request
113         */
114         const QueryParamsMap& getQueryParameters() const {return m_queryParameters;}
115
116         /**
117         *  Retrieves the request handler flag type. This can be either INIT flag or
118         *  REQUEST flag or OBSERVE flag.
119         *  NOTE:
120         *  INIT indicates that the vendor's entity handler should go and perform
121         *  initialization operations
122         *  REQUEST indicates that it is a request of certain type (GET/PUT/POST/DELETE)
123         *  and entity handler needs to perform corresponding operations
124         *  OBSERVE indicates that the request is of type Observe and entity handler
125         *  needs to perform corresponding operations
126         *  @return int type of request flag
127         */
128         int getRequestHandlerFlag() const {return m_requestHandlerFlag;}
129
130         /**
131         *  Provides the entire resource attribute representation
132         *  @return OCRepresentation reference containing the name value pairs
133         *   representing the resource's attributes
134         */
135         const OCRepresentation& getResourceRepresentation() const {return m_representation;}
136
137         /**
138         *  @return ObservationInfo reference provides observation information
139         */
140         const ObservationInfo& getObservationInfo() const {return m_observationInfo;}
141
142         /**
143         *  sets resource uri
144         *  @param resourceUri specifies the resource uri
145         */
146         void setResourceUri(const std::string resourceUri)
147         {
148             m_resourceUri = resourceUri;
149         }
150
151         /**
152         *  gets resource uri
153         *  @return std::string resource uri
154         */
155         std::string getResourceUri(void)
156         {
157             return m_resourceUri;
158         }
159
160         /**
161         * This API retrieves headerOptions which was sent from a client
162         *
163         * @return std::map HeaderOptions with the header options
164         */
165         const HeaderOptions& getHeaderOptions() const
166         {
167             return m_headerOptions;
168         }
169
170         /**
171         * This API retrieves the request handle
172         *
173         * @return OCRequestHandle
174         */
175         const OCRequestHandle& getRequestHandle() const
176         {
177             return m_requestHandle;
178         }
179
180         /**
181         * This API retrieves the resource handle
182         *
183         * return OCResourceHandle
184         */
185         const OCResourceHandle& getResourceHandle() const
186         {
187             return m_resourceHandle;
188         }
189
190         /**
191         * This API retrieves the request message ID
192         *
193         * @return int16_t value of message ID
194         */
195         int16_t getMessageID() const {return m_messageID;}
196
197     private:
198         std::string m_requestType;
199         std::string m_resourceUri;
200         QueryParamsMap m_queryParameters;
201         int m_requestHandlerFlag;
202         int16_t m_messageID;
203         OCRepresentation m_representation;
204         ObservationInfo m_observationInfo;
205         HeaderOptions m_headerOptions;
206         OCRequestHandle m_requestHandle;
207         OCResourceHandle m_resourceHandle;
208
209
210     private:
211         friend void (::formResourceRequest)(OCEntityHandlerFlag, OCEntityHandlerRequest*,
212             std::shared_ptr<OC::OCResourceRequest>);
213         void setRequestType(const std::string& requestType)
214         {
215             m_requestType = requestType;
216         }
217
218         void setPayload(OCPayload* requestPayload);
219
220         void setQueryParams(QueryParamsMap& queryParams)
221         {
222             m_queryParameters = queryParams;
223         }
224
225         void setRequestHandlerFlag(int requestHandlerFlag)
226         {
227             m_requestHandlerFlag = requestHandlerFlag;
228         }
229
230         void setMessageID(int16_t messageID)
231         {
232             m_messageID = messageID;
233         }
234
235         void setObservationInfo(const ObservationInfo& observationInfo)
236         {
237             m_observationInfo = observationInfo;
238         }
239
240         void setHeaderOptions(const HeaderOptions& headerOptions)
241         {
242             m_headerOptions = headerOptions;
243         }
244
245         /**
246         * This API allows to set request handle
247         * @param requestHandle - OCRequestHandle type used to set the
248         * request handle
249         */
250         void setRequestHandle(const OCRequestHandle& requestHandle)
251         {
252             m_requestHandle = requestHandle;
253         }
254
255         /**
256         * This API allows to set the resource handle
257         * @param resourceHandle - OCResourceHandle type used to set the
258         * resource handle
259         */
260         void setResourceHandle(const OCResourceHandle& resourceHandle)
261         {
262             m_resourceHandle = resourceHandle;
263         }
264
265     };
266  }// namespace OC
267
268 #endif // OC_RESOURCEREQUEST_H_