m2mresourcebase.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2021 Pelion. 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_RESOURCE_BASE_H
#define M2M_RESOURCE_BASE_H

#include "mbed-client/m2mbase.h"
#include "mbed-client/functionpointer.h"

// (space needed for -3.402823 × 10^38) + (magic decimal 6 digits added as no precision is added to "%f") + trailing zero
#define REGISTRY_FLOAT_STRING_MAX_LEN 48

// Forward declarations

class M2MBlockMessage;
class M2MCallbackAssociation;

typedef FP1<void, void *> execute_callback;
typedef void(*execute_callback_2)(void *arguments);

typedef FP0<void> notification_sent_callback;
typedef void(*notification_sent_callback_2)(void);

#ifndef DISABLE_BLOCK_MESSAGE
typedef FP1<void, M2MBlockMessage *> incoming_block_message_callback;
typedef FP3<void, const String &, uint8_t *&, uint32_t &> outgoing_block_message_callback;
#endif

class M2MResource;

class M2MResourceBase : public M2MBase {

    friend class M2MObjectInstance;
    friend class M2MResource;
    friend class M2MResourceInstance;

public:

    typedef enum {
        STRING,
        INTEGER,
        FLOAT,
        BOOLEAN,
        OPAQUE,
        TIME,
        OBJLINK
    } ResourceType;

    typedef void(*value_set_callback)(const M2MResourceBase *resource, uint8_t *value, const uint32_t value_length);

    typedef int(*read_resource_value_callback)(const M2MResourceBase &resource,
                                               void *buffer,
                                               size_t *buffer_size,
                                               void *client_args);

    typedef coap_response_code_e(*read_value_callback)(const M2MResourceBase &resource,
                                                       uint8_t *&buffer,
                                                       size_t &buffer_size,
                                                       size_t &total_size,
                                                       const size_t offset,
                                                       void *client_args);

    typedef int(*read_resource_value_size_callback)(const M2MResourceBase &resource,
                                                    size_t *buffer_size,
                                                    void *client_args);

    typedef bool(*write_resource_value_callback)(const M2MResourceBase &resource,
                                                 const uint8_t *buffer,
                                                 const size_t buffer_size,
                                                 void *client_args);

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

    M2MResourceBase(
        const lwm2m_parameters_s *s,
        M2MBase::DataType type);
    M2MResourceBase(
        const String &resource_name,
        M2MBase::Mode mode,
        const String &resource_type,
        M2MBase::DataType type,
        char *path,
        bool external_blockwise_store,
        bool multiple_instance);

    M2MResourceBase(
        const String &resource_name,
        M2MBase::Mode mode,
        const String &resource_type,
        M2MBase::DataType type,
        const uint8_t *value,
        const uint8_t value_length,
        char *path,
        bool external_blockwise_store,
        bool multiple_instance);

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

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

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

    virtual ~M2MResourceBase();

public:

    M2MResourceBase::ResourceType resource_instance_type() const;

    bool set_execute_function(execute_callback callback);

    bool set_execute_function(execute_callback_2 callback);

    bool set_resource_read_callback(read_resource_value_callback callback, void *client_args) m2m_deprecated;

    bool set_read_resource_function(read_value_callback callback, void *client_args);

    bool set_resource_read_size_callback(read_resource_value_size_callback callback, void *client_args);

    bool set_resource_write_callback(write_resource_value_callback callback, void *client_args);

    int read_resource_value(const M2MResourceBase &resource, void *buffer, size_t *buffer_len);

    int read_resource_value_size(const M2MResourceBase &resource, size_t *buffer_len);

    bool write_resource_value(const M2MResourceBase &resource, const uint8_t *buffer, const size_t buffer_size);

    bool set_value(const uint8_t *value, const uint32_t value_length);

    bool set_value_raw(uint8_t *value, const uint32_t value_length);

    bool set_value(int64_t value);

    bool set_value_float(float value);

    void clear_value();

    void execute(void *arguments);

    void get_value(uint8_t *&value, uint32_t &value_length);

    int64_t get_value_int() const;

    String get_value_string() const;

    float get_value_float() const;

    uint8_t *value() const;

    uint32_t value_length() const;

    void set_value_set_callback(value_set_callback callback);

    void update_value(uint8_t *value, const uint32_t value_length);

    void report_to_parents();

    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 uint16_t object_instance_id() const = 0;

    virtual const char *object_name() const = 0;

    virtual M2MResource &get_parent_resource() const = 0;

#ifndef DISABLE_BLOCK_MESSAGE

    bool set_incoming_block_message_callback(incoming_block_message_callback callback);

    bool set_outgoing_block_message_callback(outgoing_block_message_callback callback) m2m_deprecated;

    M2MBlockMessage *block_message() const;

#endif

    void publish_value_in_registration_msg(bool publish_value);

private:

    void report();

    void report_value_change();

    bool has_value_changed(const uint8_t *value, const uint32_t value_len);

    M2MResourceBase::ResourceType convert_data_type(M2MBase::DataType type) const;

    void read_data_from_application(M2MCallbackAssociation *item, nsdl_s *nsdl, const sn_coap_hdr_s *received_coap,
                                    sn_coap_hdr_s *coap_response, size_t &payload_len);

private:

#ifndef DISABLE_BLOCK_MESSAGE
    M2MBlockMessage     *_block_message_data;
#endif

    friend class Test_M2MResourceInstance;
    friend class Test_M2MResource;
    friend class Test_M2MObjectInstance;
    friend class Test_M2MObject;
    friend class Test_M2MDevice;
    friend class Test_M2MSecurity;
    friend class Test_M2MServer;
    friend class Test_M2MNsdlInterface;
    friend class Test_M2MTLVSerializer;
    friend class Test_M2MTLVDeserializer;
    friend class Test_M2MDynLog;
};

#endif // M2M_RESOURCE_BASE_H