Use `URI` all caps in documentation
[iotivity.git] / resource / include / OCResource.h
index ff4a080..c977a04 100644 (file)
@@ -25,8 +25,8 @@
  * Resource.
  */
 
-#ifndef __OCRESOURCE_H
-#define __OCRESOURCE_H
+#ifndef OC_RESOURCE_H_
+#define OC_RESOURCE_H_
 
 #include <memory>
 #include <random>
@@ -60,7 +60,15 @@ namespace OC
 
             OCResourceIdentifier(const OCResourceIdentifier&) = default;
 
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+            OCResourceIdentifier(OCResourceIdentifier&& o):
+                m_resourceUri(std::move(o.m_resourceUri)),
+                m_representation(o.m_representation)
+            {
+            }
+#else
             OCResourceIdentifier(OCResourceIdentifier&&) = default;
+#endif
 
             OCResourceIdentifier& operator=(const OCResourceIdentifier&) = delete;
 
@@ -84,7 +92,7 @@ namespace OC
                     const std::string& resourceUri );
 
         private:
-            uint32_t m_representation;
+            std::string m_representation;
             const std::string& m_resourceUri;
     };
 
@@ -103,8 +111,34 @@ namespace OC
     public:
         typedef std::shared_ptr<OCResource> Ptr;
 
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+        OCResource(OCResource&& o):
+            m_clientWrapper(std::move(o.m_clientWrapper)),
+            m_uri(std::move(o.m_uri)),
+            m_resourceId(std::move(o.m_resourceId)),
+            m_devAddr(std::move(o.m_devAddr)),
+            m_useHostString(o.m_useHostString),
+            m_property(o.m_property),
+            m_isCollection(o.m_isCollection),
+            m_resourceTypes(std::move(o.m_resourceTypes)),
+            m_interfaces(std::move(o.m_interfaces)),
+            m_children(std::move(m_children)),
+            m_endpoints(std::move(m_endpoints)),
+            m_serverHeaderOptions(std::move(m_serverHeaderOptions)),
+            m_observeHandle(std::move(m_observeHandle)),
+            m_headerOptions(std::move(m_headerOptions))
+        {
+        }
+#else
         OCResource(OCResource&&) = default;
-        OCResource& operator=(OCResource&&) = default;
+#endif
+        // Explicitly delete the copy ctor since VS2013 would try to generate one, and
+        // the standard says that defaulting the move ctor should delete the copy ctor.
+        OCResource(const OCResource&) = delete;
+
+        // We cannot support copy/move assigns since OCResourceIdentifier doesn't.
+        OCResource& operator=(OCResource&&) = delete;
+        OCResource& operator=(const OCResource&) = delete;
 
         /**
         * Virtual destructor
@@ -118,11 +152,21 @@ namespace OC
         *        The callback function will be invoked with a map of attribute name and values.
         *        The callback function will also have the result from this Get operation
         *        This will have error codes
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success.
-        * NOTE: OCStackResult is defined in ocstack.h.
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
         */
         OCStackResult get(const QueryParamsMap& queryParametersMap, GetCallback attributeHandler);
+        /**
+        * Function to get the attributes of a resource.
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler handles callback
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will also have the result from this Get operation
+        *        This will have error codes
+        * @param QoS the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        */
         OCStackResult get(const QueryParamsMap& queryParametersMap, GetCallback attributeHandler,
                           QualityOfService QoS);
 
@@ -138,33 +182,68 @@ namespace OC
         *        resource container (list will be empty if not a container)
         *        The callback function will also have the result from this Get operation. This will
         *        have error codes
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success. <br>
-        * NOTE: OCStackResult is defined in ocstack.h.<br>
-        * <b>Example:</b><br>
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        * @par Example:
         * Consider resource "a/home" (with link interface and resource type as home) contains links
         *  to "a/kitchen" and "a/room".
-        * Step 1: get("home", Link_Interface, &onGet)<br>
+        * -# get("home", Link_Interface, &onGet)
+        * @par
         * Callback onGet will receive a) Empty attribute map because there are no attributes for
         * a/home b) list with
         * full URI of "a/kitchen" and "a/room" resources and their properties c) error code for GET
-        * operation<br>
-        * NOTE: A resource may contain single or multiple resource types. Also, a resource may
-        * contain single or multiple interfaces.<br>
+        * operation
+        * @note A resource may contain single or multiple resource types. Also, a resource may
+        * contain single or multiple interfaces.
         * Currently, single GET request is allowed to do operate on single resource type or resource
-        * interface. In future, a single GET <br>
-        * can operate on multiple resource types and interfaces. <br>
-        * NOTE: A client can traverse a tree or graph by doing successive GETs on the returned
-        * resources at a node.<br>
+        * interface. In future, a single GET
+        * can operate on multiple resource types and interfaces.
+        * @note A client can traverse a tree or graph by doing successive GETs on the returned
+        * resources at a node.
+        *
         */
         OCStackResult get(const std::string& resourceType, const std::string& resourceInterface,
                         const QueryParamsMap& queryParametersMap, GetCallback attributeHandler);
+        /**
+        * Function to get the attributes of a resource.
+        *
+        * @param resourceType resourceType of the resource operate on
+        * @param resourceInterface interface type of the resource to operate on
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler handles callback
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will be invoked with a list of URIs if 'get' is invoked on a
+        *        resource container (list will be empty if not a container)
+        *        The callback function will also have the result from this Get operation. This will
+        *        have error codes
+        * @param QoS the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * note OCStackResult is defined in ocstack.h.
+        * @par Example:
+        * Consider resource "a/home" (with link interface and resource type as home) contains links
+        *  to "a/kitchen" and "a/room".
+        * -# get("home", Link_Interface, &onGet)
+        * @par
+        * Callback onGet will receive a) Empty attribute map because there are no attributes for
+        * a/home b) list with
+        * full URI of "a/kitchen" and "a/room" resources and their properties c) error code for GET
+        * operation
+        * @note A resource may contain single or multiple resource types. Also, a resource may
+        * contain single or multiple interfaces.
+        * Currently, single GET request is allowed to do operate on single resource type or resource
+        * interface. In future, a single GET
+        * can operate on multiple resource types and interfaces.
+        * @note A client can traverse a tree or graph by doing successive GETs on the returned
+        * resources at a node.
+        *
+        */
         OCStackResult get(const std::string& resourceType, const std::string& resourceInterface,
                         const QueryParamsMap& queryParametersMap, GetCallback attributeHandler,
                         QualityOfService QoS);
 
         /**
         * Function to set the representation of a resource (via PUT)
+        *
         * @param representation which can either have all the attribute names and values
                  (which will represent entire state of the resource) or a
         *        set of attribute names and values which needs to be modified
@@ -173,18 +252,35 @@ namespace OC
         *        This will have error codes
         * @param queryParametersMap map which can have the query parameter name and value
         * @param attributeHandler attribute handler
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success.
-        * NOTE: OCStackResult is defined in ocstack.h.
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
         */
         OCStackResult put(const OCRepresentation& representation,
                         const QueryParamsMap& queryParametersMap, PutCallback attributeHandler);
+        /**
+        * Function to set the representation of a resource (via PUT)
+        *
+        * @param representation which can either have all the attribute names and values
+                 (which will represent entire state of the resource) or a
+        *        set of attribute names and values which needs to be modified
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will also have the result from this Put operation
+        *        This will have error codes
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler attribute handler
+        * @param QoS the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
         OCStackResult put(const OCRepresentation& representation,
                         const QueryParamsMap& queryParametersMap, PutCallback attributeHandler,
                         QualityOfService QoS);
 
         /**
         * Function to set the attributes of a resource (via PUT)
+        *
         * @param resourceType resource type of the resource to operate on
         * @param resourceInterface interface type of the resource to operate on
         * @param representation representation of the resource
@@ -197,39 +293,74 @@ namespace OC
         *        and values
         *        (which will represent entire state of the resource) or a
         *        set of attribute names and values which needs to be modified
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success. <br>
-        * NOTE: OCStackResult is defined in ocstack.h. <br>
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
         */
         OCStackResult put(const std::string& resourceType, const std::string& resourceInterface,
                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
                         PutCallback attributeHandler);
+        /**
+        * Function to set the attributes of a resource (via PUT)
+        * @param resourceType resource type of the resource to operate on
+        * @param resourceInterface interface type of the resource to operate on
+        * @param representation representation of the resource
+        * @param queryParametersMap Map which can have the query parameter name and value
+        * @param attributeHandler attribute handler
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will also have the result from this Put operation
+        *        This will have error codes.
+        *        The Representation parameter maps which can either have all the attribute names
+        *        and values
+        *        (which will represent entire state of the resource) or a
+        *        set of attribute names and values which needs to be modified
+        * @param QoS the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
         OCStackResult put(const std::string& resourceType, const std::string& resourceInterface,
                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
                         PutCallback attributeHandler, QualityOfService QoS);
 
         /**
         * Function to post on a resource
+        *
         * @param representation which can either have all the attribute names and values
-                 (which will represent entire state of the resource) or a
+        *        (which will represent entire state of the resource) or a
         *        set of attribute names and values which needs to be modified
         *        The callback function will be invoked with a map of attribute name and values.
         *        The callback function will also have the result from this Put operation
         *        This will have error codes
         * @param queryParametersMap map which can have the query parameter name and value
         * @param attributeHandler attribute handler
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success.
-        * NOTE: OCStackResult is defined in ocstack.h.
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
         */
         OCStackResult post(const OCRepresentation& representation,
                         const QueryParamsMap& queryParametersMap, PostCallback attributeHandler);
+        /**
+        * Function to post on a resource
+        *
+        * @param representation which can either have all the attribute names and values
+        *        (which will represent entire state of the resource) or a
+        *        set of attribute names and values which needs to be modified
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will also have the result from this Put operation
+        *        This will have error codes
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler attribute handler
+        * @param QoS the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        */
         OCStackResult post(const OCRepresentation& representation,
                         const QueryParamsMap& queryParametersMap, PostCallback attributeHandler,
                         QualityOfService QoS);
 
         /**
         * Function to post on a resource
+        *
         * @param resourceType resource type of the resource to operate on
         * @param resourceInterface interface type of the resource to operate on
         * @param representation representation of the resource
@@ -242,49 +373,88 @@ namespace OC
         *        and values
         *        (which will represent entire state of the resource) or a
         *        set of attribute names and values which needs to be modified
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success. <br>
-        * NOTE: OCStackResult is defined in ocstack.h. <br>
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
         */
         OCStackResult post(const std::string& resourceType, const std::string& resourceInterface,
                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
                         PostCallback attributeHandler);
+        /**
+        * Function to post on a resource
+        *
+        * @param resourceType resource type of the resource to operate on
+        * @param resourceInterface interface type of the resource to operate on
+        * @param representation representation of the resource
+        * @param queryParametersMap Map which can have the query parameter name and value
+        * @param attributeHandler attribute handler
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will also have the result from this Put operation
+        *        This will have error codes.
+        *        The Representation parameter maps which can either have all the attribute names
+        *        and values
+        *        (which will represent entire state of the resource) or a
+        *        set of attribute names and values which needs to be modified
+        * @param QoS the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
         OCStackResult post(const std::string& resourceType, const std::string& resourceInterface,
                         const OCRepresentation& representation, const QueryParamsMap& queryParametersMap,
                         PostCallback attributeHandler, QualityOfService QoS);
 
         /**
         * Function to perform DELETE operation
-        * @param observeHandler handles callback
+        *
+        * @param deleteHandler handles callback
         *        The callback function will have headerOptions and result from this Delete
         *        operation. This will have error codes
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success.
-        * NOTE: OCStackResult is defined in ocstack.h.
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
         */
         OCStackResult deleteResource(DeleteCallback deleteHandler);
         OCStackResult deleteResource(DeleteCallback deleteHandler, QualityOfService QoS);
 
         /**
         * Function to set observation on the resource
+        *
         * @param observeType allows the client to specify how it wants to observe.
         * @param queryParametersMap map which can have the query parameter name and value
         * @param observeHandler handles callback
         *        The callback function will be invoked with a map of attribute name and values.
         *        The callback function will also have the result from this observe operation
         *        This will have error codes
-        * @param QualityOfService the quality of communication
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success.
-        * NOTE: OCStackResult is defined in ocstack.h.
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
         */
         OCStackResult observe(ObserveType observeType, const QueryParamsMap& queryParametersMap,
                         ObserveCallback observeHandler);
+        /**
+        * Function to set observation on the resource
+        *
+        * @param observeType allows the client to specify how it wants to observe.
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param observeHandler handles callback
+        *        The callback function will be invoked with a map of attribute name and values.
+        *        The callback function will also have the result from this observe operation
+        *        This will have error codes
+        * @param qos the quality of communication
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
         OCStackResult observe(ObserveType observeType, const QueryParamsMap& queryParametersMap,
                         ObserveCallback observeHandler, QualityOfService qos);
 
         /**
         * Function to cancel the observation on the resource
-        * @return OCStackResult return value of this API. Returns OC_STACK_OK if success.
-        * NOTE: OCStackResult is defined in ocstack.h.
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
         */
         OCStackResult cancelObserve();
         OCStackResult cancelObserve(QualityOfService qos);
@@ -294,34 +464,40 @@ namespace OC
         * @param headerOptions std::vector where header information(header optionID and optionData
         * is passed
         *
-        * NOTE: Once the headers information is set, it will be applicable to GET, PUT and observe
-        * request. <br>
+        * @note Once the headers information is set, it will be applicable to GET, PUT and observe
+        * request.
         * setHeaderOptions can be used multiple times if headers need to be modifed by the client.
         * Latest headers will be used to send in the request. <br>
-        * NOTE: Initial support is only for two headers. If headerMap consists of more than two
+        * @note Initial support is only for two headers. If headerMap consists of more than two
         * header options, they will be ignored. <br>
         * Use unsetHeaderOptions API to clear the header information.
         */
-        void setHeaderOptions(const HeaderOptions& headerOptions)
-        {
-            m_headerOptions = headerOptions;
-        }
+        void setHeaderOptions(const HeaderOptions& headerOptions);
 
         /**
         * Function to unset header options.
         */
-        void unsetHeaderOptions()
-        {
-            m_headerOptions.clear();
-        }
+        void unsetHeaderOptions();
 
         /**
         * Function to get the host address of this resource
         * @return std::string host address
-        * NOTE: This might or might not be exposed in future due to security concerns
+        * @note This might or might not be exposed in future due to security concerns
         */
         std::string host() const;
 
+        /**
+        * Function to get the endpoints information of this resource
+        * @return std::vector<std::string> endpoints information
+        */
+        std::vector<std::string> getAllHosts() const;
+
+        /**
+         * Function to get the header options information from response
+         * @return headerOptions HeaderOptions vector consisting of OCHeaderOption objects
+         */
+        HeaderOptions getServerHeaderOptions() const;
+
         /**
         * Function to get the URI for this resource
         * @return std::string resource URI
@@ -330,7 +506,7 @@ namespace OC
 
         /**
         * Function to get the connectivity type of this resource
-        * @return uint8_t connectivity type
+        * @return enum connectivity type (flags and adapter)
         */
         OCConnectivityType connectivityType() const;
 
@@ -341,23 +517,32 @@ namespace OC
         */
         bool isObservable() const;
 
+        /**
+        * Function to change host of this reource
+        * @return std::string New host Address.
+        *         not observable.
+        */
+        std::string setHost(const std::string& host);
+#ifdef WITH_MQ
+        /**
+        * Function to provide ability to check if this resource is publisher or not
+        * @return bool true indicates resource is publisher; false indicates resource is
+        *         not publisher.
+        */
+        bool isPublish() const;
+#endif
+
         /**
         * Function to get the list of resource types
         * @return vector of resource types
         */
-        std::vector<std::string> getResourceTypes() const
-        {
-            return m_resourceTypes;
-        }
+        std::vector<std::string> getResourceTypes() const;
 
         /**
         * Function to get the list of resource interfaces
         * @return vector of resource interface
         */
-        std::vector<std::string> getResourceInterfaces(void) const
-        {
-            return m_interfaces;
-        }
+        std::vector<std::string> getResourceInterfaces(void) const;
 
         // TODO-CA Revisit this since we are exposing two identifiers
         /**
@@ -373,11 +558,107 @@ namespace OC
         /**
         * Function to get a string representation of the resource's server ID.
         * This is unique per- server independent on how it was discovered.
-        * Note: The format of the return value is subject to change and will
-        * likely change both in size and contents in the future.
         */
         std::string sid() const;
 
+#ifdef WITH_MQ
+        /**
+        * Function to discovery Topics from MQ Broker.
+        *
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler handles callback
+        * @param qos the quality of communication
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
+        OCStackResult discoveryMQTopics(const QueryParamsMap& queryParametersMap,
+                                        MQTopicCallback attributeHandler,
+                                        QualityOfService qos);
+        /**
+        * Function to create Topic into MQ Broker.
+        * SubTopic is also created through this method.
+        *
+        * @param rep representation of the topic
+        * @param topicUri new URI of the topic which want to create
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler handles callback
+        * @param qos the quality of communication
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
+        OCStackResult createMQTopic(const OCRepresentation& rep,
+                                    const std::string& topicUri,
+                                    const QueryParamsMap& queryParametersMap,
+                                    MQTopicCallback attributeHandler,
+                                    QualityOfService qos);
+#endif
+#ifdef MQ_SUBSCRIBER
+        /**
+        * Function to subscribe Topic to MQ Broker.
+        *
+        * @param observeType allows the client to specify how it wants to observe.
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param observeHandler handles callback
+        * @param qos the quality of communication
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
+        OCStackResult subscribeMQTopic(ObserveType observeType,
+                                       const QueryParamsMap& queryParametersMap,
+                                       ObserveCallback observeHandler,
+                                       QualityOfService qos);
+
+        /**
+        * Function to unsubscribe Topic to MQ Broker.
+        *
+        * @param qos the quality of communication
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
+        OCStackResult unsubscribeMQTopic(QualityOfService qos);
+
+        /**
+        * Function to request publish to MQ publisher.
+        * Publisher can confirm the request message as key:"req_pub" and value:"true".
+        *
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler handles callback
+        * @param qos the quality of communication
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
+        OCStackResult requestMQPublish(const QueryParamsMap& queryParametersMap,
+                                       PostCallback attributeHandler,
+                                       QualityOfService qos);
+#endif
+#ifdef MQ_PUBLISHER
+        /**
+        * Function to publish Topic information into MQ Broker.
+        *
+        * @param rep representation of the topic
+        * @param queryParametersMap map which can have the query parameter name and value
+        * @param attributeHandler handles callback
+        * @param qos the quality of communication
+        *
+        * @return Returns  ::OC_STACK_OK on success, some other value upon failure.
+        * @note OCStackResult is defined in ocstack.h.
+        *
+        */
+        OCStackResult publishMQTopic(const OCRepresentation& rep,
+                                     const QueryParamsMap& queryParametersMap,
+                                     PostCallback attributeHandler,
+                                     QualityOfService qos);
+#endif
         // overloaded operators allow for putting into a 'set'
         // the uniqueidentifier allows for putting into a hash
         bool operator==(const OCResource &other) const;
@@ -396,25 +677,50 @@ namespace OC
         std::weak_ptr<IClientWrapper> m_clientWrapper;
         std::string m_uri;
         OCResourceIdentifier m_resourceId;
-        std::string m_host;
-        OCConnectivityType m_connectivityType;
-        bool m_isObservable;
+        OCDevAddr m_devAddr;
+        bool m_useHostString;
         bool m_isCollection;
+        uint8_t m_property;
         std::vector<std::string> m_resourceTypes;
         std::vector<std::string> m_interfaces;
         std::vector<std::string> m_children;
+        std::vector<std::string> m_endpoints;
+        HeaderOptions m_serverHeaderOptions;
         OCDoHandle m_observeHandle;
         HeaderOptions m_headerOptions;
 
     private:
-        OCResource(std::weak_ptr<IClientWrapper> clientWrapper, const std::string& host,
-            const std::string& uri, const std::string& serverId,
-            OCConnectivityType m_connectivityType, bool observable,
-            const std::vector<std::string>& resourceTypes,
-            const std::vector<std::string>& interfaces);
+        OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
+                    const OCDevAddr& devAddr, const std::string& uri,
+                    const std::string& serverId, uint8_t property,
+                    const std::vector<std::string>& resourceTypes,
+                    const std::vector<std::string>& interfaces);
+
+        OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
+                    const OCDevAddr& devAddr, const std::string& uri,
+                    const std::string& serverId, uint8_t property,
+                    const std::vector<std::string>& resourceTypes,
+                    const std::vector<std::string>& interfaces,
+                    const std::vector<std::string>& endpoints,
+                    const HeaderOptions& serverHeaderOptions);
+
+        OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
+                    const std::string& host, const std::string& uri,
+                    const std::string& serverId,
+                    OCConnectivityType connectivityType, uint8_t property,
+                    const std::vector<std::string>& resourceTypes,
+                    const std::vector<std::string>& interfaces);
+
+        OCResource(std::weak_ptr<IClientWrapper> clientWrapper,
+                    const std::string& host, const std::string& uri,
+                    const std::string& serverId,
+                    OCConnectivityType connectivityType, uint8_t property,
+                    const std::vector<std::string>& resourceTypes,
+                    const std::vector<std::string>& interfaces,
+                    const std::vector<std::string>& endpoints);
     };
 
 } // namespace OC
 
-#endif //__OCRESOURCE_H
+#endif // OC_RESOURCE_H