kcenon::common::patterns::SimpleEventBus Class Reference

Thread-safe event bus for publish/subscribe pattern. More...

Collaboration diagram for kcenon::common::patterns::SimpleEventBus:

Classes
struct	HandlerEntry

Public Member Functions
	SimpleEventBus ()
	~SimpleEventBus ()
void	start ()
	Start the event bus.
void	stop ()
	Stop the event bus.
bool	is_running () const
	Check if the event bus is running.
template<typename Event >
uint64_t	subscribe (std::function< void(const Event &)> handler)
	Subscribe to events of a specific type.
void	unsubscribe (uint64_t subscription_id)
	Unsubscribe from events.
template<typename Event >
void	publish (const Event &event)
	Publish an event to all subscribers.
template<typename Event >
size_t	subscriber_count () const
	Get the number of subscribers for an event type.
void	clear ()
	Clear all subscriptions.

Private Attributes
std::shared_mutex	mutex_
std::atomic< bool >	running_
std::atomic< uint64_t >	next_id_
std::unordered_map< std::type_index, std::vector< HandlerEntry > >	handlers_

Detailed Description

Thread-safe event bus for publish/subscribe pattern.

Allows components to communicate through events without direct coupling. Supports type-safe event publishing and subscription.

Definition at line 45 of file patterns.cppm.

Constructor & Destructor Documentation

SimpleEventBus()

kcenon::common::patterns::SimpleEventBus::SimpleEventBus ( )

inlineexport

Definition at line 47 of file patterns.cppm.

: running_(false), next_id_(1) {}

~SimpleEventBus()

kcenon::common::patterns::SimpleEventBus::~SimpleEventBus ( )

inlineexport

Definition at line 49 of file patterns.cppm.

                      {
        stop();
    }

References stop().

Here is the call graph for this function:

Member Function Documentation

clear()

void kcenon::common::patterns::SimpleEventBus::clear ( )

inlineexport

Clear all subscriptions.

Definition at line 146 of file patterns.cppm.

                 {
        std::unique_lock lock(mutex_);
        handlers_.clear();
    }

References handlers_, and mutex_.

is_running()

bool kcenon::common::patterns::SimpleEventBus::is_running ( ) const

inlineexport

Check if the event bus is running.

Definition at line 70 of file patterns.cppm.

                            {
        return running_.load(std::memory_order_acquire);
    }

References running_.

Referenced by publish().

Here is the caller graph for this function:

publish()

template<typename Event >

void kcenon::common::patterns::SimpleEventBus::publish ( const Event & event )

inlineexport

Publish an event to all subscribers.

Template Parameters

Event

Event type

Parameters

event

Event to publish

Definition at line 116 of file patterns.cppm.

                                     {
        if (!is_running()) return;
 
        std::shared_lock lock(mutex_);
        auto type = std::type_index(typeid(Event));
        auto it = handlers_.find(type);
        if (it != handlers_.end()) {
            for (const auto& entry : it->second) {
                entry.handler(&event);
            }
        }
    }

References handlers_, is_running(), and mutex_.

Here is the call graph for this function:

start()

void kcenon::common::patterns::SimpleEventBus::start ( )

inlineexport

Start the event bus.

Definition at line 56 of file patterns.cppm.

                 {
        running_.store(true, std::memory_order_release);
    }

References running_.

stop()

void kcenon::common::patterns::SimpleEventBus::stop ( )

inlineexport

Stop the event bus.

Definition at line 63 of file patterns.cppm.

                {
        running_.store(false, std::memory_order_release);
    }

References running_.

Referenced by ~SimpleEventBus().

Here is the caller graph for this function:

subscribe()

template<typename Event >

uint64_t kcenon::common::patterns::SimpleEventBus::subscribe ( std::function< void(const Event &)> handler )

inlineexport

Subscribe to events of a specific type.

Template Parameters

Event

Event type to subscribe to

Parameters

handler

Handler function to call when event is published

Returns

Subscription ID for unsubscribing

Definition at line 81 of file patterns.cppm.

                                                                {
        std::unique_lock lock(mutex_);
        uint64_t id = next_id_++;
        auto type = std::type_index(typeid(Event));
 
        auto& handlers = handlers_[type];
        handlers.push_back({id, [handler](const void* event) {
            handler(*static_cast<const Event*>(event));
        }});
 
        return id;
    }

References handlers_, mutex_, and next_id_.

subscriber_count()

template<typename Event >

size_t kcenon::common::patterns::SimpleEventBus::subscriber_count ( ) const

inlineexport

Get the number of subscribers for an event type.

Definition at line 133 of file patterns.cppm.

                                    {
        std::shared_lock lock(mutex_);
        auto type = std::type_index(typeid(Event));
        auto it = handlers_.find(type);
        if (it != handlers_.end()) {
            return it->second.size();
        }
        return 0;
    }

References handlers_, and mutex_.

unsubscribe()

void kcenon::common::patterns::SimpleEventBus::unsubscribe ( uint64_t subscription_id )

inlineexport

Unsubscribe from events.

Parameters

subscription_id

ID returned from subscribe

Definition at line 98 of file patterns.cppm.

                                               {
        std::unique_lock lock(mutex_);
        for (auto& [type, handlers] : handlers_) {
            handlers.erase(
                std::remove_if(handlers.begin(), handlers.end(),
                    [subscription_id](const auto& entry) {
                        return entry.id == subscription_id;
                    }),
                handlers.end());
        }
    }

References handlers_, and mutex_.

Member Data Documentation

handlers_

std::unordered_map<std::type_index, std::vector<HandlerEntry> > kcenon::common::patterns::SimpleEventBus::handlers_

exportprivate

Definition at line 160 of file patterns.cppm.

Referenced by clear(), publish(), subscribe(), subscriber_count(), and unsubscribe().

mutex_

std::shared_mutex kcenon::common::patterns::SimpleEventBus::mutex_

mutableexportprivate

Definition at line 157 of file patterns.cppm.

Referenced by clear(), publish(), subscribe(), subscriber_count(), and unsubscribe().

next_id_

std::atomic<uint64_t> kcenon::common::patterns::SimpleEventBus::next_id_

exportprivate

Definition at line 159 of file patterns.cppm.

Referenced by subscribe().

running_

std::atomic<bool> kcenon::common::patterns::SimpleEventBus::running_

exportprivate

Definition at line 158 of file patterns.cppm.

Referenced by is_running(), start(), and stop().

---

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

• src/modules/patterns.cppm