m2mobjectinstance.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 ARM Limited. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 * Licensed under the Apache License, Version 2.0 (the License); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef M2M_OBJECT_INSTANCE_H
#define M2M_OBJECT_INSTANCE_H

#include "mbed-client/m2mvector.h"
#include "mbed-client/m2mresource.h"

//FORWARD DECLARATION
typedef Vector<M2MResource *> M2MResourceList;
typedef Vector<M2MResourceInstance *> M2MResourceInstanceList;


class M2MObject;

class M2MObjectInstance : public M2MBase
{

friend class M2MObject;

private: // Constructor and destructor are private which means
         // that these objects can be created or
         // deleted only through function provided by M2MObject.

    M2MObjectInstance(M2MObject& parent,
                      const String &resource_type,
                      char *path,
                      bool external_blockwise_store = false);

    M2MObjectInstance(M2MObject& parent, const lwm2m_parameters_s* static_res);

    // Prevents the use of default constructor.
    M2MObjectInstance();

    // Prevents the use of assignment operator.
    M2MObjectInstance& operator=( const M2MObjectInstance& /*other*/ );

    // Prevents the use of copy constructor.
    M2MObjectInstance( const M2MObjectInstance& /*other*/ );

    virtual ~M2MObjectInstance();

public:

    M2MResource* create_static_resource(const lwm2m_parameters_s* static_res,
                                        M2MResourceInstance::ResourceType type);

    M2MResource* create_static_resource(const String &resource_name,
                                        const String &resource_type,
                                        M2MResourceInstance::ResourceType type,
                                        const uint8_t *value,
                                        const uint8_t value_length,
                                        bool multiple_instance = false,
                                        bool external_blockwise_store = false);

    M2MResource* create_dynamic_resource(const String &resource_name,
                                         const String &resource_type,
                                         M2MResourceInstance::ResourceType type,
                                         bool observable,
                                         bool multiple_instance = false,
                                         bool external_blockwise_store = false);

    M2MResource* create_dynamic_resource(const uint16_t resource_name,
                                         const char *resource_type,
                                         M2MResourceInstance::ResourceType type,
                                         bool observable,
                                         bool multiple_instance = false,
                                         bool external_blockwise_store = false);

    M2MResource* create_dynamic_resource(const lwm2m_parameters_s* static_res,
                                        M2MResourceInstance::ResourceType type,
                                        bool observable);

    M2MResourceInstance* create_static_resource_instance(const String &resource_name,
                                                         const String &resource_type,
                                                         M2MResourceInstance::ResourceType type,
                                                         const uint8_t *value,
                                                         const uint8_t value_length,
                                                         uint16_t instance_id,
                                                         bool external_blockwise_store = false);

    M2MResourceInstance* create_dynamic_resource_instance(const String &resource_name,
                                                          const String &resource_type,
                                                          M2MResourceInstance::ResourceType type,
                                                          bool observable,
                                                          uint16_t instance_id,
                                                          bool external_blockwise_store = false);

    bool remove_resource(const String &name);

    bool remove_resource(const char *name);

    bool remove_resource_instance(const String &resource_name,
                                          uint16_t instance_id);

    M2MResource* resource(const uint16_t resource_id) const;

    M2MResource* resource(const String &name) const;

    M2MResource* resource(const char *resource) const;

    const M2MResourceList& resources() const;

    uint16_t resource_count() const;

    uint16_t resource_count(const String& resource) const;

    uint16_t resource_count(const char *resource) const;

    virtual void add_observation_level(M2MBase::Observation observation_level);

    virtual void remove_observation_level(M2MBase::Observation observation_level);

    virtual M2MObservationHandler* observation_handler() const;

    virtual void set_observation_handler(M2MObservationHandler *handler);

    virtual sn_coap_hdr_s* handle_get_request(nsdl_s *nsdl,
                                              sn_coap_hdr_s *received_coap_header,
                                              M2MObservationHandler *observation_handler = NULL);
    virtual sn_coap_hdr_s* handle_put_request(nsdl_s *nsdl,
                                              sn_coap_hdr_s *received_coap_header,
                                              M2MObservationHandler *observation_handler,
                                              bool &execute_value_updated);

    virtual sn_coap_hdr_s* handle_post_request(nsdl_s *nsdl,
                                               sn_coap_hdr_s *received_coap_header,
                                               M2MObservationHandler *observation_handler,
                                               bool &execute_value_updated,
                                               sn_nsdl_addr_s *address = NULL);

    inline M2MObject& get_parent_object() const;

    // callback used from M2MResource/M2MResourceInstance
    void notification_update(M2MBase::Observation observation_level);

protected:
    virtual M2MBase *get_parent() const;

private:

    M2MBase::DataType convert_resource_type(M2MResourceInstance::ResourceType);

private:

    M2MObject      &_parent;

    M2MResourceList     _resource_list; // owned

    friend class Test_M2MObjectInstance;
    friend class Test_M2MObject;
    friend class Test_M2MDevice;
    friend class Test_M2MSecurity;
    friend class Test_M2MServer;
    friend class Test_M2MInterfaceFactory;
    friend class Test_M2MNsdlInterface;
    friend class Test_M2MFirmware;
    friend class Test_M2MTLVSerializer;
    friend class Test_M2MTLVDeserializer;
    friend class Test_M2MBase;
    friend class Test_M2MResource;
    friend class Test_M2MResourceInstance;
    friend class TestFactory;
};

inline M2MObject& M2MObjectInstance::get_parent_object() const
{
    return _parent;
}

#endif // M2M_OBJECT_INSTANCE_H