so_5/hello_periodic/main.cpp

/*
 * A sample of a simple agent which sends a periodic message to itself.
 */

#if defined( _MSC_VER )
  #if defined( __clang__ )
    #pragma clang diagnostic ignored "-Wreserved-id-macro"
  #endif
  #define _CRT_SECURE_NO_WARNINGS
#endif

// Main SObjectizer header files.
#include <so_5/all.hpp>

#include <time.h>

// Hello message.
struct msg_hello_periodic
{
  // Greeting.
  std::string m_message;
};

// Stop message.
class msg_stop_signal final : public so_5::signal_t {};

// Agent for stopping an example on stop_signal.
class a_shutdowner_t final : public so_5::agent_t
{
  public:
    using so_5::agent_t::agent_t;

    void so_define_agent() override
    {
      so_subscribe( so_environment().create_mbox( "shutdown" ) )
        .event( &a_shutdowner_t::evt_stop_signal );
    }

  private:
    void evt_stop_signal( mhood_t<msg_stop_signal> )
    {
      time_t t = time( nullptr );
      std::cout << asctime( localtime( &t ) )
        << "Stop SObjectizer..." << std::endl;

      // Shutting down SObjectizer.
      so_environment().stop();
    }
};

// An agent class definition.
class a_hello_t final : public so_5::agent_t
{
  public:
    a_hello_t( context_t ctx )
      : so_5::agent_t{ ctx }
      , m_shutdowner_mbox( so_environment().create_mbox( "shutdown" ) )
      , m_evt_count( 0 )
    {}

    // Definition of an agent for SObjectizer.
    void so_define_agent() override;

    // A reaction to start of work in SObjectizer.
    void so_evt_start() override;

  private:
    // Shutdowner's mbox.
    const so_5::mbox_t m_shutdowner_mbox;

    // Timer events' identifiers.
    so_5::timer_id_t m_hello_timer_id;
    so_5::timer_id_t m_stop_timer_id;

    // How much timer event has been processed.
    unsigned int m_evt_count;

    // Hello message handler.
    void evt_hello_periodic( const msg_hello_periodic & msg );
};

void a_hello_t::so_define_agent()
{
  // Message subscription.
  so_subscribe_self().event( &a_hello_t::evt_hello_periodic );
}

void a_hello_t::so_evt_start()
{
  time_t t = time( nullptr );
  std::cout << asctime( localtime( &t ) )
    << "a_hello_t::so_evt_start()" << std::endl;

  // Sending a greeting.
  m_hello_timer_id = so_5::send_periodic< msg_hello_periodic >(
    *this,
    // Delay for a second.
    std::chrono::seconds(1),
    // Repeat every 1.25 of seconds.
    std::chrono::milliseconds(1250),
    "Hello, periodic!" );

  // Sending a stop signal.
  m_stop_timer_id = so_5::send_periodic< msg_stop_signal >(
    m_shutdowner_mbox,
    // Delay for two seconds.
    std::chrono::seconds(2),
    // Not a periodic.
    std::chrono::seconds::zero() );
}

void a_hello_t::evt_hello_periodic( const msg_hello_periodic & msg )
{
  time_t t = time( nullptr );
  std::cout << asctime( localtime( &t ) ) << msg.m_message << std::endl;

  if( 5 == ++m_evt_count )
  {
    // Stops hello message.
    m_hello_timer_id.release();
  }
  else
  {
    // Reschedule a stop signal.
    // Previous a stop signal should be canceled.
    m_stop_timer_id = so_5::send_periodic< msg_stop_signal >(
      m_shutdowner_mbox,
      // 1300ms but specified in microsecs just for demonstration.
      std::chrono::microseconds(1300000),
      std::chrono::seconds::zero() );
  }
}

// Creation of 'hello' cooperation.
void create_hello_coop( so_5::environment_t & env )
{
  // Single agent can be registered as whole cooperation.
  env.register_agent_as_coop( env.make_agent< a_hello_t >() );
}

// Creation of 'shutdowner' cooperation.
void create_shutdowner_coop( so_5::environment_t & env )
{
  env.register_agent_as_coop( env.make_agent< a_shutdowner_t >() );
}

// The SObjectizer Environment initialization.
void init( so_5::environment_t & env )
{
  create_hello_coop( env );
  create_shutdowner_coop( env );
}

int main()
{
  try
  {
    so_5::launch( &init );
  }
  catch( const std::exception & ex )
  {
    std::cerr << "Error: " << ex.what() << std::endl;
    return 1;
  }

  return 0;
}