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_observeHandle(std::move(m_observeHandle)),
 127             m_headerOptions(std::move(m_headerOptions))
 128         {
 129         }
 130 #else
 131         OCResource(OCResource&&) = default;
 132 #endif
 133         // Explicitly delete the copy ctor since VS2013 would try to generate one, and
 134         // the standard says that defaulting the move ctor should delete the copy ctor.
 135         OCResource(const OCResource&) = delete;
 136
 137         // We cannot support copy/move assigns since OCResourceIdentifier doesn't.
 138         OCResource& operator=(OCResource&&) = delete;
 139         OCResource& operator=(const OCResource&) = delete;
 140
 141         /**
 142         * Virtual destructor
 143         */
 144         virtual ~OCResource(void);
 145
 146         /**
 147         * Function to get the attributes of a resource.
 148         * @param queryParametersMap map which can have the query parameter name and value
 149         * @param attributeHandler handles callback
 150         *        The callback function will be invoked with a map of attribute name and values.
 151         *        The callback function will also have the result from this Get operation
 152         *        This will have error codes
 153         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 154         * @note OCStackResult is defined in ocstack.h.
 155         */
 156         OCStackResult get(const QueryParamsMap& queryParametersMap, GetCallback attributeHandler);
 157         /**
 158         * Function to get the attributes of a resource.
 159         * @param queryParametersMap map which can have the query parameter name and value
 160         * @param attributeHandler handles callback
 161         *        The callback function will be invoked with a map of attribute name and values.
 162         *        The callback function will also have the result from this Get operation
 163         *        This will have error codes
 164         * @param QoS the quality of communication
 165         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 166         * @note OCStackResult is defined in ocstack.h.
 167         */
 168         OCStackResult get(const QueryParamsMap& queryParametersMap, GetCallback attributeHandler,
 169                           QualityOfService QoS);
 170
 171         /**
 172         * Function to get the attributes of a resource.
 173         *
 174         * @param resourceType resourceType of the resource operate on
 175         * @param resourceInterface interface type of the resource to operate on
 176         * @param queryParametersMap map which can have the query parameter name and value
 177         * @param attributeHandler handles callback
 178         *        The callback function will be invoked with a map of attribute name and values.
 179         *        The callback function will be invoked with a list of URIs if 'get' is invoked on a
 180         *        resource container (list will be empty if not a container)
 181         *        The callback function will also have the result from this Get operation. This will
 182         *        have error codes
 183         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 184         * @note OCStackResult is defined in ocstack.h.
 185         * @par Example:
 186         * Consider resource "a/home" (with link interface and resource type as home) contains links
 187         *  to "a/kitchen" and "a/room".
 188         * -# get("home", Link_Interface, &onGet)
 189         * @par
 190         * Callback onGet will receive a) Empty attribute map because there are no attributes for
 191         * a/home b) list with
 192         * full URI of "a/kitchen" and "a/room" resources and their properties c) error code for GET
 193         * operation
 194         * @note A resource may contain single or multiple resource types. Also, a resource may
 195         * contain single or multiple interfaces.
 196         * Currently, single GET request is allowed to do operate on single resource type or resource
 197         * interface. In future, a single GET
 198         * can operate on multiple resource types and interfaces.
 199         * @note A client can traverse a tree or graph by doing successive GETs on the returned
 200         * resources at a node.
 201         *
 202         */
 203         OCStackResult get(const std::string& resourceType, const std::string& resourceInterface,
 204                         const QueryParamsMap& queryParametersMap, GetCallback attributeHandler);
 205         /**
 206         * Function to get the attributes of a resource.
 207         *
 208         * @param resourceType resourceType of the resource operate on
 209         * @param resourceInterface interface type of the resource to operate on
 210         * @param queryParametersMap map which can have the query parameter name and value
 211         * @param attributeHandler handles callback
 212         *        The callback function will be invoked with a map of attribute name and values.
 213         *        The callback function will be invoked with a list of URIs if 'get' is invoked on a
 214         *        resource container (list will be empty if not a container)
 215         *        The callback function will also have the result from this Get operation. This will
 216         *        have error codes
 217         * @param QoS the quality of communication
 218         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 219         * note OCStackResult is defined in ocstack.h.
 220         * @par Example:
 221         * Consider resource "a/home" (with link interface and resource type as home) contains links
 222         *  to "a/kitchen" and "a/room".
 223         * -# get("home", Link_Interface, &onGet)
 224         * @par
 225         * Callback onGet will receive a) Empty attribute map because there are no attributes for
 226         * a/home b) list with
 227         * full URI of "a/kitchen" and "a/room" resources and their properties c) error code for GET
 228         * operation
 229         * @note A resource may contain single or multiple resource types. Also, a resource may
 230         * contain single or multiple interfaces.
 231         * Currently, single GET request is allowed to do operate on single resource type or resource
 232         * interface. In future, a single GET
 233         * can operate on multiple resource types and interfaces.
 234         * @note A client can traverse a tree or graph by doing successive GETs on the returned
 235         * resources at a node.
 236         *
 237         */
 238         OCStackResult get(const std::string& resourceType, const std::string& resourceInterface,
 239                         const QueryParamsMap& queryParametersMap, GetCallback attributeHandler,
 240                         QualityOfService QoS);
 241
 242         /**
 243         * Function to set the representation of a resource (via PUT)
 244         *
 245         * @param representation which can either have all the attribute names and values
 246                  (which will represent entire state of the resource) or a
 247         *        set of attribute names and values which needs to be modified
 248         *        The callback function will be invoked with a map of attribute name and values.
 249         *        The callback function will also have the result from this Put operation
 250         *        This will have error codes
 251         * @param queryParametersMap map which can have the query parameter name and value
 252         * @param attributeHandler attribute handler
 253         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 254         * @note OCStackResult is defined in ocstack.h.
 255         *
 256         */
 257         OCStackResult put(const OCRepresentation& representation,
 258                         const QueryParamsMap& queryParametersMap, PutCallback attributeHandler);
 259         /**
 260         * Function to set the representation of a resource (via PUT)
 261         *
 262         * @param representation which can either have all the attribute names and values
 263                  (which will represent entire state of the resource) or a
 264         *        set of attribute names and values which needs to be modified
 265         *        The callback function will be invoked with a map of attribute name and values.
 266         *        The callback function will also have the result from this Put operation
 267         *        This will have error codes
 268         * @param queryParametersMap map which can have the query parameter name and value
 269         * @param attributeHandler attribute handler
 270         * @param QoS the quality of communication
 271         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 272         * @note OCStackResult is defined in ocstack.h.
 273         *
 274         */
 275         OCStackResult put(const OCRepresentation& representation,
 276                         const QueryParamsMap& queryParametersMap, PutCallback attributeHandler,
 277                         QualityOfService QoS);
 278
 279         /**
 280         * Function to set the attributes of a resource (via PUT)
 281         *
 282         * @param resourceType resource type of the resource to operate on
 283         * @param resourceInterface interface type of the resource to operate on
 284         * @param representation representation of the resource
 285         * @param queryParametersMap Map which can have the query parameter name and value
 286         * @param attributeHandler attribute handler
 287         *        The callback function will be invoked with a map of attribute name and values.
 288         *        The callback function will also have the result from this Put operation
 289         *        This will have error codes.
 290         *        The Representation parameter maps which can either have all the attribute names
 291         *        and values
 292         *        (which will represent entire state of the resource) or a
 293         *        set of attribute names and values which needs to be modified
 294         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 295         * @note OCStackResult is defined in ocstack.h.
 296         *
 297         */
 298         OCStackResult put(const std::string& resourceType, const std::string& resourceInterface,
 299                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
 300                         PutCallback attributeHandler);
 301         /**
 302         * Function to set the attributes of a resource (via PUT)
 303         * @param resourceType resource type of the resource to operate on
 304         * @param resourceInterface interface type of the resource to operate on
 305         * @param representation representation of the resource
 306         * @param queryParametersMap Map which can have the query parameter name and value
 307         * @param attributeHandler attribute handler
 308         *        The callback function will be invoked with a map of attribute name and values.
 309         *        The callback function will also have the result from this Put operation
 310         *        This will have error codes.
 311         *        The Representation parameter maps which can either have all the attribute names
 312         *        and values
 313         *        (which will represent entire state of the resource) or a
 314         *        set of attribute names and values which needs to be modified
 315         * @param QoS the quality of communication
 316         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 317         * @note OCStackResult is defined in ocstack.h.
 318         *
 319         */
 320         OCStackResult put(const std::string& resourceType, const std::string& resourceInterface,
 321                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
 322                         PutCallback attributeHandler, QualityOfService QoS);
 323
 324         /**
 325         * Function to post on a resource
 326         *
 327         * @param representation which can either have all the attribute names and values
 328         *        (which will represent entire state of the resource) or a
 329         *        set of attribute names and values which needs to be modified
 330         *        The callback function will be invoked with a map of attribute name and values.
 331         *        The callback function will also have the result from this Put operation
 332         *        This will have error codes
 333         * @param queryParametersMap map which can have the query parameter name and value
 334         * @param attributeHandler attribute handler
 335         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 336         * @note OCStackResult is defined in ocstack.h.
 337         */
 338         OCStackResult post(const OCRepresentation& representation,
 339                         const QueryParamsMap& queryParametersMap, PostCallback attributeHandler);
 340         /**
 341         * Function to post on a resource
 342         *
 343         * @param representation which can either have all the attribute names and values
 344         *        (which will represent entire state of the resource) or a
 345         *        set of attribute names and values which needs to be modified
 346         *        The callback function will be invoked with a map of attribute name and values.
 347         *        The callback function will also have the result from this Put operation
 348         *        This will have error codes
 349         * @param queryParametersMap map which can have the query parameter name and value
 350         * @param attributeHandler attribute handler
 351         * @param QoS the quality of communication
 352         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 353         * @note OCStackResult is defined in ocstack.h.
 354         */
 355         OCStackResult post(const OCRepresentation& representation,
 356                         const QueryParamsMap& queryParametersMap, PostCallback attributeHandler,
 357                         QualityOfService QoS);
 358
 359         /**
 360         * Function to post on a resource
 361         *
 362         * @param resourceType resource type of the resource to operate on
 363         * @param resourceInterface interface type of the resource to operate on
 364         * @param representation representation of the resource
 365         * @param queryParametersMap Map which can have the query parameter name and value
 366         * @param attributeHandler attribute handler
 367         *        The callback function will be invoked with a map of attribute name and values.
 368         *        The callback function will also have the result from this Put operation
 369         *        This will have error codes.
 370         *        The Representation parameter maps which can either have all the attribute names
 371         *        and values
 372         *        (which will represent entire state of the resource) or a
 373         *        set of attribute names and values which needs to be modified
 374         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 375         * @note OCStackResult is defined in ocstack.h.
 376         *
 377         */
 378         OCStackResult post(const std::string& resourceType, const std::string& resourceInterface,
 379                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
 380                         PostCallback attributeHandler);
 381         /**
 382         * Function to post on a resource
 383         *
 384         * @param resourceType resource type of the resource to operate on
 385         * @param resourceInterface interface type of the resource to operate on
 386         * @param representation representation of the resource
 387         * @param queryParametersMap Map which can have the query parameter name and value
 388         * @param attributeHandler attribute handler
 389         *        The callback function will be invoked with a map of attribute name and values.
 390         *        The callback function will also have the result from this Put operation
 391         *        This will have error codes.
 392         *        The Representation parameter maps which can either have all the attribute names
 393         *        and values
 394         *        (which will represent entire state of the resource) or a
 395         *        set of attribute names and values which needs to be modified
 396         * @param QoS the quality of communication
 397         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 398         * @note OCStackResult is defined in ocstack.h.
 399         *
 400         */
 401         OCStackResult post(const std::string& resourceType, const std::string& resourceInterface,
 402                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
 403                         PostCallback attributeHandler, QualityOfService QoS);
 404
 405         /**
 406         * Function to perform DELETE operation
 407         *
 408         * @param deleteHandler handles callback
 409         *        The callback function will have headerOptions and result from this Delete
 410         *        operation. This will have error codes
 411         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 412         * @note OCStackResult is defined in ocstack.h.
 413         *
 414         */
 415         OCStackResult deleteResource(DeleteCallback deleteHandler);
 416         OCStackResult deleteResource(DeleteCallback deleteHandler, QualityOfService QoS);
 417
 418         /**
 419         * Function to set observation on the resource
 420         *
 421         * @param observeType allows the client to specify how it wants to observe.
 422         * @param queryParametersMap map which can have the query parameter name and value
 423         * @param observeHandler handles callback
 424         *        The callback function will be invoked with a map of attribute name and values.
 425         *        The callback function will also have the result from this observe operation
 426         *        This will have error codes
 427         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 428         * @note OCStackResult is defined in ocstack.h.
 429         *
 430         */
 431         OCStackResult observe(ObserveType observeType, const QueryParamsMap& queryParametersMap,
 432                         ObserveCallback observeHandler);
 433         /**
 434         * Function to set observation on the resource
 435         *
 436         * @param observeType allows the client to specify how it wants to observe.
 437         * @param queryParametersMap map which can have the query parameter name and value
 438         * @param observeHandler handles callback
 439         *        The callback function will be invoked with a map of attribute name and values.
 440         *        The callback function will also have the result from this observe operation
 441         *        This will have error codes
 442         * @param qos the quality of communication
 443         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 444         * @note OCStackResult is defined in ocstack.h.
 445         *
 446         */
 447         OCStackResult observe(ObserveType observeType, const QueryParamsMap& queryParametersMap,
 448                         ObserveCallback observeHandler, QualityOfService qos);
 449
 450         /**
 451         * Function to cancel the observation on the resource
 452         *
 453         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 454         * @note OCStackResult is defined in ocstack.h.
 455         *
 456         */
 457         OCStackResult cancelObserve();
 458         OCStackResult cancelObserve(QualityOfService qos);
 459
 460         /**
 461         * Function to set header information.
 462         * @param headerOptions std::vector where header information(header optionID and optionData
 463         * is passed
 464         *
 465         * @note Once the headers information is set, it will be applicable to GET, PUT and observe
 466         * request.
 467         * setHeaderOptions can be used multiple times if headers need to be modifed by the client.
 468         * Latest headers will be used to send in the request. <br>
 469         * @note Initial support is only for two headers. If headerMap consists of more than two
 470         * header options, they will be ignored. <br>
 471         * Use unsetHeaderOptions API to clear the header information.
 472         */
 473         void setHeaderOptions(const HeaderOptions& headerOptions);
 474
 475         /**
 476         * Function to unset header options.
 477         */
 478         void unsetHeaderOptions();
 479
 480         /**
 481         * Function to get the host address of this resource
 482         * @return std::string host address
 483         * @note This might or might not be exposed in future due to security concerns
 484         */
 485         std::string host() const;
 486
 487         /**
 488         * Function to get the URI for this resource
 489         * @return std::string resource URI
 490         */
 491         std::string uri() const;
 492
 493         /**
 494         * Function to get the connectivity type of this resource
 495         * @return enum connectivity type (flags and adapter)
 496         */
 497         OCConnectivityType connectivityType() const;
 498
 499         /**
 500         * Function to provide ability to check if this resource is observable or not
 501         * @return bool true indicates resource is observable; false indicates resource is
 502         *         not observable.
 503         */
 504         bool isObservable() const;
 505
 506 #ifdef WITH_MQ
 507         /**
 508         * Function to provide ability to check if this resource is publisher or not
 509         * @return bool true indicates resource is publisher; false indicates resource is
 510         *         not publisher.
 511         */
 512         bool isPublish() const;
 513 #endif
 514
 515         /**
 516         * Function to get the list of resource types
 517         * @return vector of resource types
 518         */
 519         std::vector<std::string> getResourceTypes() const;
 520
 521         /**
 522         * Function to get the list of resource interfaces
 523         * @return vector of resource interface
 524         */
 525         std::vector<std::string> getResourceInterfaces(void) const;
 526
 527         // TODO-CA Revisit this since we are exposing two identifiers
 528         /**
 529         * Function to get a unique identifier for this
 530         * resource across network interfaces.  This will
 531         * be guaranteed unique for every resource-per-server
 532         * independent of how this was discovered.
 533         * @return OCResourceIdentifier object, which can
 534         * be used for all comparison and hashing.
 535         */
 536         OCResourceIdentifier uniqueIdentifier() const;
 537
 538         /**
 539         * Function to get a string representation of the resource's server ID.
 540         * This is unique per- server independent on how it was discovered.
 541         * @note The format of the return value is subject to change and will
 542         * likely change both in size and contents in the future.
 543         */
 544         std::string sid() const;
 545
 546 #ifdef WITH_MQ
 547         /**
 548         * Function to discovery Topics from MQ Broker.
 549         *
 550         * @param queryParametersMap map which can have the query parameter name and value
 551         * @param attributeHandler handles callback
 552
 553         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 554         * @note OCStackResult is defined in ocstack.h.
 555         *
 556         */
 557         OCStackResult discoveryMQTopics(const QueryParamsMap& queryParametersMap,
 558                                         FindCallback attributeHandler);
 559         /**
 560         * Function to create Topic into MQ Broker.
 561         * SubTopic is also created through this method.
 562         *
 563         * @param rep representation of the topic
 564         * @param topicUri new uri of the topic which want to create
 565         * @param queryParametersMap map which can have the query parameter name and value
 566         * @param attributeHandler handles callback
 567
 568         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 569         * @note OCStackResult is defined in ocstack.h.
 570         *
 571         */
 572         OCStackResult createMQTopic(const OCRepresentation& rep,
 573                                     const std::string& topicUri,
 574                                     const QueryParamsMap& queryParametersMap,
 575                                     MQCreateTopicCallback attributeHandler);
 576 #endif
 577 #ifdef MQ_SUBSCRIBER
 578         /**
 579         * Function to subscribe Topic to MQ Broker.
 580         *
 581         * @param observeType allows the client to specify how it wants to observe.
 582         * @param queryParametersMap map which can have the query parameter name and value
 583         * @param observeHandler handles callback
 584
 585         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 586         * @note OCStackResult is defined in ocstack.h.
 587         *
 588         */
 589         OCStackResult subscribeMQTopic(ObserveType observeType,
 590                                        const QueryParamsMap& queryParametersMap,
 591                                        ObserveCallback observeHandler);
 592
 593         /**
 594         * Function to unsubscribe Topic to MQ Broker.
 595         *
 596         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 597         * @note OCStackResult is defined in ocstack.h.
 598         *
 599         */
 600         OCStackResult unsubscribeMQTopic();
 601
 602         /**
 603         * Function to request publish to MQ publisher.
 604         * Publisher can confirm the request message as key:"req_pub" and value:"true".
 605         *
 606         * @param queryParametersMap map which can have the query parameter name and value
 607         * @param attributeHandler handles callback
 608
 609         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 610         * @note OCStackResult is defined in ocstack.h.
 611         *
 612         */
 613         OCStackResult requestMQPublish(const QueryParamsMap& queryParametersMap,
 614                                        PostCallback attributeHandler);
 615 #endif
 616 #ifdef MQ_PUBLISHER
 617         /**
 618         * Function to publish Topic information into MQ Broker.
 619         *
 620         * @param rep representation of the topic
 621         * @param queryParametersMap map which can have the query parameter name and value
 622         * @param attributeHandler handles callback
 623
 624         * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
 625         * @note OCStackResult is defined in ocstack.h.
 626         *
 627         */
 628         OCStackResult publishMQTopic(const OCRepresentation& rep,
 629                                      const QueryParamsMap& queryParametersMap,
 630                                      PostCallback attributeHandler);
 631 #endif
 632         // overloaded operators allow for putting into a 'set'
 633         // the uniqueidentifier allows for putting into a hash
 634         bool operator==(const OCResource &other) const;
 635
 636         bool operator!=(const OCResource &other) const;
 637
 638         bool operator<(const OCResource &other) const;
 639
 640         bool operator>(const OCResource &other) const;
 641
 642         bool operator<=(const OCResource &other) const;
 643
 644         bool operator>=(const OCResource &other) const;
 645
 646     private:
 647         void setHost(const std::string& host);
 648         std::weak_ptr<IClientWrapper> m_clientWrapper;
 649         std::string m_uri;
 650         OCResourceIdentifier m_resourceId;
 651         OCDevAddr m_devAddr;
 652         bool m_useHostString;
 653         bool m_isCollection;
 654         uint8_t m_property;
 655         std::vector<std::string> m_resourceTypes;
 656         std::vector<std::string> m_interfaces;
 657         std::vector<std::string> m_children;
 658         OCDoHandle m_observeHandle;
 659         HeaderOptions m_headerOptions;
 660
 661     private:
 662         OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
 663                     const OCDevAddr& devAddr, const std::string& uri,
 664                     const std::string& serverId, uint8_t property,
 665                     const std::vector<std::string>& resourceTypes,
 666                     const std::vector<std::string>& interfaces);
 667
 668         OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
 669                     const std::string& host, const std::string& uri,
 670                     const std::string& serverId,
 671                     OCConnectivityType connectivityType, uint8_t property,
 672                     const std::vector<std::string>& resourceTypes,
 673                     const std::vector<std::string>& interfaces);
 674     };
 675
 676 } // namespace OC
 677
 678 #endif // OC_RESOURCE_H
 679