demo1.h

Go to the documentation of this file.

/****
 Active Object compiled file
 Copyright (C) 2006-2010 Werner Van Belle
 Do not modify. Changes might be lost
 --------------------------------------------
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
****/

#ifndef __DEMO1_H
#define __DEMO1_H
#include "active-objects.h"
using namespace std;
class DemoSender;
class ActiveDemoSender;
#ifdef TRACE_MESSAGES
#define ENTER_MSG cerr << "Start " << declaration() << "\n";
#define LEAVE_MSG cerr << "Stop " << declaration()  << "\n";
#endif
#ifndef ENTER_MSG
#define ENTER_MSG ;
#endif
#ifndef LEAVE_MSG
#define LEAVE_MSG ;
#endif
class DemoReceiver;
class ActiveDemoReceiver;
#ifdef TRACE_MESSAGES
#define ENTER_MSG cerr << "Start " << declaration() << "\n";
#define LEAVE_MSG cerr << "Stop " << declaration()  << "\n";
#endif
#ifndef ENTER_MSG
#define ENTER_MSG ;
#endif
#ifndef LEAVE_MSG
#define LEAVE_MSG ;
#endif

//-------------------------------------
// Active Object base messaging classes
//-------------------------------------
class ActiveDemoSender_msg_
{
  public:
    virtual elementResult run(ActiveDemoSender * /* caller */)
    {
      assert(0);
    }
    virtual string declaration()
    {
      return "Unknown message";
    }
};

class ActiveDemoReceiver_msg_
{
  public:
    virtual elementResult run(ActiveDemoReceiver * /* caller */)
    {
      assert(0);
    }
    virtual string declaration()
    {
      return "Unknown message";
    }
};


//-------------------------------------
// Main object definition
//-------------------------------------
class ActiveDemoSender: public ActiveObject< ActiveDemoSender_msg_* >
{
  friend class DemoSender;
  DemoSender * self;
    virtual elementResult handle( ActiveDemoSender_msg_* cmd)
      {
        if (cmd) return cmd->run(this);
        else return Done;
      };
  volatile int tosend;
  DemoReceiver* recv;
  public: elementResult startSending(DemoReceiver* recv, int nr);
  protected: void queue_startSending(DemoReceiver* recv, int nr);
  protected:
    ActiveDemoSender(DemoSender* s, string name):
      ActiveObject< ActiveDemoSender_msg_ * >(name), self(s)
      {
      tosend =  20;
      };
};

class ActiveDemoReceiver: public ActiveObject< ActiveDemoReceiver_msg_* >
{
  friend class DemoReceiver;
  DemoReceiver * self;
    virtual elementResult handle( ActiveDemoReceiver_msg_* cmd)
      {
        if (cmd) return cmd->run(this);
        else return Done;
      };
  public: elementResult printNumber(int nr);
  protected: void queue_printNumber(int nr);
  protected:
    ActiveDemoReceiver(DemoReceiver* s, string name):
      ActiveObject< ActiveDemoReceiver_msg_ * >(name), self(s)
      {
      };
};


//-------------------------------------
// Specific messaging classes 
//-------------------------------------
class ActiveDemoSender_msg_startSending: public ActiveDemoSender_msg_
{
    DemoReceiver* recv;
    int nr;
  public:
    ActiveDemoSender_msg_startSending(DemoReceiver* recv, int nr) : recv(recv), nr(nr)
      {
      };
    virtual string declaration()
    {
      return "DemoSender::startSending(DemoReceiver* recv, int nr)";
    }
    virtual elementResult run(ActiveDemoSender * ao)
      {
        ENTER_MSG;
        elementResult res = ao->startSending(recv, nr);
        LEAVE_MSG;
        return res;
      };
};

class ActiveDemoReceiver_msg_printNumber: public ActiveDemoReceiver_msg_
{
    int nr;
  public:
    ActiveDemoReceiver_msg_printNumber(int nr) : nr(nr)
      {
      };
    virtual string declaration()
    {
      return "DemoReceiver::printNumber(int nr)";
    }
    virtual elementResult run(ActiveDemoReceiver * ao)
      {
        ENTER_MSG;
        elementResult res = ao->printNumber(nr);
        LEAVE_MSG;
        return res;
      };
};


//-------------------------------------
// Active Object wrapper 
//-------------------------------------
class DemoSender
{
  private:
    ActiveDemoSender object;
  public:
    DemoSender(string name="DemoSender"): object(this, name) {};
  public:
    void startSending(DemoReceiver* recv, int nr)
    {
      object.queue_startSending(recv, nr);
    };
  public:
    void donothing();
};

class DemoReceiver
{
  private:
    ActiveDemoReceiver object;
  public:
    DemoReceiver(string name="DemoReceiver"): object(this, name) {};
  public:
    void printNumber(int nr)
    {
      object.queue_printNumber(nr);
    };
};


//-------------------------------------
// Active Object Methods
//-------------------------------------
inline void ActiveDemoSender::queue_startSending(DemoReceiver* recv, int nr)
  {
    push(new ActiveDemoSender_msg_startSending(recv, nr));
  };
inline void ActiveDemoReceiver::queue_printNumber(int nr)
  {
    push(new ActiveDemoReceiver_msg_printNumber(nr));
  };
#endif // __DEMO1_H

---