baciBACIAction.h

Go to the documentation of this file.

#ifndef baciBACIAction_H
#define baciBACIAction_H

/*******************************************************************
* ALMA - Atacama Large Millimiter Array
* (c) European Southern Observatory, 2003 
*
*This library is free software; you can redistribute it and/or
*modify it under the terms of the GNU Lesser General Public
*License as published by the Free Software Foundation; either
*version 2.1 of the License, or (at your option) any later version.
*
*This library 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
*Lesser General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with this library; if not, write to the Free Software
*Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*
* "@(#) $Id: baciBACIAction.h,v 1.7 2008/06/03 09:14:47 bjeram Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* bgustafs 2001-07-12 changed name of parameter in setCompletion
* msekoran  2001/03/04 modified
*/

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include "baciExport.h"
#include "baciValue.h"

#include <deque>

namespace baci {


// forwards
class BACIComponent;

enum ActionRequest { reqNone=0, 
                                 reqInvokeWorking=1, 
                                 reqInvokeDone=2, 
                                 reqDestroy=3 };

class baci_EXPORT ActionImplementator 
{
public:
  virtual ActionRequest invokeAction(int function,
                                     BACIComponent* component_p, 
                                     const int &callbackID, 
                                     const CBDescIn& descIn, 
                                     BACIValue* value, 
                                     Completion& completion, 
                                     CBDescOut& descOut) = 0;

  virtual ~ActionImplementator() {}

};   /* ActionImplementator */

/* ------------------------------------------------------------------------ */

class baci_EXPORT BACIAction 
{

public:

  BACIAction() : actionFunction_m(0), actionImplementator_mp(0),
    callbackID_m(-1), value_m(BACIValue::NullValue), completed_m(false) {}

  BACIAction(ActionImplementator* actionImplementator_,
             int actionFunction_, 
             int callbackID_) :
    actionFunction_m(actionFunction_),
    actionImplementator_mp(actionImplementator_),
    callbackID_m(callbackID_), 
    value_m(BACIValue(BACIValue::NullValue)),
    completed_m(false)
  {
  }

  BACIAction(ActionImplementator* actionImplementator_,
             int actionFunction_, 
             int callbackID_, const BACIValue& value_): 
    actionFunction_m(actionFunction_), 
    actionImplementator_mp(actionImplementator_),
    callbackID_m(callbackID_), 
    value_m(value_),
    completed_m(false)
  {
  }
  
  BACIAction& operator=(const BACIAction& action)
  {
    if (this!=&action) 
      { 
        actionFunction_m=action.actionFunction_m;
        actionImplementator_mp=action.actionImplementator_mp;
        callbackID_m=action.callbackID_m;
        value_m=action.value_m;
        completed_m=action.completed_m;
        completion_m=action.completion_m;
      } 
    return *this;
  }
  
  bool operator==(const BACIAction& action) const { return callbackID_m==action.callbackID_m; }

    ActionRequest invoke(BACIComponent* component_p, 
                         int callbackID_, 
                         const CBDescIn& descIn, 
                         BACIValue* value, 
                         Completion& completion, 
                         CBDescOut& descOut) 
  {
    return actionImplementator_mp->invokeAction(actionFunction_m, component_p, callbackID_, descIn, 
                                             value, completion, descOut);
  }  

  int getActionFunction() const { return actionFunction_m; }

  ActionImplementator* getActionImplementator() const { return actionImplementator_mp; }

  int getCallbackID() const { return callbackID_m; };

  BACIValue getValue() const { return value_m; }

  BACIValue* getValueRef() const { return const_cast<BACIValue*>(&value_m); }

  bool isCompleted() const { return completed_m; }

  Completion getCompletion() const { return completion_m; }

  void setCompletion(const Completion& c)
  { 
    completed_m = true;
    completion_m = c;
  }
          
private:

  int actionFunction_m;         

  ActionImplementator* actionImplementator_mp;

  int callbackID_m;

  BACIValue value_m;

  bool completed_m;

  Completion completion_m;
 
    BACIAction(const BACIAction&);

};   /* BACIAction */

typedef std::deque<BACIAction*> BACIActionQueue;

/* ------------------------------------------------------------------------ */

 }; 

#endif /* baci_H */