Event.H

Go to the documentation of this file.

#ifndef EVENT_H
#define EVENT_H


#include "IS3DCommon.H"
#include "G3DOperators.H"

namespace IS3D {


class Event;
typedef ReferenceCountedPointer<class Event> EventRef;

EventRef createCopyOfEvent(EventRef e);

class Event : public ReferenceCountedObject
{
public:

  enum EventType {  
    EVENTTYPE_STANDARD = 0,        
    EVENTTYPE_1D = 1,              
    EVENTTYPE_2D = 2,              
    EVENTTYPE_3D = 3,              
    EVENTTYPE_COORDINATEFRAME = 4, 
    EVENTTYPE_MSG = 5              
  };

  Event(const std::string &name) { 
    _name = name;
    _type = EVENTTYPE_STANDARD;
  }

  Event(const std::string &name, const double data) { 
    _name = name;
    _data1D = data;
    _type = EVENTTYPE_1D;
  }

  Event(const std::string &name, const Vector2 &data) { 
    _name = name;
    _data2D = data;
    _type = EVENTTYPE_2D;
  }
  
  Event(const std::string &name, const Vector3 &data) { 
    _name = name;
    _data3D = data;
    _type = EVENTTYPE_3D;
  }

  Event(const std::string &name, const CoordinateFrame &data) { 
    _name = name;
    _dataCF = data;
    _type = EVENTTYPE_COORDINATEFRAME;
  }
  
  Event(const std::string &name, const std::string &data) { 
    _name = name;
    _dataMsg = data;
    _type = EVENTTYPE_MSG;
  }

  virtual ~Event() {}


  std::string     getName() const { return _name; }
  EventType       getType() const { return _type; }

  double          get1DData();
  Vector2         get2DData();
  Vector3         get3DData();
  CoordinateFrame getCoordinateFrameData();
  std::string     getMsgData();

  std::string     toString();

  void            rename(const std::string &newname) { _name = newname; }

  void serialize(BinaryOutput &b) const;
  void deserialize(BinaryInput &b);

protected:
  std::string     _name;
  EventType       _type;
  double          _data1D;
  Vector2         _data2D;
  Vector3         _data3D;
  CoordinateFrame _dataCF;
  std::string     _dataMsg;
};



// Functors allow for callback functions that are class methods
// in C++.  Google "C++ functors" for more information.
class EventCallbackFunctor
{
public:
  EventCallbackFunctor() {}
  virtual ~EventCallbackFunctor() {}
  virtual void exec(EventRef event) = 0;
};

template <class T>
class EventCallbackSpecificFunctor : public EventCallbackFunctor
{
public:
  typedef void (T::*MethodType)(EventRef event);

  EventCallbackSpecificFunctor(T *obj, MethodType meth) {
    _obj = obj;
    _method = meth;
  }

  virtual ~EventCallbackSpecificFunctor() {}

  void exec(EventRef event) {
    (_obj->*_method)(event);
  }
  
protected:
  T          *_obj;
  MethodType  _method;
};
// End functor bullshit


} // end namespace

#endif

---