context.h

/*
 *  Copyright (c) 2005-2007    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED_SCOPIRA_AGENT_CONTEXT_H__
#define __INCLUDED_SCOPIRA_AGENT_CONTEXT_H__

#include <typeinfo>

#include <scopira/tool/export.h>
#include <scopira/tool/uuid.h>
#include <scopira/tool/binflow.h>
#include <scopira/agent/task.h>
#include <scopira/agent/agent.h>

namespace scopira
{
  namespace agent
  {
    class service_broadcast;

    class send_msg;
    class recv_msg;

    class task_context;  // rename to task_context

    SCOPIRA_EXPORT void run_task(scopira::agent::task_context &ctx, scopira::agent::agent_task_i &t);
  }
}

class scopira::agent::service_broadcast
{
  public:
    service_broadcast(const scopira::tool::uuid &serviceid) : m_serviceud(serviceid) { }

    const scopira::tool::uuid & get_serviceid(void) const { return m_serviceud; }

  private:
    scopira::tool::uuid m_serviceud;
};

class scopira::agent::send_msg : public scopira::tool::bin64oflow
{
  public:
    SCOPIRA_EXPORT send_msg(scopira::agent::task_context &ctx, scopira::tool::uuid dest);
    SCOPIRA_EXPORT send_msg(scopira::agent::task_context &ctx, int dest);

    SCOPIRA_EXPORT send_msg(scopira::agent::task_context &ctx, const service_broadcast &targets);

    SCOPIRA_EXPORT virtual ~send_msg();

  private:
    // in the future, change the implementation to use direct-to-wire
    scopira::tool::uuid dm_src, dm_dest;
    scopira::tool::count_ptr<scopira::tool::bufferflow> dm_buf;

    bool dm_service_bcast;
};

class scopira::agent::recv_msg : public scopira::tool::bin64iflow
{
  public:
    SCOPIRA_EXPORT recv_msg(scopira::agent::task_context &ctx, scopira::tool::uuid src);
    SCOPIRA_EXPORT recv_msg(scopira::agent::task_context &ctx, int src);
    SCOPIRA_EXPORT recv_msg(scopira::agent::task_context &ctx, const uuid_query &Q);

    SCOPIRA_EXPORT virtual ~recv_msg();

    scopira::tool::uuid get_source(void) const { return dm_lastsrc; }

  private:
    scopira::tool::uuid dm_lastsrc, dm_dest;
    scopira::tool::count_ptr<scopira::tool::bufferiflow> dm_buf;
    scopira::tool::count_ptr<scopira::tool::bufferflow> dm_realbuf;
};

class scopira::agent::task_context
{
  public:
    SCOPIRA_EXPORT task_context(void);
    SCOPIRA_EXPORT task_context(taskmsg_reactor_i *reac);
    // internal ctor for scopira use, DO NOT USE
    SCOPIRA_EXPORT task_context(int myindex, const scopira::basekit::narray<scopira::tool::uuid> &peers);
    SCOPIRA_EXPORT ~task_context();

    bool failed(void) const { return agent_i::instance()->failed(); }

    int find_services(scopira::tool::uuid &serviceid, scopira::basekit::narray<scopira::tool::uuid> &out);

    int universe_size(void)
      { return agent_i::instance()->universe_size(); }

    scopira::tool::uuid get_agent_id(void) { return agent_i::instance()->get_agent_id(); }

    template <class M>
      scopira::tool::uuid launch_task(scopira::tool::uuid where = scopira::tool::uuid())
        { return agent_i::instance()->launch_task(typeid(M), where); }
    SCOPIRA_EXPORT scopira::tool::uuid launch_task(const std::string &classname, scopira::tool::uuid where = scopira::tool::uuid());
    
    //scopira::tool::uuid launch_task(const std::type_info &t)
      //{ return agent_i::instance()->launch_task(t); }

    template <class M>
      scopira::tool::uuid launch_group(int numps)
        { return agent_i::instance()->launch_group(numps, typeid(M)); }
    SCOPIRA_EXPORT scopira::tool::uuid launch_group(int numps, const std::string &classname);

    //scopira::tool::uuid launch_group(int numps, const std::type_info &t)
      //{ return agent_i::instance()->launch_group(numps, t); }

    template <class M>
      void launch_slaves(int numps)    // doesnt block
        { launch_slaves_impl(numps, typeid(M)); }
    SCOPIRA_EXPORT void launch_slaves(int numps, const std::string &classname);

    void kill_task(scopira::tool::uuid ps)
      { agent_i::instance()->kill_task(ps); }

    bool wait_task(scopira::tool::uuid ps, int msec = 0)
      { return agent_i::instance()->wait_task(ps, msec); }

    bool is_alive_task(scopira::tool::uuid ps)
      { return agent_i::instance()->is_alive_task(ps); }

    bool is_killed_task(void)
      { return agent_i::instance()->is_killed_task(dm_peers[dm_myindex]); }

    SCOPIRA_EXPORT bool wait_msg(scopira::tool::uuid src, int timeout = 0);
    SCOPIRA_EXPORT bool wait_msg(int src = -1, int timeout = 0);
    SCOPIRA_EXPORT bool wait_msg(const scopira::agent::uuid_query &Q, int timeout = 0);

    SCOPIRA_EXPORT bool has_msg(scopira::tool::uuid src);
    SCOPIRA_EXPORT bool has_msg(int src = -1);
    SCOPIRA_EXPORT bool has_msg(const scopira::agent::uuid_query &Q);

    scopira::tool::uuid get_source(void) const { return dm_lastsrc; }

    int get_index(void) const { assert(dm_myindex>=0); return dm_myindex; }
    SCOPIRA_EXPORT int get_index(scopira::tool::uuid id) const;
    int get_group_size(void) const { return static_cast<int>(dm_peers.size()); }
    scopira::tool::uuid get_id(void) const { return dm_peers[dm_myindex]; }
    scopira::tool::uuid get_id(int idx) const { return dm_peers[idx]; }
    const scopira::basekit::narray<scopira::tool::uuid> & get_group(void) const { return dm_peers; }

    SCOPIRA_EXPORT void barrier_group(void);

    SCOPIRA_EXPORT void wait_group(void);

  private:
    SCOPIRA_EXPORT void launch_slaves_impl(int numtotalps, const std::type_info &nfo);

  private:
    scopira::tool::count_ptr<agent_i> dm_server_link;

    // for wait_msg*
    scopira::tool::uuid dm_lastsrc;

    // group stuff... [0] is the master... the group size is always atleast one
    // [dm_myindex] is me
    scopira::basekit::narray<scopira::tool::uuid> dm_peers;
    int dm_myindex;

    // dont even try it (disabled)
    task_context(const task_context &) { }

  friend class scopira::agent::send_msg;
  friend class scopira::agent::recv_msg;
};

#endif