Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members

SignalDispatcher.h

00001 #ifndef ERIS_SIGNAL_DISPATCH_H
00002 #define ERIS_SIGNAL_DISPATCH_H
00003 
00004 #include <Eris/Dispatcher.h>
00005 
00006 #include <Atlas/Message/Element.h>
00007 
00008 #include <sigc++/object.h>
00009 #include <sigc++/signal.h>
00010 #include <sigc++/slot.h>
00011 
00012 namespace Eris {
00013 
00014 template <class T>
00015 class SignalDispatcher :
00016         public LeafDispatcher, 
00017         virtual public SigC::Object
00018 {
00019 public:
00020         SignalDispatcher(const std::string &nm, const SigC::Slot1<void, const T& > &slot) :
00021                 LeafDispatcher(nm)
00022         { Signal.connect(slot); }
00023 
00024         virtual ~SignalDispatcher() {;}
00025 
00027         virtual bool dispatch(DispatchContextDeque &dq)
00028         {
00029                 T object;
00030                 Atlas::Message::Element::MapType::const_iterator I = dq.front().asMap().begin();
00031                 
00032                 for (; I != dq.front().asMap().end(); ++I)
00033                         object.setAttr(I->first, I->second);
00034                 Signal.emit(object);
00035                 
00036                 return LeafDispatcher::dispatch(dq);
00037         }
00038 
00040         SigC::Signal1<void, const T&> Signal;
00041 protected:
00042         
00043 };
00044 
00045 class SignalDispatcher0 :
00046         public LeafDispatcher, 
00047         virtual public SigC::Object
00048 {
00049 public:
00050         SignalDispatcher0(const std::string &nm, const SigC::Slot0<void> &slot) :
00051                 LeafDispatcher(nm)
00052         { Signal.connect(slot); }
00053 
00054         virtual ~SignalDispatcher0() {;}
00055 
00057         virtual bool dispatch(DispatchContextDeque &dq)
00058         {
00059                 Signal.emit();
00060                 return LeafDispatcher::dispatch(dq);
00061         }
00062 
00064         SigC::Signal0<void> Signal;
00065 protected:
00066         
00067 };
00068 
00069 template <class T, class S>
00070 class SignalDispatcher2 :
00071         public LeafDispatcher, 
00072         virtual public SigC::Object
00073 {
00074 public:
00075         SignalDispatcher2(const std::string &nm, 
00076                 const SigC::Slot2<void, const T&, const S& > &slot) :
00077                 LeafDispatcher(nm)
00078         { Signal.connect(slot); }
00079 
00080         virtual ~SignalDispatcher2() {;}
00081 
00083         virtual bool dispatch(DispatchContextDeque &dq)
00084         {
00085                 DispatchContextDeque::iterator Q = dq.begin();
00086                 
00087                 S object;
00088                 Atlas::Message::Element::MapType::const_iterator I = Q->asMap().begin();
00089                 
00090                 for (; I != Q->asMap().end(); ++I)
00091                         object.setAttr(I->first, I->second);
00092                 ++Q;
00093                 T parent;
00094                 I = Q->asMap().begin();
00095                 for (; I != Q->asMap().end(); ++I)
00096                         parent.setAttr(I->first, I->second);
00097                 
00098                 Signal.emit(parent, object);
00099                 return LeafDispatcher::dispatch(dq);
00100         }
00101 
00105         SigC::Signal2<void, const T&, const S&> Signal; 
00106 };
00107 
00108 template <class U, class T, class S >
00109 class SignalDispatcher3 :
00110         public LeafDispatcher, 
00111         virtual public SigC::Object
00112 {
00113 public:
00114         SignalDispatcher3(const std::string &nm, 
00115                 const SigC::Slot3<void,const U&, const T&, const S&> &slot) :
00116                 LeafDispatcher(nm)
00117         { Signal.connect(slot); }
00118 
00119         virtual ~SignalDispatcher3() {;}
00120 
00122         virtual bool dispatch(DispatchContextDeque &dq)
00123         {
00124                 DispatchContextDeque::iterator Q = dq.begin();
00125                 
00126                 S object;
00127                 Atlas::Message::Element::MapType::const_iterator I = Q->asMap().begin();
00128                 
00129                 for (; I != Q->asMap().end(); ++I)
00130                         object.setAttr(I->first, I->second);
00131                 ++Q;
00132                 T parent;
00133                 I = Q->asMap().begin();
00134                 for (; I != Q->asMap().end(); ++I)
00135                         parent.setAttr(I->first, I->second);
00136                 
00137                 ++Q;
00138                 U grandparent;
00139                 I = Q->asMap().begin();
00140                 for (; I != Q->asMap().end(); ++I)
00141                         grandparent.setAttr(I->first, I->second);
00142                 
00143                 Signal.emit(grandparent, parent, object);
00144                 return LeafDispatcher::dispatch(dq);
00145         }
00146 
00150         SigC::Signal3<void, const U&, const T&, const S&> Signal;       
00151 };
00152 
00156 class MessageDispatcher :
00157         public Dispatcher,
00158         virtual public SigC::Object
00159 {
00160 public: 
00164         MessageDispatcher(const std::string &nm, const SigC::Slot1<void, const Atlas::Message::Element&> &slot) :
00165                 Dispatcher(nm)
00166         { Signal.connect(slot); }
00167         
00168         virtual ~MessageDispatcher() {;}
00169                 
00170         virtual bool dispatch(DispatchContextDeque &dq)
00171         { 
00172                 Signal.emit(dq.front());
00173                 return false;
00174         }
00175 protected:      
00176         SigC::Signal1<void, const Atlas::Message::Element&> Signal;
00177 };
00178 
00179 
00180 } // of namespace
00181 
00182 #endif

Generated on Fri Nov 12 07:43:30 2004 for Eris by  doxygen 1.3.9.1