Nymph  v1.5.2
Flow-Based Data Processing Framework
KTProcessor.hh
Go to the documentation of this file.
1 
9 #ifndef KTPROCESSOR_HH_
10 #define KTPROCESSOR_HH_
11 
12 #include "KTConfigurable.hh"
13 
14 #include "KTConnection.hh"
15 #include "KTLogger.hh"
16 #include "KTSignalWrapper.hh"
17 #include "KTSlotWrapper.hh"
18 
19 #include "factory.hh"
20 
21 #include <boost/bind.hpp>
22 #include <boost/function.hpp>
23 #include <boost/signals2.hpp>
24 
25 #include <exception>
26 #include <map>
27 #include <sstream>
28 #include <string>
29 
30 namespace Nymph
31 {
32  KTLOGGER(processorlog, "KTProcessor.hh");
33 
34  class ProcessorException : public std::logic_error
35  {
36  public:
37  ProcessorException(std::string const& why);
38  };
39 
40  class KTProcessor : public KTConfigurable
41  {
42  protected:
43  typedef std::map< std::string, KTSignalWrapper* > SignalMap;
44  typedef SignalMap::iterator SigMapIt;
45  typedef SignalMap::value_type SigMapVal;
46 
47  typedef std::map< std::string, KTSlotWrapper* > SlotMap;
48  typedef SlotMap::iterator SlotMapIt;
49  typedef SlotMap::value_type SlotMapVal;
50 
51  public:
52  KTProcessor(const std::string& name="default-proc-name");
53  virtual ~KTProcessor();
54 
55  public:
56 
57  void ConnectASlot(const std::string& signalName, KTProcessor* processor, const std::string& slotName, int groupNum=-1);
58  void ConnectASignal(KTProcessor* processor, const std::string& signalName, const std::string& slotName, int groupNum=-1);
59  void ConnectSignalToSlot(KTSignalWrapper* signal, KTSlotWrapper* slot, int groupNum=-1);
60 
61  template< class XProcessor >
62  void RegisterSignal(std::string name, XProcessor* signalPtr);
63 
64  template< class XTarget, typename XReturn >
65  void RegisterSlot(std::string name, XTarget* target, XReturn (XTarget::* funcPtr)());
66 
67  template< class XTarget, typename XReturn, typename XArg1 >
68  void RegisterSlot(std::string name, XTarget* target, XReturn (XTarget::* funcPtr)(XArg1));
69 
70  template< class XTarget, typename XReturn, typename XArg1, typename XArg2 >
71  void RegisterSlot(std::string name, XTarget* target, XReturn (XTarget::* funcPtr)(XArg1, XArg2));
72 
73  KTSignalWrapper* GetSignal(const std::string& name);
74 
75  KTSlotWrapper* GetSlot(const std::string& name);
76 
77  protected:
78 
79  SignalMap fSignalMap;
80 
81  SlotMap fSlotMap;
82 
83  };
84 
85 
86  template< typename XSignalSig >
87  void KTProcessor::RegisterSignal(std::string name, XSignalSig* signalPtr)
88  {
89  KTDEBUG(processorlog, "Registering signal <" << name << "> in processor <" << fConfigName << ">");
90  KTSignalWrapper* sig = new KTSignalWrapper(signalPtr);
91  fSignalMap.insert(SigMapVal(name, sig));
92  return;
93  }
94 
95  template< class XTarget, typename XReturn >
96  void KTProcessor::RegisterSlot(std::string name, XTarget* target, XReturn (XTarget::* funcPtr)())
97  {
98  KTDEBUG(processorlog, "Registering slot <" << name << "> in processor <" << fConfigName << ">");
99 
100  KTSignalConcept< XReturn () > signalConcept;
101 
102  boost::function< XReturn () > *func = new boost::function< XReturn () >(boost::bind(funcPtr, target));
103 
104  KTSlotWrapper* slot = new KTSlotWrapper(func, &signalConcept);
105  fSlotMap.insert(SlotMapVal(name, slot));
106  return;
107  }
108 
109  template< class XTarget, typename XReturn, typename XArg1 >
110  void KTProcessor::RegisterSlot(std::string name, XTarget* target, XReturn (XTarget::* funcPtr)(XArg1))
111  {
112  KTDEBUG(processorlog, "Registering slot <" << name << "> in processor <" << fConfigName << ">");
113 
115 
116  boost::function< XReturn (XArg1) > *func = new boost::function< XReturn (XArg1) >(boost::bind(funcPtr, target, _1));
117 
118  KTSlotWrapper* slot = new KTSlotWrapper(func, &signalConcept);
119  fSlotMap.insert(SlotMapVal(name, slot));
120  return;
121  }
122 
123  template< class XTarget, typename XReturn, typename XArg1, typename XArg2 >
124  void KTProcessor::RegisterSlot(std::string name, XTarget* target, XReturn (XTarget::* funcPtr)(XArg1, XArg2))
125  {
126  KTDEBUG(processorlog, "Registering slot <" << name << "> in processor <" << fConfigName << ">");
127 
129 
130  boost::function< XReturn (XArg1, XArg2) > *func = new boost::function< XReturn (XArg1, XArg2) >(boost::bind(funcPtr, target, _1, _2));
131 
132  KTSlotWrapper* slot = new KTSlotWrapper(func, &signalConcept);
133  fSlotMap.insert(SlotMapVal(name, slot));
134  return;
135  }
136 
137 
138 #define KT_REGISTER_PROCESSOR(proc_class, proc_name) \
139  static ::scarab::registrar< ::Nymph::KTProcessor, proc_class, const std::string& > sProc##proc_class##Registrar( proc_name );
140 
141 } /* namespace Nymph */
142 #endif /* KTPROCESSOR_HH_ */
SlotMap::value_type SlotMapVal
Definition: KTProcessor.hh:49
SignalMap fSignalMap
Definition: KTProcessor.hh:79
void RegisterSlot(std::string name, XTarget *target, XReturn(XTarget::*funcPtr)())
Definition: KTProcessor.hh:96
SignalMap::iterator SigMapIt
Definition: KTProcessor.hh:44
std::map< std::string, KTSignalWrapper *> SignalMap
Definition: KTProcessor.hh:43
#define KTDEBUG(...)
Definition: KTLogger.hh:343
KTLOGGER(applog, "KTApplication")
ProcessorException(std::string const &why)
Definition: KTProcessor.cc:22
SignalMap::value_type SigMapVal
Definition: KTProcessor.hh:45
void RegisterSignal(std::string name, XProcessor *signalPtr)
SlotMap::iterator SlotMapIt
Definition: KTProcessor.hh:48
std::map< std::string, KTSlotWrapper *> SlotMap
Definition: KTProcessor.hh:47
Contains the logger class and macros, based on Kasper&#39;s KLogger class.