c977a041d62dfa407bea4e1654dacf8c0d862599
[iotivity.git] / resource / include / OCResource.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  * Resource.
26  */
27
28 #ifndef OC_RESOURCE_H_
29 #define OC_RESOURCE_H_
30
31 #include <memory>
32 #include <random>
33 #include <algorithm>
34
35 #include <OCApi.h>
36 #include <ResourceInitException.h>
37 #include <IClientWrapper.h>
38 #include <InProcClientWrapper.h>
39 #include <OCRepresentation.h>
40
41 namespace OC
42 {
43     class OCResource;
44     class OCResourceIdentifier;
45     std::ostream& operator <<(std::ostream& os, const OCResourceIdentifier& ri);
46     /**
47     *  @brief  OCResourceIdentifier represents the identity information for a server. This
48     *          object combined with the OCResource's URI property uniquely identify an
49     *          OCResource on or across networks.
50     *          Equality operators are implemented.  However, internal representation is subject
51     *          to change and thus should not be accessed or depended on.
52     */
53     class OCResourceIdentifier
54     {
55         friend class OCResource;
56         friend std::ostream& operator <<(std::ostream& os, const OCResourceIdentifier& ri);
57
58         public:
59             OCResourceIdentifier() = delete;
60
61             OCResourceIdentifier(const OCResourceIdentifier&) = default;
62
63 #if defined(_MSC_VER) && (_MSC_VER < 1900)
64             OCResourceIdentifier(OCResourceIdentifier&& o):
65                 m_resourceUri(std::move(o.m_resourceUri)),
66                 m_representation(o.m_representation)
67             {
68             }
69 #else
70             OCResourceIdentifier(OCResourceIdentifier&&) = default;
71 #endif
72
73             OCResourceIdentifier& operator=(const OCResourceIdentifier&) = delete;
74
75             OCResourceIdentifier& operator=(OCResourceIdentifier&&) = delete;
76
77             bool operator==(const OCResourceIdentifier &other) const;
78
79             bool operator!=(const OCResourceIdentifier &other) const;
80
81             bool operator<(const OCResourceIdentifier &other) const;
82
83             bool operator>(const OCResourceIdentifier &other) const;
84
85             bool operator<=(const OCResourceIdentifier &other) const;
86
87             bool operator>=(const OCResourceIdentifier &other) const;
88
89         private:
90
91             OCResourceIdentifier(const std::string& wireServerIdentifier,
92                     const std::string& resourceUri );
93
94         private:
95             std::string m_representation;
96             const std::string& m_resourceUri;
97     };
98
99     /**
100     *   @brief  OCResource represents an OC resource. A resource could be a light controller,
101     *           temperature sensor, smoke detector, etc. A resource comes with a well-defined
102     *           contract or interface onto which you can perform different operations, such as
103     *           turning on the light, getting the current temperature or subscribing for event
104     *           notifications from the smoke detector. A resource can be composed of one or
105     *           more resources.
106     */
107     class OCResource
108     {
109     friend class OCPlatform_impl;
110     friend class ListenOCContainer;
111     public:
112         typedef std::shared_ptr<OCResource> Ptr;
113
114 #if defined(_MSC_VER) && (_MSC_VER < 1900)
115         OCResource(OCResource&& o):
116             m_clientWrapper(std::move(o.m_clientWrapper)),
117             m_uri(std::move(o.m_uri)),
118             m_resourceId(std::move(o.m_resourceId)),
119             m_devAddr(std::move(o.m_devAddr)),
120             m_useHostString(o.m_useHostString),
121             m_property(o.m_property),
122             m_isCollection(o.m_isCollection),
123             m_resourceTypes(std::move(o.m_resourceTypes)),
124             m_interfaces(std::move(o.m_interfaces)),
125             m_children(std::move(m_children)),
126             m_endpoints(std::move(m_endpoints)),
127             m_serverHeaderOptions(std::move(m_serverHeaderOptions)),
128             m_observeHandle(std::move(m_observeHandle)),
129             m_headerOptions(std::move(m_headerOptions))
130         {
131         }
132 #else
133         OCResource(OCResource&&) = default;
134 #endif
135         // Explicitly delete the copy ctor since VS2013 would try to generate one, and
136         // the standard says that defaulting the move ctor should delete the copy ctor.
137         OCResource(const OCResource&) = delete;
138
139         // We cannot support copy/move assigns since OCResourceIdentifier doesn't.
140         OCResource& operator=(OCResource&&) = delete;
141         OCResource& operator=(const OCResource&) = delete;
142
143         /**
144         * Virtual destructor
145         */
146         virtual ~OCResource(void);
147
148         /**
149         * Function to get the attributes of a resource.
150         * @param queryParametersMap map which can have the query parameter name and value
151         * @param attributeHandler handles callback
152         *        The callback function will be invoked with a map of attribute name and values.
153         *        The callback function will also have the result from this Get operation
154         *        This will have error codes
155         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
156         * @note OCStackResult is defined in ocstack.h.
157         */
158         OCStackResult get(const QueryParamsMap& queryParametersMap, GetCallback attributeHandler);
159         /**
160         * Function to get the attributes of a resource.
161         * @param queryParametersMap map which can have the query parameter name and value
162         * @param attributeHandler handles callback
163         *        The callback function will be invoked with a map of attribute name and values.
164         *        The callback function will also have the result from this Get operation
165         *        This will have error codes
166         * @param QoS the quality of communication
167         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
168         * @note OCStackResult is defined in ocstack.h.
169         */
170         OCStackResult get(const QueryParamsMap& queryParametersMap, GetCallback attributeHandler,
171                           QualityOfService QoS);
172
173         /**
174         * Function to get the attributes of a resource.
175         *
176         * @param resourceType resourceType of the resource operate on
177         * @param resourceInterface interface type of the resource to operate on
178         * @param queryParametersMap map which can have the query parameter name and value
179         * @param attributeHandler handles callback
180         *        The callback function will be invoked with a map of attribute name and values.
181         *        The callback function will be invoked with a list of URIs if 'get' is invoked on a
182         *        resource container (list will be empty if not a container)
183         *        The callback function will also have the result from this Get operation. This will
184         *        have error codes
185         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
186         * @note OCStackResult is defined in ocstack.h.
187         * @par Example:
188         * Consider resource "a/home" (with link interface and resource type as home) contains links
189         *  to "a/kitchen" and "a/room".
190         * -# get("home", Link_Interface, &onGet)
191         * @par
192         * Callback onGet will receive a) Empty attribute map because there are no attributes for
193         * a/home b) list with
194         * full URI of "a/kitchen" and "a/room" resources and their properties c) error code for GET
195         * operation
196         * @note A resource may contain single or multiple resource types. Also, a resource may
197         * contain single or multiple interfaces.
198         * Currently, single GET request is allowed to do operate on single resource type or resource
199         * interface. In future, a single GET
200         * can operate on multiple resource types and interfaces.
201         * @note A client can traverse a tree or graph by doing successive GETs on the returned
202         * resources at a node.
203         *
204         */
205         OCStackResult get(const std::string& resourceType, const std::string& resourceInterface,
206                         const QueryParamsMap& queryParametersMap, GetCallback attributeHandler);
207         /**
208         * Function to get the attributes of a resource.
209         *
210         * @param resourceType resourceType of the resource operate on
211         * @param resourceInterface interface type of the resource to operate on
212         * @param queryParametersMap map which can have the query parameter name and value
213         * @param attributeHandler handles callback
214         *        The callback function will be invoked with a map of attribute name and values.
215         *        The callback function will be invoked with a list of URIs if 'get' is invoked on a
216         *        resource container (list will be empty if not a container)
217         *        The callback function will also have the result from this Get operation. This will
218         *        have error codes
219         * @param QoS the quality of communication
220         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
221         * note OCStackResult is defined in ocstack.h.
222         * @par Example:
223         * Consider resource "a/home" (with link interface and resource type as home) contains links
224         *  to "a/kitchen" and "a/room".
225         * -# get("home", Link_Interface, &onGet)
226         * @par
227         * Callback onGet will receive a) Empty attribute map because there are no attributes for
228         * a/home b) list with
229         * full URI of "a/kitchen" and "a/room" resources and their properties c) error code for GET
230         * operation
231         * @note A resource may contain single or multiple resource types. Also, a resource may
232         * contain single or multiple interfaces.
233         * Currently, single GET request is allowed to do operate on single resource type or resource
234         * interface. In future, a single GET
235         * can operate on multiple resource types and interfaces.
236         * @note A client can traverse a tree or graph by doing successive GETs on the returned
237         * resources at a node.
238         *
239         */
240         OCStackResult get(const std::string& resourceType, const std::string& resourceInterface,
241                         const QueryParamsMap& queryParametersMap, GetCallback attributeHandler,
242                         QualityOfService QoS);
243
244         /**
245         * Function to set the representation of a resource (via PUT)
246         *
247         * @param representation which can either have all the attribute names and values
248                  (which will represent entire state of the resource) or a
249         *        set of attribute names and values which needs to be modified
250         *        The callback function will be invoked with a map of attribute name and values.
251         *        The callback function will also have the result from this Put operation
252         *        This will have error codes
253         * @param queryParametersMap map which can have the query parameter name and value
254         * @param attributeHandler attribute handler
255         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
256         * @note OCStackResult is defined in ocstack.h.
257         *
258         */
259         OCStackResult put(const OCRepresentation& representation,
260                         const QueryParamsMap& queryParametersMap, PutCallback attributeHandler);
261         /**
262         * Function to set the representation of a resource (via PUT)
263         *
264         * @param representation which can either have all the attribute names and values
265                  (which will represent entire state of the resource) or a
266         *        set of attribute names and values which needs to be modified
267         *        The callback function will be invoked with a map of attribute name and values.
268         *        The callback function will also have the result from this Put operation
269         *        This will have error codes
270         * @param queryParametersMap map which can have the query parameter name and value
271         * @param attributeHandler attribute handler
272         * @param QoS the quality of communication
273         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
274         * @note OCStackResult is defined in ocstack.h.
275         *
276         */
277         OCStackResult put(const OCRepresentation& representation,
278                         const QueryParamsMap& queryParametersMap, PutCallback attributeHandler,
279                         QualityOfService QoS);
280
281         /**
282         * Function to set the attributes of a resource (via PUT)
283         *
284         * @param resourceType resource type of the resource to operate on
285         * @param resourceInterface interface type of the resource to operate on
286         * @param representation representation of the resource
287         * @param queryParametersMap Map which can have the query parameter name and value
288         * @param attributeHandler attribute handler
289         *        The callback function will be invoked with a map of attribute name and values.
290         *        The callback function will also have the result from this Put operation
291         *        This will have error codes.
292         *        The Representation parameter maps which can either have all the attribute names
293         *        and values
294         *        (which will represent entire state of the resource) or a
295         *        set of attribute names and values which needs to be modified
296         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
297         * @note OCStackResult is defined in ocstack.h.
298         *
299         */
300         OCStackResult put(const std::string& resourceType, const std::string& resourceInterface,
301                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
302                         PutCallback attributeHandler);
303         /**
304         * Function to set the attributes of a resource (via PUT)
305         * @param resourceType resource type of the resource to operate on
306         * @param resourceInterface interface type of the resource to operate on
307         * @param representation representation of the resource
308         * @param queryParametersMap Map which can have the query parameter name and value
309         * @param attributeHandler attribute handler
310         *        The callback function will be invoked with a map of attribute name and values.
311         *        The callback function will also have the result from this Put operation
312         *        This will have error codes.
313         *        The Representation parameter maps which can either have all the attribute names
314         *        and values
315         *        (which will represent entire state of the resource) or a
316         *        set of attribute names and values which needs to be modified
317         * @param QoS the quality of communication
318         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
319         * @note OCStackResult is defined in ocstack.h.
320         *
321         */
322         OCStackResult put(const std::string& resourceType, const std::string& resourceInterface,
323                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
324                         PutCallback attributeHandler, QualityOfService QoS);
325
326         /**
327         * Function to post on a resource
328         *
329         * @param representation which can either have all the attribute names and values
330         *        (which will represent entire state of the resource) or a
331         *        set of attribute names and values which needs to be modified
332         *        The callback function will be invoked with a map of attribute name and values.
333         *        The callback function will also have the result from this Put operation
334         *        This will have error codes
335         * @param queryParametersMap map which can have the query parameter name and value
336         * @param attributeHandler attribute handler
337         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
338         * @note OCStackResult is defined in ocstack.h.
339         */
340         OCStackResult post(const OCRepresentation& representation,
341                         const QueryParamsMap& queryParametersMap, PostCallback attributeHandler);
342         /**
343         * Function to post on a resource
344         *
345         * @param representation which can either have all the attribute names and values
346         *        (which will represent entire state of the resource) or a
347         *        set of attribute names and values which needs to be modified
348         *        The callback function will be invoked with a map of attribute name and values.
349         *        The callback function will also have the result from this Put operation
350         *        This will have error codes
351         * @param queryParametersMap map which can have the query parameter name and value
352         * @param attributeHandler attribute handler
353         * @param QoS the quality of communication
354         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
355         * @note OCStackResult is defined in ocstack.h.
356         */
357         OCStackResult post(const OCRepresentation& representation,
358                         const QueryParamsMap& queryParametersMap, PostCallback attributeHandler,
359                         QualityOfService QoS);
360
361         /**
362         * Function to post on a resource
363         *
364         * @param resourceType resource type of the resource to operate on
365         * @param resourceInterface interface type of the resource to operate on
366         * @param representation representation of the resource
367         * @param queryParametersMap Map which can have the query parameter name and value
368         * @param attributeHandler attribute handler
369         *        The callback function will be invoked with a map of attribute name and values.
370         *        The callback function will also have the result from this Put operation
371         *        This will have error codes.
372         *        The Representation parameter maps which can either have all the attribute names
373         *        and values
374         *        (which will represent entire state of the resource) or a
375         *        set of attribute names and values which needs to be modified
376         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
377         * @note OCStackResult is defined in ocstack.h.
378         *
379         */
380         OCStackResult post(const std::string& resourceType, const std::string& resourceInterface,
381                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
382                         PostCallback attributeHandler);
383         /**
384         * Function to post on a resource
385         *
386         * @param resourceType resource type of the resource to operate on
387         * @param resourceInterface interface type of the resource to operate on
388         * @param representation representation of the resource
389         * @param queryParametersMap Map which can have the query parameter name and value
390         * @param attributeHandler attribute handler
391         *        The callback function will be invoked with a map of attribute name and values.
392         *        The callback function will also have the result from this Put operation
393         *        This will have error codes.
394         *        The Representation parameter maps which can either have all the attribute names
395         *        and values
396         *        (which will represent entire state of the resource) or a
397         *        set of attribute names and values which needs to be modified
398         * @param QoS the quality of communication
399         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
400         * @note OCStackResult is defined in ocstack.h.
401         *
402         */
403         OCStackResult post(const std::string& resourceType, const std::string& resourceInterface,
404                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
405                         PostCallback attributeHandler, QualityOfService QoS);
406
407         /**
408         * Function to perform DELETE operation
409         *
410         * @param deleteHandler handles callback
411         *        The callback function will have headerOptions and result from this Delete
412         *        operation. This will have error codes
413         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
414         * @note OCStackResult is defined in ocstack.h.
415         *
416         */
417         OCStackResult deleteResource(DeleteCallback deleteHandler);
418         OCStackResult deleteResource(DeleteCallback deleteHandler, QualityOfService QoS);
419
420         /**
421         * Function to set observation on the resource
422         *
423         * @param observeType allows the client to specify how it wants to observe.
424         * @param queryParametersMap map which can have the query parameter name and value
425         * @param observeHandler handles callback
426         *        The callback function will be invoked with a map of attribute name and values.
427         *        The callback function will also have the result from this observe operation
428         *        This will have error codes
429         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
430         * @note OCStackResult is defined in ocstack.h.
431         *
432         */
433         OCStackResult observe(ObserveType observeType, const QueryParamsMap& queryParametersMap,
434                         ObserveCallback observeHandler);
435         /**
436         * Function to set observation on the resource
437         *
438         * @param observeType allows the client to specify how it wants to observe.
439         * @param queryParametersMap map which can have the query parameter name and value
440         * @param observeHandler handles callback
441         *        The callback function will be invoked with a map of attribute name and values.
442         *        The callback function will also have the result from this observe operation
443         *        This will have error codes
444         * @param qos the quality of communication
445         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
446         * @note OCStackResult is defined in ocstack.h.
447         *
448         */
449         OCStackResult observe(ObserveType observeType, const QueryParamsMap& queryParametersMap,
450                         ObserveCallback observeHandler, QualityOfService qos);
451
452         /**
453         * Function to cancel the observation on the resource
454         *
455         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
456         * @note OCStackResult is defined in ocstack.h.
457         *
458         */
459         OCStackResult cancelObserve();
460         OCStackResult cancelObserve(QualityOfService qos);
461
462         /**
463         * Function to set header information.
464         * @param headerOptions std::vector where header information(header optionID and optionData
465         * is passed
466         *
467         * @note Once the headers information is set, it will be applicable to GET, PUT and observe
468         * request.
469         * setHeaderOptions can be used multiple times if headers need to be modifed by the client.
470         * Latest headers will be used to send in the request. <br>
471         * @note Initial support is only for two headers. If headerMap consists of more than two
472         * header options, they will be ignored. <br>
473         * Use unsetHeaderOptions API to clear the header information.
474         */
475         void setHeaderOptions(const HeaderOptions& headerOptions);
476
477         /**
478         * Function to unset header options.
479         */
480         void unsetHeaderOptions();
481
482         /**
483         * Function to get the host address of this resource
484         * @return std::string host address
485         * @note This might or might not be exposed in future due to security concerns
486         */
487         std::string host() const;
488
489         /**
490         * Function to get the endpoints information of this resource
491         * @return std::vector<std::string> endpoints information
492         */
493         std::vector<std::string> getAllHosts() const;
494
495         /**
496          * Function to get the header options information from response
497          * @return headerOptions HeaderOptions vector consisting of OCHeaderOption objects
498          */
499         HeaderOptions getServerHeaderOptions() const;
500
501         /**
502         * Function to get the URI for this resource
503         * @return std::string resource URI
504         */
505         std::string uri() const;
506
507         /**
508         * Function to get the connectivity type of this resource
509         * @return enum connectivity type (flags and adapter)
510         */
511         OCConnectivityType connectivityType() const;
512
513         /**
514         * Function to provide ability to check if this resource is observable or not
515         * @return bool true indicates resource is observable; false indicates resource is
516         *         not observable.
517         */
518         bool isObservable() const;
519
520         /**
521         * Function to change host of this reource
522         * @return std::string New host Address.
523         *         not observable.
524         */
525         std::string setHost(const std::string& host);
526 #ifdef WITH_MQ
527         /**
528         * Function to provide ability to check if this resource is publisher or not
529         * @return bool true indicates resource is publisher; false indicates resource is
530         *         not publisher.
531         */
532         bool isPublish() const;
533 #endif
534
535         /**
536         * Function to get the list of resource types
537         * @return vector of resource types
538         */
539         std::vector<std::string> getResourceTypes() const;
540
541         /**
542         * Function to get the list of resource interfaces
543         * @return vector of resource interface
544         */
545         std::vector<std::string> getResourceInterfaces(void) const;
546
547         // TODO-CA Revisit this since we are exposing two identifiers
548         /**
549         * Function to get a unique identifier for this
550         * resource across network interfaces.  This will
551         * be guaranteed unique for every resource-per-server
552         * independent of how this was discovered.
553         * @return OCResourceIdentifier object, which can
554         * be used for all comparison and hashing.
555         */
556         OCResourceIdentifier uniqueIdentifier() const;
557
558         /**
559         * Function to get a string representation of the resource's server ID.
560         * This is unique per- server independent on how it was discovered.
561         */
562         std::string sid() const;
563
564 #ifdef WITH_MQ
565         /**
566         * Function to discovery Topics from MQ Broker.
567         *
568         * @param queryParametersMap map which can have the query parameter name and value
569         * @param attributeHandler handles callback
570         * @param qos the quality of communication
571         *
572         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
573         * @note OCStackResult is defined in ocstack.h.
574         *
575         */
576         OCStackResult discoveryMQTopics(const QueryParamsMap& queryParametersMap,
577                                         MQTopicCallback attributeHandler,
578                                         QualityOfService qos);
579         /**
580         * Function to create Topic into MQ Broker.
581         * SubTopic is also created through this method.
582         *
583         * @param rep representation of the topic
584         * @param topicUri new URI of the topic which want to create
585         * @param queryParametersMap map which can have the query parameter name and value
586         * @param attributeHandler handles callback
587         * @param qos the quality of communication
588         *
589         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
590         * @note OCStackResult is defined in ocstack.h.
591         *
592         */
593         OCStackResult createMQTopic(const OCRepresentation& rep,
594                                     const std::string& topicUri,
595                                     const QueryParamsMap& queryParametersMap,
596                                     MQTopicCallback attributeHandler,
597                                     QualityOfService qos);
598 #endif
599 #ifdef MQ_SUBSCRIBER
600         /**
601         * Function to subscribe Topic to MQ Broker.
602         *
603         * @param observeType allows the client to specify how it wants to observe.
604         * @param queryParametersMap map which can have the query parameter name and value
605         * @param observeHandler handles callback
606         * @param qos the quality of communication
607         *
608         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
609         * @note OCStackResult is defined in ocstack.h.
610         *
611         */
612         OCStackResult subscribeMQTopic(ObserveType observeType,
613                                        const QueryParamsMap& queryParametersMap,
614                                        ObserveCallback observeHandler,
615                                        QualityOfService qos);
616
617         /**
618         * Function to unsubscribe Topic to MQ Broker.
619         *
620         * @param qos the quality of communication
621         *
622         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
623         * @note OCStackResult is defined in ocstack.h.
624         *
625         */
626         OCStackResult unsubscribeMQTopic(QualityOfService qos);
627
628         /**
629         * Function to request publish to MQ publisher.
630         * Publisher can confirm the request message as key:"req_pub" and value:"true".
631         *
632         * @param queryParametersMap map which can have the query parameter name and value
633         * @param attributeHandler handles callback
634         * @param qos the quality of communication
635         *
636         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
637         * @note OCStackResult is defined in ocstack.h.
638         *
639         */
640         OCStackResult requestMQPublish(const QueryParamsMap& queryParametersMap,
641                                        PostCallback attributeHandler,
642                                        QualityOfService qos);
643 #endif
644 #ifdef MQ_PUBLISHER
645         /**
646         * Function to publish Topic information into MQ Broker.
647         *
648         * @param rep representation of the topic
649         * @param queryParametersMap map which can have the query parameter name and value
650         * @param attributeHandler handles callback
651         * @param qos the quality of communication
652         *
653         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
654         * @note OCStackResult is defined in ocstack.h.
655         *
656         */
657         OCStackResult publishMQTopic(const OCRepresentation& rep,
658                                      const QueryParamsMap& queryParametersMap,
659                                      PostCallback attributeHandler,
660                                      QualityOfService qos);
661 #endif
662         // overloaded operators allow for putting into a 'set'
663         // the uniqueidentifier allows for putting into a hash
664         bool operator==(const OCResource &other) const;
665
666         bool operator!=(const OCResource &other) const;
667
668         bool operator<(const OCResource &other) const;
669
670         bool operator>(const OCResource &other) const;
671
672         bool operator<=(const OCResource &other) const;
673
674         bool operator>=(const OCResource &other) const;
675
676     private:
677         std::weak_ptr<IClientWrapper> m_clientWrapper;
678         std::string m_uri;
679         OCResourceIdentifier m_resourceId;
680         OCDevAddr m_devAddr;
681         bool m_useHostString;
682         bool m_isCollection;
683         uint8_t m_property;
684         std::vector<std::string> m_resourceTypes;
685         std::vector<std::string> m_interfaces;
686         std::vector<std::string> m_children;
687         std::vector<std::string> m_endpoints;
688         HeaderOptions m_serverHeaderOptions;
689         OCDoHandle m_observeHandle;
690         HeaderOptions m_headerOptions;
691
692     private:
693         OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
694                     const OCDevAddr& devAddr, const std::string& uri,
695                     const std::string& serverId, uint8_t property,
696                     const std::vector<std::string>& resourceTypes,
697                     const std::vector<std::string>& interfaces);
698
699         OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
700                     const OCDevAddr& devAddr, const std::string& uri,
701                     const std::string& serverId, uint8_t property,
702                     const std::vector<std::string>& resourceTypes,
703                     const std::vector<std::string>& interfaces,
704                     const std::vector<std::string>& endpoints,
705                     const HeaderOptions& serverHeaderOptions);
706
707         OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
708                     const std::string& host, const std::string& uri,
709                     const std::string& serverId,
710                     OCConnectivityType connectivityType, uint8_t property,
711                     const std::vector<std::string>& resourceTypes,
712                     const std::vector<std::string>& interfaces);
713
714         OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
715                     const std::string& host, const std::string& uri,
716                     const std::string& serverId,
717                     OCConnectivityType connectivityType, uint8_t property,
718                     const std::vector<std::string>& resourceTypes,
719                     const std::vector<std::string>& interfaces,
720                     const std::vector<std::string>& endpoints);
721     };
722
723 } // namespace OC
724
725 #endif // OC_RESOURCE_H
726