A template which allows to use tuples as messages. More...

#include <tuple_as_message.hpp>

Inheritance diagram for so_5::tuple_as_message_t< Tag, Types >:

Public Types
using	base_tuple_type = std::tuple< Types... >

Public Types inherited from so_5::message_t
using	kind_t = ::so_5::message_kind_t
	A short typedef for kind of message. More...

Public Member Functions
	tuple_as_message_t ()

	tuple_as_message_t (const tuple_as_message_t &)=default

tuple_as_message_t &	operator= (const tuple_as_message_t &)=default

	tuple_as_message_t (tuple_as_message_t &&)=default

tuple_as_message_t &	operator= (tuple_as_message_t &&)=default

	tuple_as_message_t (const Types &... args)

template<typename... Utypes>
	tuple_as_message_t (Utypes &&... args)

Public Member Functions inherited from so_5::message_t
	message_t ()

	message_t (const message_t &other)

	message_t (message_t &&other)

message_t &	operator= (const message_t &other)

message_t &	operator= (message_t &&other)

virtual	~message_t () SO_5_NOEXCEPT=default

Public Member Functions inherited from so_5::atomic_refcounted_t
	atomic_refcounted_t (const atomic_refcounted_t &)=delete

atomic_refcounted_t &	operator= (const atomic_refcounted_t &)=delete

	atomic_refcounted_t () SO_5_NOEXCEPT
	Default constructor. More...

	~atomic_refcounted_t () SO_5_NOEXCEPT=default
	Destructor. More...

void	inc_ref_count () SO_5_NOEXCEPT
	Increments reference count. More...

unsigned long	dec_ref_count () SO_5_NOEXCEPT
	Decrement reference count. More...

Detailed Description

template<typename Tag, typename... Types>
struct so_5::tuple_as_message_t< Tag, Types >

A template which allows to use tuples as messages.

Since: v.5.5.5

Template Parameters

Tag	a type tag for distinguish messages with the same fields list.
Types	types for message fields.

This template is added to allow a user to use simple constructs for very simple messages, when there is no need to define a full class for message.

Just for comparison:

// This is recommended way to defining of messages.
// Separate class allows to easily extend or refactor
// message type in the future.
struct process_data : public so_5::message_t
{
  const std::uint8_t * m_data;
  // Constructor is necessary.
  process_data( const std::uint8_t * data )
    : m_data( data )
  {}
};
// And the event-handler for this message.
void data_processing_agent::evt_process_data( const process_data & evt )
{
  do_data_processing( evt.m_data ); // Some processing 
}

And this the one possible usage of tuple_as_message_t for the same task:

// This way of defining messages is not recommended for big projects
// with large code base and big amount of agents and messages.
// But can be useful for small to-be-thrown-out utilities.
struct process_data_tag {};
using process_data = so_5::tuple_as_message_t< process_data_tag, const std::uint8_t * >;
// And the event-handler for this message.
void data_processing_agent::evt_process_data( const process_data & evt )
{
  do_data_processing( std::get<0>( evt ) );
}

Or even yet more simplier and dirtier:

// This way of defining messages can be good only for very and very
// small to-be-thrown-out programs (like tests and samples).
using process_data = so_5::tuple_as_message_t<
      std::integral_constant<int, 0>, const std::uint8_t * >;
// And the event-handler for this message.
void data_processing_agent::evt_process_data( const process_data & evt )
{
  do_data_processing( std::get<0>( evt ) );
}