so_5::multi_sink_binding_t< Lock_Type > Class Template Reference

Helper class for managing multiple sink bindings. More...

#include <multi_sink_binding.hpp>

Inheritance diagram for so_5::multi_sink_binding_t< Lock_Type >:

Public Member Functions
	multi_sink_binding_t ()=default
	multi_sink_binding_t (const multi_sink_binding_t &)=delete
multi_sink_binding_t &	operator= (const multi_sink_binding_t &)=delete
	multi_sink_binding_t (multi_sink_binding_t &&)=delete
multi_sink_binding_t &	operator= (multi_sink_binding_t &&)=delete
template<typename Msg >
void	bind (const mbox_t &from, const msink_t &dest)
template<typename Msg >
void	bind (const mbox_t &from, const msink_t &dest, delivery_filter_unique_ptr_t delivery_filter)
template<typename Msg , typename Lambda >
void	bind (const mbox_t &from, const msink_t &dest, Lambda &&filter)
template<typename Msg >
void	unbind (const mbox_t &from, const msink_t &dest) noexcept
void	unbind_all_for (const mbox_t &from, const msink_t &dest) noexcept
void	clear () noexcept

Additional Inherited Members
Protected Member Functions inherited from so_5::details::actual_lock_holder_t< Lock_Type >
template<typename Lambda >
auto	lock_and_perform (Lambda &&l) const -> decltype(l())
	Do actual lock and perform necessary action.
Protected Member Functions inherited from so_5::multi_sink_binding_impl::actual_binding_handler_t
template<typename Msg >
void	do_bind (const mbox_t &from, const msink_t &dest)
template<typename Msg >
void	do_bind (const mbox_t &from, const msink_t &dest, delivery_filter_unique_ptr_t delivery_filter)
template<typename Msg >
void	do_unbind (const mbox_t &from, const msink_t &dest) noexcept
void	do_unbind_all_for (const mbox_t &from, const msink_t &dest) noexcept
void	do_clear () noexcept

Detailed Description

template<typename Lock_Type = std::mutex>
class so_5::multi_sink_binding_t< Lock_Type >

Helper class for managing multiple sink bindings.

An instance of multi_sink_binding_t drops all binding in the destructor. If it's necessary to drop all binding manually then clear() method can be used.

Usage examples:

// Use as a part of an agent.
class coordinator final : public so_5::agent_t
{
  const so_5::mbox_t broadcasting_mbox_;
  so_5::multi_sink_binding_t<> bindings_;
...
  void on_some_event(mhood_t<msg_some_command> cmd) {
    // Create a child coop and bind agents to broadcasting mbox.
    so_5::introduce_child_coop(*this, [](so_5::coop_t & coop) {
        auto * first = coop.make_agent<first_worker>(...);
        auto first_worker_msink = so_5::wrap_to_msink(first->so_direct_mbox());
 
        auto * second = coop.make_agent<second_worker>(...);
        auto second_worker_msink = so_5::wrap_to_msink(second->so_direct_mbox());
 
        bindings_.bind<msg_some_data>(broadcasting_mbox_, first_worker_msink);
        bindings_.bind<msg_some_data>(broadcasting_mbox_, second_worker_msink);
        bindings_.bind<msg_some_notify>(broadcasting_mbox_, first_worker_msink);
        bindings_.bind<msg_another_notify>(broadcasting_mbox_, second_worker_msink);
        ...
      });
  }
};
 
// Use as object controlled by a coop.
so_5::environment_t & env = ...;
env.introduce_coop([](so_5::coop_t & coop) {
    const auto broadcasting_mbox = coop.environment().create_mbox();
    auto * bindings = coop.take_under_control(
      std::make_unique<so_5::multi_sink_binding_t<>>());
 
    auto * first = coop.make_agent<first_worker>(...);
    auto first_worker_msink = so_5::wrap_to_msink(first->so_direct_mbox());
 
    auto * second = coop.make_agent<second_worker>(...);
    auto second_worker_msink = so_5::wrap_to_msink(second->so_direct_mbox());
 
    bindings.bind<msg_some_data>(broadcasting_mbox, first_worker_msink);
    bindings.bind<msg_some_data>(broadcasting_mbox, second_worker_msink);
    bindings.bind<msg_some_notify>(broadcasting_mbox, first_worker_msink);
    bindings.bind<msg_another_notify>(broadcasting_mbox, second_worker_msink);
    ...
  });

The instance of multi_sink_binding_t is thread safe by the default (if the default value is used for template parameter Lock_Type). In single-threaded environments this can be unnecessary, so_5::null_mutex_t can be used in those cases:

// It's assumed that code works in single-threaded environment.
so_5::environment_t & env = ...;
env.introduce_coop([](so_5::coop_t & coop) {
    const auto broadcasting_mbox = coop.environment().create_mbox();
    auto * bindings = coop.take_under_control(
      std::make_unique<so_5::multi_sink_binding_t<so_5::null_mutex_t>>());

Note

This class isn't Copyable, not Moveable. Once created an instance of that type can't be copied or moved.

Template Parameters

Lock_Type

Type to be used for thread-safety. It should be a std::mutex-like class. If thread-safety isn't needed then so_5::null_mutex_t can be used.

Since

v.5.8.0

Examples

so_5/bind_transformer/main.cpp.

Definition at line 401 of file multi_sink_binding.hpp.

Constructor & Destructor Documentation

multi_sink_binding_t() [1/3]

template<typename Lock_Type = std::mutex>

so_5::multi_sink_binding_t< Lock_Type >::multi_sink_binding_t ( )

default

multi_sink_binding_t() [2/3]

template<typename Lock_Type = std::mutex>

so_5::multi_sink_binding_t< Lock_Type >::multi_sink_binding_t ( const multi_sink_binding_t< Lock_Type > & )

delete

multi_sink_binding_t() [3/3]

template<typename Lock_Type = std::mutex>

so_5::multi_sink_binding_t< Lock_Type >::multi_sink_binding_t ( multi_sink_binding_t< Lock_Type > && )

delete

Member Function Documentation

bind() [1/3]

template<typename Lock_Type = std::mutex>

template<typename Msg >

void so_5::multi_sink_binding_t< Lock_Type >::bind ( const mbox_t & from, const msink_t & dest )

inline

Create a binding for message/signal of type Msg from mbox from to the destination dest.

This binding won't use a delivery filter.

An exception will be thrown if such a binding already exists.

Usage example:

const so_5::mbox_t & source = ...;
const so_5::msink_t & dest = ...;
auto binding = std::make_unique< so_5::multi_sink_binding_t<> >();
 
binding->bind<my_message>(source, dest);
binding->bind<my_signal>(source, dest);

It it's required to make a binding for a mutable message then so_5::mutable_msg marker has to be used:

const so_5::mbox_t & source = ...;
const so_5::msink_t & dest = ...;
auto binding = std::make_unique< so_5::multi_sink_binding_t<> >();
 
binding->bind< so_5::mutable_msg<my_message> >(source, dest);

Parameters

from	The source mbox.
dest	The destination for messages.

Definition at line 446 of file multi_sink_binding.hpp.

bind() [2/3]

template<typename Lock_Type = std::mutex>

template<typename Msg >

void so_5::multi_sink_binding_t< Lock_Type >::bind ( const mbox_t & from, const msink_t & dest, delivery_filter_unique_ptr_t delivery_filter )

inline

Create a binding for message of type Msg from mbox from to the destination dest.

This binding should use delivery filter delivery_filter.

An exception will be thrown if such a binding already exists.

Note

This method can't be used for binding signals.

Parameters

from	The source mbox.
dest	The destination for messages.
delivery_filter	Delivery filter to be used. It shouldn't be nullptr.

Definition at line 472 of file multi_sink_binding.hpp.

bind() [3/3]

template<typename Lock_Type = std::mutex>

template<typename Msg , typename Lambda >

void so_5::multi_sink_binding_t< Lock_Type >::bind ( const mbox_t & from, const msink_t & dest, Lambda && filter )

inline

Create a binding for message of type Msg from mbox from to the destination dest.

The lambda (or functor) filter will be used as delivery filter for messages.

An exception will be thrown if such a binding already exists.

Note

This method can't be used for binding signals.

Usage example:

const so_5::mbox_t & source = ...;
const so_5::msink_t & dest = ...;
auto binding = std::make_unique< so_5::multi_sink_binding_t<> >();
 
binding->bind<my_message>(source, dest,
  [](const my_message & msg) {
    ... // should return `true` or `false`.
  });

It it's required to make a binding for a mutable message then so_5::mutable_msg marker has to be used, but note the type of delivery filter argument:

const so_5::mbox_t & source = ...;
const so_5::msink_t & dest = ...;
auto binding = std::make_unique< so_5::multi_sink_binding_t<> >();
 
binding->bind< so_5::mutable_msg<my_message> >(source, dest,
  [](const my_message & msg) {
    ... // should return `true` or `false`.
  });

Parameters

from	The source mbox.
dest	The destination for messages.
filter	Delivery filter to be used.

Definition at line 530 of file multi_sink_binding.hpp.

clear()

template<typename Lock_Type = std::mutex>

void so_5::multi_sink_binding_t< Lock_Type >::clear ( )

inlinenoexcept

Remove all exising bindings.

Definition at line 643 of file multi_sink_binding.hpp.

operator=() [1/2]

template<typename Lock_Type = std::mutex>

multi_sink_binding_t & so_5::multi_sink_binding_t< Lock_Type >::operator= ( const multi_sink_binding_t< Lock_Type > & )

delete

operator=() [2/2]

template<typename Lock_Type = std::mutex>

multi_sink_binding_t & so_5::multi_sink_binding_t< Lock_Type >::operator= ( multi_sink_binding_t< Lock_Type > && )

delete

unbind()

template<typename Lock_Type = std::mutex>

template<typename Msg >

void so_5::multi_sink_binding_t< Lock_Type >::unbind ( const mbox_t & from, const msink_t & dest )

inlinenoexcept

Remove binding for message/signal of type Msg from mbox from to the destination dest.

It is safe to call this method if such a binding doesn't exist.

Usage example:

const so_5::mbox_t & source = ...;
const so_5::msink_t & dest = ...;
so_5::multi_sink_binding_t & bindings = ...;
 
binding->unbind<my_message>(source, dest);
binding->unbind<my_signal>(source, dest);

Parameters

from	The source mbox.
dest	The destination for messages.

Definition at line 600 of file multi_sink_binding.hpp.

unbind_all_for()

template<typename Lock_Type = std::mutex>

void so_5::multi_sink_binding_t< Lock_Type >::unbind_all_for ( const mbox_t & from, const msink_t & dest )

inlinenoexcept

Remove binding for all message/signal types from mbox from to the destination dest.

It is safe to call this method if there is no any binding for (form, dest) pair.

Usage example:

const so_5::mbox_t & source = ...;
const so_5::msink_t & dest = ...;
so_5::multi_sink_binding_t & bindings = ...;
 
binding->unbind_all_for(source, dest);

Parameters

from	The source mbox.
dest	The destination for messages.

Definition at line 628 of file multi_sink_binding.hpp.

---

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

• multi_sink_binding.hpp