meshXComposition Class Reference

Singleton manager for the dynamic BLE Mesh composition. More...

#include <meshx_composition.hpp>

Public Member Functions
void	add_element (std::unique_ptr< meshXElementIF > element)
	Add an element to the composition.
std::vector< std::unique_ptr< meshXElementIF > > &	get_elements ()
	Get the list of elements.
bool	has_model (uint16_t model_id) const
	Check if any element in the composition contains a specific model.
bool	has_elements () const
	Check if there are any elements.
void	clear_elements ()
	Clear all elements and reset state.
void	set_device_struct (dev_struct_t *pdev)
	Set the device structure pointer.
meshx_err_t	bake (uint16_t cid, uint16_t pid, uint16_t vid)
	"Bake" the dynamic composition into a contiguous C-array
bool	is_composition_baked () const
	Check if the composition is baked.
MESHX_ELEMENT *	get_baked_elements ()
	Get the baked elements array.
MESHX_COMPOSITION *	get_baked_composition ()
	Get the baked composition structure.

Static Public Member Functions
static meshXComposition &	get_instance ()
	Get the singleton instance.

Private Member Functions
	meshXComposition ()
	~meshXComposition ()=default
	meshXComposition (const meshXComposition &)=delete
meshXComposition &	operator= (const meshXComposition &)=delete

Private Attributes
dev_struct_t *	pdev
bool	is_baked
std::vector< std::unique_ptr< meshXElementIF > >	elements
std::vector< uint8_t >	baked_elements
std::vector< std::vector< uint8_t > >	baked_sig_model_arrays
std::vector< std::vector< uint8_t > >	baked_ven_model_arrays
MESHX_COMPOSITION	baked_comp
MESHX_COMPOSITION *	baked_comp_ptr

Detailed Description

Singleton manager for the dynamic BLE Mesh composition.

This class manages the collection of elements and flattens them into the contiguous C-arrays required by the platform's BLE Mesh stack.

Constructor & Destructor Documentation

meshXComposition() [1/2]

meshXComposition::meshXComposition ( )

inlineprivate

: pdev(nullptr), is_baked(false), baked_comp_ptr(nullptr) {}

~meshXComposition()

meshXComposition::~meshXComposition ( )

privatedefault

meshXComposition() [2/2]

meshXComposition::meshXComposition ( const meshXComposition & )

privatedelete

Member Function Documentation

add_element()

void meshXComposition::add_element ( std::unique_ptr< meshXElementIF > element )

inline

Add an element to the composition.

Parameters

element

Unique pointer to the element to add

                                                            {
        elements.push_back(std::move(element));
    }

bake()

meshx_err_t meshXComposition::bake	(	uint16_t	cid,
		uint16_t	pid,
		uint16_t	vid )

"Bake" the dynamic composition into a contiguous C-array

This flattens the C++ object tree into the format required by the BLE stack.

Parameters

cid	Company ID.
pid	Product ID.
vid	Version ID.

Returns

MESHX_SUCCESS on success, error code otherwise

                                                                           {
    if (is_baked) return MESHX_SUCCESS;
    if (!pdev) {
        MESHX_LOGE(MODULE_ID_COMMON, "Composition bake failed: Device struct not set");
        return MESHX_INVALID_STATE;
    }
 
    MESHX_LOGI(MODULE_ID_BLE_MESH_ELEMENT, "C|P|V|E: 0x%04x|0x%04x|0x%04x|%zu",
               cid, pid, vid, elements.size());
    MESHX_LOGD(MODULE_ID_BLE_MESH_ELEMENT, "MESHX_MODEL size: %d, pub offset: %d", (int)sizeof(MESHX_MODEL), (int)offsetof(MESHX_MODEL, pub));
    MESHX_LOGD(MODULE_ID_BLE_MESH_ELEMENT, "MESHX_MODEL_PUB size: %d", (int)sizeof(MESHX_MODEL_PUB));
 
    /* Compile-time check for structural alignment */
    static_assert(sizeof(MESHX_MODEL) >= 40, "MESHX_MODEL size is too small!");
 
    size_t total_elements = elements.size();
 
    /* Allocate and initialize platform structures */
    baked_elements.assign(total_elements * sizeof(MESHX_ELEMENT), 0);
    baked_sig_model_arrays.resize(total_elements);
    baked_ven_model_arrays.resize(total_elements);
 
    MESHX_ELEMENT* p_elements = reinterpret_cast<MESHX_ELEMENT*>(baked_elements.data());
 
    /* Bake all Elements (Index 0 to N) */
    for (size_t i = 0; i < elements.size(); ++i) {
        size_t plat_idx = i;
        auto& el = elements[i];
 
        /* Clear and refresh model lists to prevent duplicates if bake is re-called */
        el->get_sig_models().clear();
        el->get_ven_models().clear();
        el->list_sig_models();
        el->list_ven_models();
 
        auto& sig_models = el->get_sig_models();
        auto& ven_models = el->get_ven_models();
 
        /* 1. Pre-calculate counts after filtering */
        size_t actual_sig_cnt = 0;
        for (auto& m : sig_models) {
            if (m->get_model_id() == MESHX_MODEL_ID_CONFIG_SRV && plat_idx > 0) continue;
            actual_sig_cnt++;
        }
        size_t actual_ven_cnt = ven_models.size();
 
        /* 2. Resize and Zero-Initialize model arrays ONCE to ensure pointer stability */
        baked_sig_model_arrays[plat_idx].assign(actual_sig_cnt * sizeof(MESHX_MODEL), 0);
        baked_ven_model_arrays[plat_idx].assign(actual_ven_cnt * sizeof(MESHX_MODEL), 0);
 
        MESHX_LOGD(MODULE_ID_BLE_MESH_ELEMENT, "Baking Element %d: SIG models: %zu, Vendor models: %zu (Model Size: %zu)",
                   (int)plat_idx, actual_sig_cnt, actual_ven_cnt, sizeof(MESHX_MODEL));
 
        /* 3. Populate SIG models */
        size_t baked_sig_idx = 0;
        for (auto& m : sig_models) {
            m->set_parent_element(el.get());
 
            /* Skip Config Server if not primary element to satisfy ESP-IDF requirements */
            if (m->get_model_id() == MESHX_MODEL_ID_CONFIG_SRV && plat_idx > 0) {
                MESHX_LOGW(MODULE_ID_COMMON, "  Skipping Config Server (0x0000) on non-primary element %d", (int)plat_idx);
                continue;
            }
 
            /* Get pointer to the baked slot for this model */
            MESHX_MODEL* p_baked_base = reinterpret_cast<MESHX_MODEL*>(baked_sig_model_arrays[plat_idx].data());
            MESHX_MODEL* p_baked = p_baked_base + baked_sig_idx;
 
            /* Explicitly zero the slot again before calling platform create to prevent garbage */
            memset(static_cast<void*>(p_baked), 0, sizeof(MESHX_MODEL));
 
            /* Create the platform model directly into the baked slot */
            meshx_err_t m_err = m->plat_model_create(p_baked);
            if (m_err != MESHX_SUCCESS) {
                MESHX_LOGE(MODULE_ID_BLE_MESH_ELEMENT, "Failed to create platform model for SIG model 0x%04x in element %d (err: %d)",
                           m->get_model_id(), (int)plat_idx, m_err);
                continue;
            }
 
            /* Link the C++ object to the platform struct */
            m->set_plat_model(p_baked);
 
            // Debug: Verify the baked model state and check for garbage pointers
            MESHX_LOGD(MODULE_ID_BLE_MESH_ELEMENT, "  Model %zu ID: 0x%04x, Pub: %p, Slot Addr: %p",
                       baked_sig_idx, p_baked->model_id, (void*)p_baked->pub, (void*)p_baked);
 
            if (p_baked->pub) {
                uint32_t pub_ptr_val = (uint32_t)p_baked->pub;
                if (pub_ptr_val < 0x3f000000 || pub_ptr_val > 0x3fffffff) {
                    MESHX_LOGE(MODULE_ID_BLE_MESH_ELEMENT, "  CRITICAL: Garbage Pub pointer detected: %p at %p", (void*)p_baked->pub, (void*)&p_baked->pub);
                }
            }
 
            baked_sig_idx++;
        }
 
        /* 4. Populate Vendor models */
        size_t baked_ven_idx = 0;
        for (auto& m : ven_models) {
            m->set_parent_element(el.get());
 
            /* Get pointer to the baked slot for this vendor model */
            MESHX_MODEL* p_baked = reinterpret_cast<MESHX_MODEL*>(baked_ven_model_arrays[plat_idx].data()) + baked_ven_idx;
            memset(static_cast<void*>(p_baked), 0, sizeof(MESHX_MODEL));
 
            /* Create the platform model directly into the baked slot */
            meshx_err_t m_err = m->plat_model_create(p_baked);
            if (m_err != MESHX_SUCCESS) {
                MESHX_LOGE(MODULE_ID_BLE_MESH_ELEMENT, "Failed to create platform model for Vendor model 0x%04x in element %d (err: %d)",
                           m->get_model_id(), (int)plat_idx, m_err);
                continue;
            }
 
            m->set_plat_model(p_baked);
            baked_ven_idx++;
        }
 
        /* 5. Finalize platform element structure */
        uint16_t loc = 0;
        uint8_t sig_cnt = (uint8_t)actual_sig_cnt;
        uint8_t ven_cnt = (uint8_t)baked_ven_idx;
        esp_ble_mesh_model_t* sig_ptr = (sig_cnt > 0) ? reinterpret_cast<esp_ble_mesh_model_t*>(baked_sig_model_arrays[plat_idx].data()) : nullptr;
        esp_ble_mesh_model_t* ven_ptr = (ven_cnt > 0) ? reinterpret_cast<esp_ble_mesh_model_t*>(baked_ven_model_arrays[plat_idx].data()) : nullptr;
 
        MESHX_ELEMENT* e = &p_elements[plat_idx];
        memcpy((void*)&e->location, &loc, sizeof(e->location));
        memcpy((void*)&e->sig_model_count, &sig_cnt, sizeof(e->sig_model_count));
        memcpy((void*)&e->vnd_model_count, &ven_cnt, sizeof(e->vnd_model_count));
        memcpy((void*)&e->sig_models, &sig_ptr, sizeof(e->sig_models));
        memcpy((void*)&e->vnd_models, &ven_ptr, sizeof(e->vnd_models));
 
        /* Register in registry for runtime callbacks/lookups */
        el->on_baked(plat_idx);
        meshXElementRegistry::get_instance().register_element(el.get());
    }
 
    /* 4. Finalize Composition Object */
    baked_comp.cid = cid;
    baked_comp.pid = pid;
    baked_comp.vid = vid;
    baked_comp.element_count = (uint16_t)total_elements;
    baked_comp.elements = p_elements;
 
    baked_comp_ptr = &baked_comp;
    is_baked = true;
 
    /* Update the device structure with the baked data */
    pdev->elements = p_elements;
    pdev->element_cnt = (uint16_t)total_elements;
    pdev->element_idx = (uint16_t)total_elements;
    pdev->composition = baked_comp_ptr;
 
    return MESHX_SUCCESS;
 
}

clear_elements()

void meshXComposition::clear_elements ( )

inline

Clear all elements and reset state.

                          {
        elements.clear();
        is_baked = false;
        baked_elements.clear();
        baked_sig_model_arrays.clear();
        baked_ven_model_arrays.clear();
    }

get_baked_composition()

MESHX_COMPOSITION * meshXComposition::get_baked_composition ( )

inline

Get the baked composition structure.

{ return baked_comp_ptr; }

get_baked_elements()

MESHX_ELEMENT * meshXComposition::get_baked_elements ( )

inline

Get the baked elements array.

                                        {
        return reinterpret_cast<MESHX_ELEMENT*>(baked_elements.data());
    }

get_elements()

std::vector< std::unique_ptr< meshXElementIF > > & meshXComposition::get_elements ( )

inline

Get the list of elements.

{ return elements; }

get_instance()

meshXComposition & meshXComposition::get_instance ( )

static

Get the singleton instance.

Returns

Reference to the meshXComposition instance

                                                 {
    static meshXComposition instance;
    return instance;
}

has_elements()

bool meshXComposition::has_elements ( ) const

inline

Check if there are any elements.

{ return !elements.empty(); }

has_model()

bool meshXComposition::has_model ( uint16_t model_id ) const

inline

Check if any element in the composition contains a specific model.

Parameters

model_id

The model ID to search for.

Returns

true if found, false otherwise.

                                            {
        for (const auto& el : elements) {
            if (el && el->has_model(model_id)) return true;
        }
        return false;
    }

is_composition_baked()

bool meshXComposition::is_composition_baked ( ) const

inline

Check if the composition is baked.

Returns

true if baked, false otherwise

{ return is_baked; }

operator=()

meshXComposition & meshXComposition::operator= ( const meshXComposition & )

privatedelete

set_device_struct()

void meshXComposition::set_device_struct ( dev_struct_t * pdev )

inline

Set the device structure pointer.

Parameters

pdev	Pointer to the device structure

{ this->pdev = pdev; }

Field Documentation

baked_comp

MESHX_COMPOSITION meshXComposition::baked_comp

private

baked_comp_ptr

MESHX_COMPOSITION* meshXComposition::baked_comp_ptr

private

baked_elements

std::vector<uint8_t> meshXComposition::baked_elements

private

baked_sig_model_arrays

std::vector<std::vector<uint8_t> > meshXComposition::baked_sig_model_arrays

private

baked_ven_model_arrays

std::vector<std::vector<uint8_t> > meshXComposition::baked_ven_model_arrays

private

elements

std::vector<std::unique_ptr<meshXElementIF> > meshXComposition::elements

private

is_baked

bool meshXComposition::is_baked

private

pdev

dev_struct_t* meshXComposition::pdev

private

---

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

• meshx_composition.hpp
• meshx_composition.cpp