MayaFlux::Registry::BackendRegistry Class Reference

Thread-safe singleton registry for backend service discovery. More...

#include <BackendRegistry.hpp>

Collaboration diagram for MayaFlux::Registry::BackendRegistry:

Public Types
using	ServiceId = std::type_index
using	ServiceFactory = std::function< void *()>

Public Member Functions
	BackendRegistry (const BackendRegistry &)=delete
BackendRegistry &	operator= (const BackendRegistry &)=delete
	BackendRegistry (BackendRegistry &&)=delete
BackendRegistry &	operator= (BackendRegistry &&)=delete
template<typename Interface >
void	register_service (ServiceFactory factory)
	Register a backend service capability.
template<typename Interface >
Interface *	get_service ()
	Query for a backend service.
template<typename Interface >
bool	has_service () const
	Check if a service is available.
template<typename Interface >
void	unregister_service ()
	Unregister a service.
void	clear_all_services ()
	Clear all registered services.
size_t	get_service_count () const
	Get count of currently registered services.

Static Public Member Functions
static BackendRegistry &	instance ()
	Get the global registry instance.

Private Member Functions
	BackendRegistry ()=default
	~BackendRegistry ()=default

Private Attributes
std::shared_mutex	m_mutex
std::unordered_map< ServiceId, ServiceFactory >	m_services

Detailed Description

Thread-safe singleton registry for backend service discovery.

Provides centralized, type-safe registry for backend capabilities without creating dependencies between processing components and specific backend implementations. Backends register their services on initialization, and processing components (Buffers, Nodes, Coroutines, etc.) query for needed capabilities at runtime.

Design Philosophy:

• Zero coupling between consumers and backends
• Runtime service discovery with compile-time type safety
• Graceful degradation when services unavailable
• Thread-safe for concurrent access across subsystems
• Singleton to avoid engine/subsystem dependencies
• Hot-swappable backends via re-registration

Thread Safety: All methods are thread-safe. Registration and queries can occur concurrently from different threads. Uses shared_mutex for optimal read performance (multiple concurrent queries, exclusive write for registration).

Lifecycle:

1. Backend initializes and registers services
2. Consumers query for services as needed
3. Backend shuts down and unregisters services
4. Registry remains valid for next backend initialization

Example Usage:

Backend registration: auto& registry = BackendRegistry::instance(); registry.register_service<IBufferService>([this]() -> void* { return m_buffer_service.get(); });

Consumer query: auto* service = BackendRegistry::instance().get_service<IBufferService>(); if (service) { service->create_buffer(...); }

Definition at line 49 of file BackendRegistry.hpp.

---

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

• BackendRegistry.hpp