void create_new_child_coop()
{
// The cooperation will use active_obj dispatcher.
auto disp = so_5::disp::active_obj::create_private_disp(
so_environment() );
auto coop = so_5::create_child_coop(
// This agent will be parent for new cooperation.
*this,
// Name for the cooperation will be generated automatically.
so_5::autoname,
// The main dispatcher for the new cooperation is
// the private active_obj dispatcher.
disp->binder() );
// We should receive notification about complete
// child cooperation deregistration.
coop->add_dereg_notificator(
so_5::make_coop_dereg_notificator( so_direct_mbox() ) );
auto first_mbox = fill_coop( *coop );
so_environment().register_coop( std::move( coop ) );
// Initial message must be sent to the first chain's member.
so_5::send< a_chain_member_t::msg_your_turn >( first_mbox );
}
void
so_evt_start()
{
ensure_counter_value( m_message_counter, 0 );
m_id1 = so_environment().schedule_timer(
make_message_object(),
so_direct_mbox(),
6000,
0 );
m_id2 = so_environment().schedule_timer(
make_message_object(),
so_direct_mbox(),
6000,
1000 );
m_id3 = so_environment().schedule_timer(
make_message_object(),
so_direct_mbox(),
6000,
0 );
m_id4 = so_environment().schedule_timer(
make_message_object(),
so_direct_mbox(),
6000,
1000 );
m_id1.release();
m_id2.release();
ensure_counter_value( m_message_counter, 2 );
so_deregister_agent_coop_normally();
}
virtual void
so_evt_start()
{
so_environment().register_agent_as_coop(
"parent",
new a_parent_t( so_environment(), m_mbox ),
so_5::disp::active_obj::create_disp_binder( "active_obj" ) );
}
void
so_evt_start()
{
so_environment().single_timer< msg_stop >( m_mbox, 1000 );
so_environment().single_timer(
std::unique_ptr< msg_test >( new msg_test() ), m_mbox, 0 );
m_mbox->deliver_signal< msg_do_resend >();
}
shutdowner( context_t ctx, unsigned int producers_count )
: so_5::agent_t{ ctx }
, m_producers_left{ producers_count }
{
so_subscribe( so_environment().create_mbox( "shutdowner" ) )
.event< another_producer_finished >( [this] {
--m_producers_left;
if( !m_producers_left )
so_environment().stop();
} );
}
virtual void
so_evt_start()
{
so_5::mbox_t mbox = so_environment()
.create_mbox( so_coop_name() + "_mbox" );
so_subscribe( mbox )
.in( so_default_state() )
.event( &a_master_t::evt_slave_finished );
so_environment().register_agent_as_coop(
so_coop_name() + "_slave",
new a_slave_t( so_environment(), mbox ) );
}
virtual void
so_evt_start()
{
auto child = so_environment().create_coop(
so_coop_name() + "::child" );
child->set_parent_coop_name( so_coop_name() );
auto mbox = so_environment().create_mbox();
child->add_agent( new a_test_t( so_environment(), mbox ) );
so_environment().register_coop( std::move(child) );
mbox->deliver_signal< msg_test_signal >();
}
test_agent_t(
so_5::environment_t & env )
:
base_type_t( env ),
m_test_mbox( so_environment().create_mbox() )
{
}
void
so_evt_start()
{
so_environment().deregister_coop(
so_coop_name(),
so_5::dereg_reason::normal );
}
void
evt_slave_finished(
const so_5::event_data_t< slave_coop_finished_signal > & )
{
std::cout << "Shutdown\n";
so_environment().stop();
}
void
evt_four( const so_5::event_data_t< msg_four > & )
{
m_sequence += "e4:";
so_environment().stop();
}
virtual void
so_define_agent()
{
so_subscribe( m_self_mbox )
.event< msg_shutdown >(
[this]() { so_environment().stop(); } );
}
void
evt_st_2_three( const so_5::rt::event_data_t< msg_three > & )
{
m_sequence += "2_d3:";
so_environment().stop();
}
virtual void
so_evt_start()
{
try
{
m_svc_mbox->get_one< std::string >()
.wait_forever()
.sync_get( new msg_convert( 3 ) );
std::cerr << "An exception rc_more_than_one_svc_handler expected"
<< std::endl;
std::abort();
}
catch( const so_5::exception_t & x )
{
if( so_5::rc_more_than_one_svc_handler != x.error_code() )
{
std::cerr << "Unexpected error_code: "
<< x.error_code()
<< ", expected: "
<< so_5::rc_no_svc_handlers
<< std::endl;
std::abort();
}
}
so_environment().stop();
}
void a_hello_t::evt_stop_signal()
{
show_message( "Stop SObjectizer..." );
// Shutting down SObjectizer.
so_environment().stop();
}
void
evt_parent_started()
{
auto coop = so_environment().create_coop( "child",
so_5::disp::active_obj::create_disp_binder( "active_obj" ) );
coop->set_parent_coop_name( "parent" );
coop->add_agent(
new a_child_t(
so_environment(),
so_environment().create_mbox(),
m_mbox ) );
so_environment().register_coop( std::move( coop ) );
so_environment().single_timer< msg_shutdown >( m_mbox, 500 );
}
virtual void
so_evt_start()
{
so_environment().deregister_coop(
so_coop_name(),
so_5::dereg_reason::normal );
m_master_mbox->deliver_signal< slave_coop_finished_signal >();
}
virtual void
so_evt_start()
{
// Schedule periodic message.
m_timer_ref = so_environment().schedule_timer< test_message >(
m_test_mbox,
150,
100 );
}
void
so_evt_start()
{
auto child_coop = so_environment().create_coop( "child" );
child_coop->set_parent_coop_name( so_coop_name() );
child_coop->add_reg_notificator( m_reg_notificator );
child_coop->add_dereg_notificator( m_dereg_notificator );
child_coop->add_dereg_notificator(
[this]( so_5::environment_t &,
const std::string &,
const so_5::coop_dereg_reason_t &)
{
m_mbox->deliver_signal< msg_child_deregistered >();
} );
child_coop->add_agent( new a_child_t( so_environment() ) );
so_environment().register_coop( std::move( child_coop ) );
}
// Definition of an agent for SObjectizer.
virtual void so_define_agent() override
{
// The hello message subscription.
so_subscribe_self().event( [this]( const std::string & msg ) {
std::cout << msg << std::endl;
// Shutting down SObjectizer.
so_environment().stop();
} );
}
void
try_start_new_iteration()
{
if( m_iterations_left <= 0 )
{
std::cout << "COMPLETED!" << std::endl;
so_environment().stop();
return;
}
std::cout << m_iterations_left << " iterations left...\r"
<< std::flush;
m_state = state_t::awaiting_creation;
m_acks_received = 0;
m_destroy_received = 0;
m_child_mboxes = std::vector< so_5::rt::mbox_t >();
m_child_mboxes.reserve( m_max_agents );
auto coop = so_environment().create_coop( "child" );
coop->set_parent_coop_name( so_coop_name() );
coop->add_reg_notificator(
so_5::rt::make_coop_reg_notificator( so_direct_mbox() ) );
coop->add_dereg_notificator(
so_5::rt::make_coop_dereg_notificator( so_direct_mbox() ) );
for( std::size_t i = 0; i != m_max_agents; ++i )
{
std::unique_ptr< so_5::rt::agent_t > agent(
new a_child_t(
so_environment(),
so_direct_mbox() ) );
m_child_mboxes.push_back( agent->so_direct_mbox() );
coop->add_agent( std::move( agent ) );
}
so_environment().register_coop( std::move( coop ) );
}
void
my_agent_t::change_state_event_handler(
const change_state_message & message )
{
std::cout << "change_state_event_handler()" << std::endl;
if( DEFAULT_STATE == message.m_next_state )
{
this >>= so_default_state();
std::cout << "\tswitched to default state and shutdown..." << std::endl;
so_environment().stop();
}
virtual void
so_define_agent()
{
so_5::mbox_t mbox = so_environment()
.create_mbox( g_test_mbox_name );
so_subscribe( mbox )
.in( so_default_state() )
.event( &a_ordinary_t::some_handler );
// Give time to test message sender.
std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
}
a_shutdowner_t(
so_5::rt::environment_t & env,
const so_5::rt::mbox_t & mbox,
unsigned int sender_count )
: so_5::rt::agent_t( env )
, m_sender_count( sender_count )
{
so_subscribe( mbox ).event< msg_complete >(
[=] {
m_sender_count -= 1;
if( !m_sender_count )
so_environment().stop();
} );
}
void
test_agent_t::evt_test(
const so_5::event_data_t< test_message > & )
{
if( m_test_evt_count == ++m_evt_count )
{
// Reschedule message. Old timer event should be released.
m_timer_ref =
so_environment().schedule_timer< stop_message >(
m_test_mbox,
400,
0 );
}
}
void
evt_child_started(
const so_5::event_data_t< msg_child_started > & )
{
m_started_children += 1;
if( m_started_children == m_max_children )
{
if( m_level )
notify_parent();
else
so_environment().deregister_coop(
so_coop_name(),
so_5::dereg_reason::normal );
}
}
void
evt_ack()
{
if( m_state != state_t::awaiting_acks )
throw std::runtime_error( "msg_ack when "
"m_state != state_t::awaiting_acks" );
++m_acks_received;
if( m_acks_received == m_max_agents )
{
m_state = state_t::awaiting_destroying;
so_environment().deregister_coop( "child",
so_5::rt::dereg_reason::normal );
}
}
void
so_evt_start()
{
if( m_level != m_max_deep )
{
for( int i = 0; i != m_max_children; ++i )
create_and_register_agent(
so_environment(),
m_self_name,
i,
m_max_children,
m_level + 1,
m_max_deep );
}
else
notify_parent();
}
void
evt_next_back_call_convert(
const so_5::rt::event_data_t< msg_next_convert > & )
{
if( m_back_call_actions_current <
m_back_call_actions.size() )
{
m_back_call_actions[ m_back_call_actions_current ]();
++m_back_call_actions_current;
m_self_mbox->deliver_signal< msg_next_convert >();
}
else
{
so_environment().stop();
}
}
void
so_evt_start() override
{
auto coop = so_5::rt::create_child_coop( *this, "child" );
// Add necessary cooperation notificators for coop.
coop->add_reg_notificator(
so_5::rt::make_coop_reg_notificator( so_direct_mbox() ) );
coop->add_reg_notificator( normal_coop_reg_notificator );
coop->add_reg_notificator( invalid_coop_reg_notificator );
// A cooperation agent.
coop->define_agent()
.on_start( []() { std::cout << "Child started!" << std::endl; } );
std::cout << "registering coop: " << coop->query_coop_name()
<< std::endl;
// Registering cooperation.
so_environment().register_coop( std::move( coop ) );
}
