meshXElement< meshx_model_send_param_header_t > Class Template Reference

Base class for MeshX elements. More...

#include <meshx_element_class.hpp>

Inheritance diagram for meshXElement< meshx_model_send_param_header_t >:

Public Member Functions
void	set_element_type (meshxElementType_t type)
meshxElementType_t	get_element_type (void) const final
	Get the element type.
void	set_element_variant (meshx_element_type_t variant)
meshx_element_type_t	get_element_variant (void) const final
	Get the element variant.
void	set_no_of_sig_models (uint8_t cnt)
uint8_t	get_no_of_sig_models (void) const final
	Get the number of SIG models supported by the element.
void	set_no_of_ven_models (uint8_t cnt)
uint8_t	get_no_of_ven_models (void) const final
	Get the number of Vendor models supported by the element.
std::vector< std::unique_ptr< meshXModelIF > > &	get_sig_models (void) final
	Get the SIG models vector.
std::vector< std::unique_ptr< meshXModelIF > > &	get_ven_models (void) final
	Get the Vendor models vector.
const char *	get_element_name (void) const override
	Get the name of the element.
virtual uint8_t	list_sig_models (void)
	Lists and creates all required SIG models for the element.
virtual uint8_t	list_ven_models (void)
	Lists and creates all required Vendor models for the element.
virtual meshx_err_t	element_state_change_notify (meshx_ptr_t param, size_t param_size)
	Notify element about state change.
void	register_element_ctx (meshx_ptr_t ctx, size_t ctx_size)
	Register element context structure.
meshx_ptr_t	get_element_ctx (void) const override
	Get the element context structure.
size_t	get_element_ctx_size (void) const override
	Get the size of the element context structure.
meshx_err_t	sig_plat_model_array_allocate (void)
	Allocate memory for SIG model platform array.
meshx_err_t	ven_plat_model_array_allocate (void)
	Allocate memory for Vendor model platform array.
std::vector< uint8_t > &	get_sig_model_array (void)
	Get the SIG model array.
std::vector< uint8_t > &	get_ven_model_array (void)
	Get the Vendor model array.
template<typename meshXModelT, typename... ConstructorsArgs>
meshx_err_t	add_sig_model (ConstructorsArgs &&... args)
	Add a SIG model to the element.
template<typename meshXModelT, typename... ConstructorsArgs>
meshx_err_t	add_ven_model (ConstructorsArgs &&... args)
	Add a Vendor model to the element.
uint8_t	get_sig_model_count (void) const
	Get the number of SIG models currently added to the element.
uint8_t	get_ven_model_count (void) const
	Get the number of Vendor models currently added to the element.
meshx_err_t	add_sig_models (void)
	Add multiple SIG models to the element.
meshx_err_t	add_ven_models (void)
	Add multiple Vendor models to the element.
meshx_err_t	add_models (void)
	Add both SIG and Vendor models to the element.
MESHX_MODEL *	get_sig_plat_model_array (void)
	Get the platform model array for SIG models.
MESHX_MODEL *	get_ven_plat_model_array (void)
	Get the platform model array for Vendor models.
	meshXElement (void)
	Default constructor for meshXElement.
	meshXElement (uint16_t element_idx)
	Constructor for meshXElement with element index.
	meshXElement (uint16_t element_idx, meshxElementType_t type, uint8_t no_of_sig_models, uint8_t no_of_ven_models)
	Constructor for meshXElement with element index, type, and model counts.
meshx_err_t	initialize (void) override
	Initialize the element.
meshx_err_t	reset (void) override
	Reset the element.
bool	is_initialized (void) const override
	Check if the element is initialized.
meshx_err_t	restore_nvs_context (void) override
	Restore the element's context from NVS.
bool	has_model (uint16_t model_id) const override
	Check if the element contains a specific model by ID.
void	on_baked (uint16_t index) override
	Called when the composition is baked to update the element's index.
	~meshXElement () override
Public Member Functions inherited from meshXElementIF
void	set_element_idx (uint16_t idx)
uint16_t	get_element_idx (void) const
virtual void	sync (control_task_msg_evt_t evt)=0
	Synchronize element state (Status broadcast or GET request).
virtual void	handle_config (control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t *params)=0
	Handle configuration server events (AppKey bind, Publication, etc.).
	meshXElementIF ()=delete
	meshXElementIF (uint16_t element_idx)
virtual	~meshXElementIF ()=default

Static Public Member Functions
static meshx_err_t	static_prov_srv_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
	Global static provisioning callback for Server elements.
static meshx_err_t	static_prov_cli_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const void *params)
	Global static provisioning callback for Client elements.
static meshx_err_t	static_config_cb (const dev_struct_t *pdev, control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t *params)
	Global static configuration callback.
static void	register_global_callbacks (void)
	Register the global callbacks with the provisioning server.

Private Member Functions
meshx_err_t	on_model_cb (meshx_ptr_t param, size_t param_size) final
	Handle model callback from child models.

Private Attributes
uint8_t	no_of_sig_models
uint8_t	no_of_ven_models
std::vector< uint8_t >	sig_model_array
std::vector< uint8_t >	ven_model_array
std::vector< std::unique_ptr< meshXModelIF > >	sig_models
std::vector< std::unique_ptr< meshXModelIF > >	ven_models
meshxElementType_t	element_type
meshx_element_type_t	element_variant
meshx_ptr_t	element_ctx
size_t	element_ctx_size

Detailed Description

template<typename meshx_model_send_param_header_t>
class meshXElement< meshx_model_send_param_header_t >

Base class for MeshX elements.

This is a base class for elements.

Constructor & Destructor Documentation

meshXElement() [1/3]

template<typename meshx_model_send_param_header_t>

meshXElement< meshx_model_send_param_header_t >::meshXElement

(

void

)

Default constructor for meshXElement.

Creates an element with default parameters (index 0, no models)

meshXElement() [2/3]

template<typename meshx_model_send_param_header_t>

meshXElement< meshx_model_send_param_header_t >::meshXElement ( uint16_t element_idx )

explicit

Constructor for meshXElement with element index.

Parameters

[in]

element_idx

Index of the element in the mesh network

    : meshXElementIF(element_idx), no_of_sig_models(0), no_of_ven_models(0), element_type(meshxElementType_t::MESHX_ELEMENT_TYPE_SERVER),
      element_variant(MESHX_ELEMENT_TYPE_MAX), element_ctx(nullptr), element_ctx_size(0)
{
    // Register instance in global registry
    meshXElementRegistry::get_instance().register_element(this);
    // Register global callbacks
    this->register_global_callbacks();
}

meshXElement() [3/3]

template<typename meshx_model_send_param_header_t>

meshXElement< meshx_model_send_param_header_t >::meshXElement	(	uint16_t	element_idx,
		meshxElementType_t	type,
		uint8_t	no_of_sig_models,
		uint8_t	no_of_ven_models )

Constructor for meshXElement with element index, type, and model counts.

Construct meshXElement with explicit element index, type, and model counts.

Parameters

[in]	element_idx	Index of the element in the mesh network
[in]	type	Type of the element (server or client)
[in]	no_of_sig_models	Number of SIG models supported by the element
[in]	no_of_ven_models	Number of vendor models supported by the element

    : meshXElementIF(element_idx), no_of_sig_models(no_of_sig_models), no_of_ven_models(no_of_ven_models),
      element_type(type), element_variant(MESHX_ELEMENT_TYPE_MAX), element_ctx(nullptr), element_ctx_size(0)
{
    // Register instance in global registry
    meshXElementRegistry::get_instance().register_element(this);
    // Register global callbacks
    this->register_global_callbacks();
}

~meshXElement()

template<typename meshx_model_send_param_header_t>

meshXElement< meshx_model_send_param_header_t >::~meshXElement ( )

override

{
    meshXElementRegistry::get_instance().unregister_element(get_element_idx());
}

Member Function Documentation

add_models()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::add_models

(

void

)

Add both SIG and Vendor models to the element.

This function combines the functionality of add_sig_models() and add_ven_models() to add all available models (both SIG and Vendor) to the element in a single call. It validates input parameters, checks capacity constraints for both model types, sets parent element for each model, and transfers ownership.

Returns

MESHX_SUCCESS on success, error code otherwise (MESHX_NOT_SUPPORTED, MESHX_INVALID_ARG, MESHX_NO_MEM)

{
    meshx_err_t result = MESHX_SUCCESS;
 
    // Add SIG models
 
    if (meshx_err_t sig_result = add_sig_models(); sig_result != MESHX_SUCCESS && sig_result != MESHX_NOT_SUPPORTED)
    {
        return sig_result;
    }
    // Add Vendor models
 
    if (meshx_err_t ven_result = add_ven_models(); ven_result != MESHX_SUCCESS && ven_result != MESHX_NOT_SUPPORTED)
    {
        return ven_result;
    }
 
    // Check if at least one type of model is supported
    if (no_of_sig_models == 0 && no_of_ven_models == 0)
    {
        return MESHX_NOT_SUPPORTED;
    }
 
    return result;
}

add_sig_model()

template<typename meshx_model_send_param_header_t>

template<typename meshXModelT, typename... ConstructorsArgs>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::add_sig_model

(

ConstructorsArgs &&...

args

)

Add a SIG model to the element.

Template Parameters

meshXModelT	Type of the model to add
ConstructorsArgs	Variadic template parameter pack for constructor arguments

This function adds a SIG model to the element using perfect forwarding. It validates the model type, checks capacity constraints, and transfers ownership.

Parameters

[in]

args

Constructor arguments for the model

Returns

MESHX_SUCCESS on success, error code otherwise

{
    static_assert(std::is_base_of<meshXModelIF, meshXModelT>::std::is_base_of_v,
        "meshXModelT must be derived from meshXModelIF");
 
    if(no_of_sig_models == 0)
    {
        return MESHX_NOT_SUPPORTED;
    }
    if (sig_models.size() >= no_of_sig_models)
    {
        return MESHX_NO_MEM;
    }
    sig_models.emplace_back(std::forward<ConstructorsArgs>(args)...);
    return MESHX_SUCCESS;
}

add_sig_models()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::add_sig_models

(

void

)

Add multiple SIG models to the element.

This function allows adding multiple SIG models at once to the element. It accepts a vector of unique_ptr to meshXModelIF objects. The function validates input parameters, checks capacity constraints, sets parent element for each model, and transfers ownership.

Returns

MESHX_SUCCESS on success, MESHX_NOT_SUPPORTED if no SIG models supported, MESHX_INVALID_ARG if input vector is empty or contains null pointers, MESHX_NO_MEM if adding models would exceed capacity

{
    std::vector<std::unique_ptr<meshXModelIF>>& models = this->get_sig_models();
 
    if(no_of_sig_models == 0)
    {
        return MESHX_NOT_SUPPORTED;
    }
 
    if (models.empty())
    {
        return MESHX_INVALID_STATE;
    }
 
    if ((sig_models.size() + models.size()) > no_of_sig_models)
    {
        return MESHX_NO_MEM;
    }
 
    uint8_t index = 0;
    for (auto& model : models)
    {
        if (model == nullptr)
        {
            return MESHX_INVALID_ARG;
        }
 
        // Set the platform model for the model
        model->set_plat_model(reinterpret_cast<MESHX_MODEL*>(&this->sig_model_array[index * sizeof(MESHX_MODEL)]));
        // Set the parent element for the model
        model->set_parent_element(this);
 
        // Add the model to the sig_models vector
        // Since sig_models is a vector of unique_ptr, we need to transfer ownership
        sig_models.emplace_back(std::move(model));
        index++;
    }
 
    return MESHX_SUCCESS;
}

add_ven_model()

template<typename meshx_model_send_param_header_t>

template<typename meshXModelT, typename... ConstructorsArgs>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::add_ven_model

(

ConstructorsArgs &&...

args

)

Add a Vendor model to the element.

Template Parameters

meshXModelT	Type of the model to add
ConstructorsArgs	Variadic template parameter pack for constructor arguments

This function adds a Vendor model to the element using perfect forwarding. It validates the model type, checks capacity constraints, and transfers ownership.

Parameters

[in]

args

Constructor arguments for the model

Returns

MESHX_SUCCESS on success, error code otherwise

{
    static_assert(std::is_base_of<meshXModelIF, meshXModelT>::std::is_base_of_v,
        "meshXModelT must be derived from meshXModelIF");
    if(no_of_ven_models == 0)
    {
        return MESHX_NOT_SUPPORTED;
    }
 
    if (ven_models.size() >= no_of_ven_models)
    {
        return MESHX_NO_MEM;
    }
    ven_models.emplace_back(std::forward<ConstructorsArgs>(args)...);
    return MESHX_SUCCESS;
}

add_ven_models()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::add_ven_models

(

void

)

Add multiple Vendor models to the element.

This function allows adding multiple Vendor models at once to the element. It accepts a vector of unique_ptr to meshXModelIF objects. The function validates input parameters, checks capacity constraints, sets parent element for each model, and transfers ownership.

Returns

MESHX_SUCCESS on success, MESHX_NOT_SUPPORTED if no Vendor models supported, MESHX_INVALID_ARG if input vector is empty or contains null pointers, MESHX_NO_MEM if adding models would exceed capacity

{
    std::vector<std::unique_ptr<meshXModelIF>>& models = this->get_ven_models();
 
    if(no_of_ven_models == 0)
    {
        return MESHX_NOT_SUPPORTED;
    }
 
    if (models.empty())
    {
        return MESHX_INVALID_STATE;
    }
 
    if ((ven_models.size() + models.size()) > no_of_ven_models)
    {
        return MESHX_NO_MEM;
    }
 
    uint8_t index = 0;
    for (auto& model : models)
    {
        if (model == nullptr)
        {
            return MESHX_INVALID_ARG;
        }
 
        // Set the platform model for the model
        model->set_plat_model(reinterpret_cast<MESHX_MODEL*>(&this->ven_model_array[index * sizeof(MESHX_MODEL)]));
        // Set the parent element for the model
        model->set_parent_element(this);
 
        // Add the model to the ven_models vector
        // Since ven_models is a vector of unique_ptr, we need to transfer ownership
        ven_models.emplace_back(std::move(model));
        index++;
    }
 
    return MESHX_SUCCESS;
}

element_state_change_notify()

template<typename meshx_model_send_param_header_t>

virtual meshx_err_t meshXElement< meshx_model_send_param_header_t >::element_state_change_notify ( meshx_ptr_t param, size_t param_size )

inlinevirtual

Notify element about state change.

Note

This function shall be derived by the specific element class to handle state change notifications from child models (if required).

Parameters

[in]	param	Pointer to the state change parameter
[in]	param_size	Size of the parameter structure

Returns

MESHX_SUCCESS on success, error code otherwise

Reimplemented in meshXCWWWClientElement, meshXCWWWServerElement, meshXRelayClientElement, meshXRelayServerElement, meshXRGBServerElement, meshXRootElement, and meshXSensorElement.

    {
        /* If not derived, return success */
        return MESHX_SUCCESS;
    }

get_element_ctx()

template<typename meshx_model_send_param_header_t>

meshx_ptr_t meshXElement< meshx_model_send_param_header_t >::get_element_ctx ( void ) const

inlineoverridevirtual

Get the element context structure.

Returns

Pointer to the element context structure

Implements meshXElementIF.

{ return element_ctx; }

get_element_ctx_size()

template<typename meshx_model_send_param_header_t>

size_t meshXElement< meshx_model_send_param_header_t >::get_element_ctx_size ( void ) const

inlineoverridevirtual

Get the size of the element context structure.

Returns

Size of the element context structure

Implements meshXElementIF.

{ return element_ctx_size; }

get_element_name()

template<typename meshx_model_send_param_header_t>

const char * meshXElement< meshx_model_send_param_header_t >::get_element_name ( void ) const

overridevirtual

Get the name of the element.

Returns

String literal representing the element name.

Implements meshXElementIF.

Reimplemented in meshXRelayClientElement, meshXRelayServerElement, meshXRGBServerElement, meshXRootElement, and meshXSensorElement.

{
    return "Unknown Element";
}

get_element_type()

template<typename meshx_model_send_param_header_t>

meshxElementType_t meshXElement< meshx_model_send_param_header_t >::get_element_type ( void ) const

inlinefinalvirtual

Get the element type.

Returns

Element type (server or client)

Implements meshXElementIF.

{ return element_type; }

get_element_variant()

template<typename meshx_model_send_param_header_t>

meshx_element_type_t meshXElement< meshx_model_send_param_header_t >::get_element_variant ( void ) const

inlinefinalvirtual

Get the element variant.

Returns

Element variant (meshx_element_type_t)

Implements meshXElementIF.

{ return element_variant; }

get_no_of_sig_models()

template<typename meshx_model_send_param_header_t>

uint8_t meshXElement< meshx_model_send_param_header_t >::get_no_of_sig_models ( void ) const

inlinefinalvirtual

Get the number of SIG models supported by the element.

Returns

Number of SIG models

Implements meshXElementIF.

{ return no_of_sig_models; }

get_no_of_ven_models()

template<typename meshx_model_send_param_header_t>

uint8_t meshXElement< meshx_model_send_param_header_t >::get_no_of_ven_models ( void ) const

inlinefinalvirtual

Get the number of Vendor models supported by the element.

Returns

Number of Vendor models

Implements meshXElementIF.

{ return no_of_ven_models; }

get_sig_model_array()

template<typename meshx_model_send_param_header_t>

std::vector< uint8_t > & meshXElement< meshx_model_send_param_header_t >::get_sig_model_array ( void )

inline

Get the SIG model array.

Returns

Reference to the SIG model array

{ return sig_model_array; }

get_sig_model_count()

template<typename meshx_model_send_param_header_t>

uint8_t meshXElement< meshx_model_send_param_header_t >::get_sig_model_count ( void ) const

inline

Get the number of SIG models currently added to the element.

Returns

Number of SIG models in the element

{ return sig_models.size(); }

get_sig_models()

template<typename meshx_model_send_param_header_t>

std::vector< std::unique_ptr< meshXModelIF > > & meshXElement< meshx_model_send_param_header_t >::get_sig_models ( void )

inlinefinalvirtual

Get the SIG models vector.

Returns

Reference to the SIG models vector

Implements meshXElementIF.

{ return sig_models; }

get_sig_plat_model_array()

template<typename meshx_model_send_param_header_t>

MESHX_MODEL * meshXElement< meshx_model_send_param_header_t >::get_sig_plat_model_array

(

void

)

Get the platform model array for SIG models.

Returns

Pointer to the SIG model array

{
    return sig_model_array.empty() ? nullptr : reinterpret_cast<MESHX_MODEL*>(sig_model_array.data());
}

get_ven_model_array()

template<typename meshx_model_send_param_header_t>

std::vector< uint8_t > & meshXElement< meshx_model_send_param_header_t >::get_ven_model_array ( void )

inline

Get the Vendor model array.

Returns

Reference to the Vendor model array

{ return ven_model_array; }

get_ven_model_count()

template<typename meshx_model_send_param_header_t>

uint8_t meshXElement< meshx_model_send_param_header_t >::get_ven_model_count ( void ) const

inline

Get the number of Vendor models currently added to the element.

Returns

Number of Vendor models in the element

{ return ven_models.size(); }

get_ven_models()

template<typename meshx_model_send_param_header_t>

std::vector< std::unique_ptr< meshXModelIF > > & meshXElement< meshx_model_send_param_header_t >::get_ven_models ( void )

inlinefinalvirtual

Get the Vendor models vector.

Returns

Reference to the Vendor models vector

Implements meshXElementIF.

{ return ven_models; }

get_ven_plat_model_array()

template<typename meshx_model_send_param_header_t>

MESHX_MODEL * meshXElement< meshx_model_send_param_header_t >::get_ven_plat_model_array

(

void

)

Get the platform model array for Vendor models.

Returns

Pointer to the Vendor model array

{
    return ven_model_array.empty() ? nullptr : reinterpret_cast<MESHX_MODEL*>(ven_model_array.data());
}

has_model()

template<typename meshx_model_send_param_header_t>

bool meshXElement< meshx_model_send_param_header_t >::has_model ( uint16_t model_id ) const

overridevirtual

Check if the element contains a specific model by ID.

Parameters

model_id

The model ID to check for

Returns

true if the model exists in this element, false otherwise

Implements meshXElementIF.

{
    // Check SIG models
    for (const auto& m : sig_models) {
        if (m && m->get_model_id() == model_id) return true;
    }
 
    // Check Vendor models
    for (const auto& m : ven_models) {
        if (m && m->get_model_id() == model_id) return true;
    }
 
    return false;
}

initialize()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::initialize ( void )

overridevirtual

Initialize the element.

Returns

MESHX_SUCCESS on success, error code otherwise

Implements meshXElementIF.

{
    /* Restoration from NVS should happen before model initialization if needed */
    this->restore_nvs_context();
 
    /*
     * If platform model pointers are already set (e.g. by meshx_composition_bake),
     * we skip re-allocation and re-adding to maintain pointer stability.
     */
    bool already_initialized = false;
    if (!this->get_sig_models().empty() && this->get_sig_models()[0]->get_plat_model() != nullptr) {
        already_initialized = true;
    }
 
    if (!already_initialized) {
        uint8_t num_sig = this->list_sig_models();
        uint8_t num_ven = this->list_ven_models();
 
        this->set_no_of_sig_models(num_sig);
        this->set_no_of_ven_models(num_ven);
 
        this->sig_plat_model_array_allocate();
        this->ven_plat_model_array_allocate();
 
        /* Add all models to the element (this populates the platform model pointers) */
        this->add_models();
    } else {
        MESHX_LOGI(MODULE_ID_BLE_MESH_ELEMENT, "Element %d already has platform pointers set, skipping re-init", get_element_idx());
    }
 
    return MESHX_SUCCESS;
}

is_initialized()

template<typename meshx_model_send_param_header_t>

bool meshXElement< meshx_model_send_param_header_t >::is_initialized ( void ) const

overridevirtual

Check if the element is initialized.

Returns

true if initialized, false otherwise

Implements meshXElementIF.

{
    /* Default: always report initialized */
    return true;
}

list_sig_models()

template<typename meshx_model_send_param_header_t>

virtual uint8_t meshXElement< meshx_model_send_param_header_t >::list_sig_models ( void )

inlinevirtual

Lists and creates all required SIG models for the element.

This function is responsible for creating and populating the sig_models vector with all essential SIG models that the element must have.

The function can be extended to include additional models based on configuration flags or specific requirements.

Returns

uint8_t The total number of SIG models created and added to the root_sig_models vector

Implements meshXElementIF.

Reimplemented in meshXCWWWClientElement, meshXCWWWServerElement, meshXRelayClientElement, meshXRelayServerElement, meshXRGBServerElement, meshXRootElement, and meshXSensorElement.

{ return 0; };

list_ven_models()

template<typename meshx_model_send_param_header_t>

virtual uint8_t meshXElement< meshx_model_send_param_header_t >::list_ven_models ( void )

inlinevirtual

Lists and creates all required Vendor models for the element.

This function is responsible for creating and populating the ven_models vector with all essential Vendor models that the element must have.

The function can be extended to include additional models based on configuration flags or specific requirements.

Returns

uint8_t The total number of Vendor models created and added to the root_sig_models vector

Implements meshXElementIF.

Reimplemented in meshXCWWWClientElement, meshXCWWWServerElement, meshXRelayClientElement, meshXRelayServerElement, meshXRGBServerElement, meshXRootElement, and meshXSensorElement.

{ return 0; };

on_baked()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::on_baked ( uint16_t index )

inlineoverridevirtual

Called when the composition is baked to update the element's index.

Parameters

index

The final platform index of this element.

Implements meshXElementIF.

                                           {
        this->set_element_idx(index);
        for (auto& m : sig_models) m->on_baked();
        for (auto& m : ven_models) m->on_baked();
    }

on_model_cb()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::on_model_cb ( meshx_ptr_t param, size_t param_size )

finalprivatevirtual

Handle model callback from child models.

This function is called by child models when a state change occurs. It handles the state change by storing in element context, saving to NVS, and notifying the application.

Parameters

[in]	param	Pointer to the model callback parameter
[in]	param_size	Size of the parameter structure

Returns

• MESHX_SUCCESS: State change handled successfully
• MESHX_INVALID_ARG: Invalid parameter

Implements meshXElementIF.

{
    if (param == nullptr)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Invalid parameter in on_model_cb");
        return MESHX_INVALID_ARG;
    }
    meshx_err_t err = MESHX_SUCCESS;
 
    auto *msg_header = static_cast<meshx_model_send_param_header_t *>(param);
 
    if(!msg_header)
    {
        MESHX_LOGE(MODULE_ID_COMMON, "Invalid message header in on_model_cb");
        return MESHX_INVALID_ARG;
    }
 
    if(msg_header->element_state_change == MESHX_SUCCESS)
    {
        /* Notify the element of the state change to derived class (if defined) */
        err = this->element_state_change_notify(param, param_size);
        if(err != MESHX_SUCCESS)
        {
            MESHX_LOGE(MODULE_ID_COMMON, "Element state change notify failed in on_model_cb");
            return err;
        }
 
        /* Save updated context to NVS if it exists */
        if (element_ctx && element_ctx_size > 0)
        {
            err = meshx_nvs_element_ctx_set(get_element_idx(), get_element_variant(), element_ctx, element_ctx_size);
            if(err)
            {
                MESHX_LOGE(MODULE_ID_BLE_MESH_ELEMENT, "meshx_nvs_element_ctx_set failed: %d", err);
            }
        }
    }
 
    return err;
}

register_element_ctx()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::register_element_ctx ( meshx_ptr_t ctx, size_t ctx_size )

inline

Register element context structure.

This function registers the element context structure used to maintain state information for the element.

Parameters

[in]	ctx	Pointer to the element context structure
[in]	ctx_size	Size of the context structure

    {
        element_ctx      = ctx;
        element_ctx_size = ctx_size;
    }

register_global_callbacks()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::register_global_callbacks ( void )

static

Register the global callbacks with the provisioning server.

{
    static std::once_flag registered;
    std::call_once(registered, [](){
#if CONFIG_ENABLE_CONFIG_SERVER
        meshx_config_server_cb_reg((config_srv_cb_t)static_config_cb, 0xFF); // Subscribe to all
#endif
#if CONFIG_ENABLE_PROVISIONING
        meshx_prov_srv_reg_el_server_cb((prov_srv_cb_t)static_prov_srv_cb);
        meshx_prov_srv_reg_el_client_cb((prov_srv_cb_t)static_prov_cli_cb);
#endif
    });
}

reset()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::reset ( void )

overridevirtual

Reset the element.

Returns

MESHX_SUCCESS on success, error code otherwise

Implements meshXElementIF.

{
    /* Default: reset is a no-op */
    return MESHX_SUCCESS;
}

restore_nvs_context()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::restore_nvs_context ( void )

overridevirtual

Restore the element's context from NVS.

Returns

MESHX_SUCCESS on success, error code otherwise.

Implements meshXElementIF.

{
    if (element_ctx && element_ctx_size > 0)
    {
        return meshx_nvs_element_ctx_get(get_element_idx(), get_element_variant(), element_ctx, element_ctx_size);
    }
    return MESHX_SUCCESS;
}

set_element_type()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::set_element_type ( meshxElementType_t type )

inline

{ element_type = type; }

set_element_variant()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::set_element_variant ( meshx_element_type_t variant )

inline

{ element_variant = variant; }

set_no_of_sig_models()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::set_no_of_sig_models ( uint8_t cnt )

inline

{ no_of_sig_models = cnt; }

set_no_of_ven_models()

template<typename meshx_model_send_param_header_t>

void meshXElement< meshx_model_send_param_header_t >::set_no_of_ven_models ( uint8_t cnt )

inline

{ no_of_ven_models = cnt; }

sig_plat_model_array_allocate()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::sig_plat_model_array_allocate

(

void

)

Allocate memory for SIG model platform array.

This function allocates memory for the SIG model platform array based on the number of SIG models supported by the element. It reserves capacity for the specified number of models.

Returns

MESHX_SUCCESS on success, MESHX_NOT_SUPPORTED if no SIG models supported

{
    if (no_of_sig_models > 0)
    {
        sig_model_array.resize(no_of_sig_models * sizeof(MESHX_MODEL));
        return MESHX_SUCCESS;
    }
    return MESHX_NOT_SUPPORTED;
}

static_config_cb()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::static_config_cb ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const meshx_config_srv_cb_param_t * params )

static

Global static configuration callback.

{
    MESHX_UNUSED(pdev);
    if (!params) return MESHX_INVALID_ARG;
 
    uint16_t element_addr = 0;
 
    if (evt == CONTROL_TASK_MSG_EVT_APP_KEY_BIND)
    {
        element_addr = params->state_change.mod_app_bind.element_addr;
    }
    else if (evt == CONTROL_TASK_MSG_EVT_PUB_ADD || evt == CONTROL_TASK_MSG_EVT_PUB_DEL)
    {
        element_addr = params->state_change.mod_pub_set.element_addr;
    }
    else
    {
        return MESHX_SUCCESS; // Not an event we handle context for directly
    }
 
    // Find element by address (abs_id)
    auto *el = meshXElementRegistry::get_instance().find_element(element_addr);
    if (el)
    {
        // Update common context first (pattern matching)
        auto *ctx = static_cast<meshx_element_common_ctx_t *>(el->get_element_ctx());
        if (ctx)
        {
            bool save = false;
            if (evt == CONTROL_TASK_MSG_EVT_APP_KEY_BIND)
            {
                ctx->app_id = params->state_change.mod_app_bind.app_idx;
                save = true;
            }
            else if (evt == CONTROL_TASK_MSG_EVT_PUB_ADD || evt == CONTROL_TASK_MSG_EVT_PUB_DEL)
            {
                if (evt == CONTROL_TASK_MSG_EVT_PUB_ADD) {
                    ctx->pub_addr = params->state_change.mod_pub_set.pub_addr;
                    ctx->app_id   = params->state_change.mod_pub_set.app_idx;
                } else {
                    ctx->pub_addr = MESHX_ADDR_UNASSIGNED;
                }
                save = true;
            }
 
            if (save)
            {
                meshx_nvs_element_ctx_set(el->get_element_idx(), el->get_element_variant(),
                                         el->get_element_ctx(), el->get_element_ctx_size());
            }
        }
 
        // Notify element for any specialized handling
        el->handle_config(evt, params);
    }
    return MESHX_SUCCESS;
}

static_prov_cli_cb()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::static_prov_cli_cb ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const void * params )

static

Global static provisioning callback for Client elements.

{
    MESHX_UNUSED(pdev); MESHX_UNUSED(params);
 
    // Iterate through all elements and call sync only for client elements
    auto elements = meshXElementRegistry::get_instance().get_all_elements();
    for (auto const& [abs_id, base_el] : elements)
    {
        if (base_el && base_el->get_element_type() == meshxElementType_t::MESHX_ELEMENT_TYPE_CLIENT)
        {
            base_el->sync(evt);
        }
    }
    return MESHX_SUCCESS;
}

static_prov_srv_cb()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::static_prov_srv_cb ( const dev_struct_t * pdev, control_task_msg_evt_t evt, const void * params )

static

Global static provisioning callback for Server elements.

{
    MESHX_UNUSED(pdev); MESHX_UNUSED(params);
 
    // Iterate through all elements and call sync only for server elements
    auto elements = meshXElementRegistry::get_instance().get_all_elements();
    for (auto const& [abs_id, base_el] : elements)
    {
        if (base_el && base_el->get_element_type() == meshxElementType_t::MESHX_ELEMENT_TYPE_SERVER)
        {
            base_el->sync(evt);
        }
    }
    return MESHX_SUCCESS;
}

ven_plat_model_array_allocate()

template<typename meshx_model_send_param_header_t>

meshx_err_t meshXElement< meshx_model_send_param_header_t >::ven_plat_model_array_allocate

(

void

)

Allocate memory for Vendor model platform array.

This function allocates memory for the Vendor model platform array based on the number of Vendor models supported by the element. It reserves capacity for the specified number of models.

Returns

MESHX_SUCCESS on success, MESHX_NOT_SUPPORTED if no Vendor models supported

{
    if (no_of_ven_models > 0)
    {
        ven_model_array.resize(no_of_ven_models * sizeof(MESHX_MODEL));
        return MESHX_SUCCESS;
    }
    return MESHX_NOT_SUPPORTED;
}

Field Documentation

element_ctx

template<typename meshx_model_send_param_header_t>

meshx_ptr_t meshXElement< meshx_model_send_param_header_t >::element_ctx

private

Pointer to element context structure

element_ctx_size

template<typename meshx_model_send_param_header_t>

size_t meshXElement< meshx_model_send_param_header_t >::element_ctx_size

private

Size of the element context structure

element_type

template<typename meshx_model_send_param_header_t>

meshxElementType_t meshXElement< meshx_model_send_param_header_t >::element_type

private

element_variant

template<typename meshx_model_send_param_header_t>

meshx_element_type_t meshXElement< meshx_model_send_param_header_t >::element_variant

private

no_of_sig_models

template<typename meshx_model_send_param_header_t>

uint8_t meshXElement< meshx_model_send_param_header_t >::no_of_sig_models

private

no_of_ven_models

template<typename meshx_model_send_param_header_t>

uint8_t meshXElement< meshx_model_send_param_header_t >::no_of_ven_models

private

sig_model_array

template<typename meshx_model_send_param_header_t>

std::vector<uint8_t> meshXElement< meshx_model_send_param_header_t >::sig_model_array

private

sig_models

template<typename meshx_model_send_param_header_t>

std::vector<std::unique_ptr<meshXModelIF> > meshXElement< meshx_model_send_param_header_t >::sig_models

private

ven_model_array

template<typename meshx_model_send_param_header_t>

std::vector<uint8_t> meshXElement< meshx_model_send_param_header_t >::ven_model_array

private

ven_models

template<typename meshx_model_send_param_header_t>

std::vector<std::unique_ptr<meshXModelIF> > meshXElement< meshx_model_send_param_header_t >::ven_models

private

---

The documentation for this class was generated from the following files:

• meshx_fwd_decl.hpp
• meshx_element_class.hpp
• meshx_element_class.cpp