meshx::MeshXIoFactory Class Reference

IO Factory Class. More...

#include <meshx_io_factory.hpp>

Public Member Functions
bool	registerType (IoType type, IoFactoryFunction factory_func)
	Register IO type factory function.
std::unique_ptr< MeshXIoInterface >	create (const IoConfig &config)
	Create IO instance.
std::unique_ptr< MeshXIoInterface >	createFromYaml (const void *yaml_config)
	Create IO instance from YAML configuration.
bool	isTypeSupported (IoType type) const
	Check if IO type is supported.

Static Public Member Functions
static MeshXIoFactory &	getInstance ()
	Get singleton instance.

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

Private Attributes
std::unordered_map< IoType, IoFactoryFunction >	factory_registry_

Detailed Description

IO Factory Class.

This factory creates IO instances based on configuration.

Constructor & Destructor Documentation

MeshXIoFactory() [1/2]

meshx::MeshXIoFactory::MeshXIoFactory ( )

privatedefault

~MeshXIoFactory()

meshx::MeshXIoFactory::~MeshXIoFactory ( )

privatedefault

MeshXIoFactory() [2/2]

meshx::MeshXIoFactory::MeshXIoFactory ( const MeshXIoFactory & )

privatedelete

Member Function Documentation

create()

std::unique_ptr< MeshXIoInterface > meshx::MeshXIoFactory::create

(

const IoConfig &

config

)

Create IO instance.

Parameters

config

IO configuration

Returns

std::unique_ptr<MeshXIoInterface> IO instance pointer

                                                                             {
    // Check if type is supported
    auto it = factory_registry_.find(config.type);
    if (it == factory_registry_.end()) {
        // Type not supported
        return nullptr;
    }
 
    // Call factory function
    return it->second(config.logical_pin, config.name.c_str());
}

createFromYaml()

std::unique_ptr< MeshXIoInterface > meshx::MeshXIoFactory::createFromYaml

(

const void *

yaml_config

)

Create IO instance from YAML configuration.

Parameters

yaml_config

YAML configuration node

Returns

std::unique_ptr<MeshXIoInterface> IO instance pointer

                                                                                      {
    // Note: YAML parsing would be implemented here
    // For now, this is a placeholder implementation
    (void)yaml_config;
    return nullptr;
}

getInstance()

MeshXIoFactory & meshx::MeshXIoFactory::getInstance ( )

static

Get singleton instance.

Returns

MeshXIoFactory& Reference to singleton instance

                                            {
    static MeshXIoFactory instance;
 
    // Register default factory functions on first call
    static bool initialized = false;
    if (!initialized) {
        instance.registerType(IoType::GPIO, createGpioInstance);
        instance.registerType(IoType::PWM, createPwmInstance);
        initialized = true;
    }
 
    return instance;
}

isTypeSupported()

bool meshx::MeshXIoFactory::isTypeSupported

(

IoType

type

)

const

Check if IO type is supported.

Parameters

type	IO type to check

Returns

true if type is supported

false if type is not supported

                                                      {
    return factory_registry_.find(type) != factory_registry_.end();
}

operator=()

MeshXIoFactory & meshx::MeshXIoFactory::operator= ( const MeshXIoFactory & )

privatedelete

registerType()

bool meshx::MeshXIoFactory::registerType	(	IoType	type,
		IoFactoryFunction	factory_func )

Register IO type factory function.

Parameters

type	IO type
factory_func	Factory function

Returns

true if registration successful

false if registration failed (type already registered)

                                                                             {
    if (factory_func == nullptr) {
        return false;
    }
 
    auto it = factory_registry_.find(type);
    if (it != factory_registry_.end()) {
        // Type already registered
        return false;
    }
 
    factory_registry_[type] = factory_func;
    return true;
}

Field Documentation

factory_registry_

std::unordered_map<IoType, IoFactoryFunction> meshx::MeshXIoFactory::factory_registry_

private

---

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

• meshx_io_factory.hpp
• meshx_io_factory.cpp