Belle II Software  release-08-01-10
NSMVHandler.h
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 #ifndef _Belle2_NSMVHandler_h
9 #define _Belle2_NSMVHandler_h
10 
11 #include <daq/slc/nsm/NSMVar.h>
12 
13 #include <vector>
14 #include <map>
15 
16 namespace Belle2 {
22  class NSMVHandler {
23 
24  friend class Callback;
25  friend class AbstractNSMCallback;
26  friend class NSMCallback;
27 
28  public:
29  static NSMVHandler* create(const NSMVar& var);
30 
31  public:
32  NSMVHandler(const std::string& node, const std::string& name,
33  bool useget, bool useset)
34  : m_id(0), m_timestamp(0), m_node(node), m_name(name),
35  m_useget(useget), m_useset(useset), m_var(name) {}
36  virtual ~NSMVHandler() {}
37 
38  public:
39  virtual bool handleGet(NSMVar& var)
40  {
41  var = m_var;
42  return true;
43  }
44  virtual bool handleSet(const NSMVar& var)
45  {
46  m_var = var;
47  return true;
48  }
49 
50  public:
51  const std::string& getNode() const { return m_node; }
52  const std::string& getName() const { return m_name; }
53  bool useGet() const { return m_useget; }
54  bool useSet() const { return m_useset; }
55  void setUseGet(bool use) { m_useget = use; }
56  void setUseSet(bool use) { m_useset = use; }
57  int getTimeStamp() const { return m_timestamp; }
58  int getId() const { return m_id; }
59  void setNode(const std::string& node) { m_node = node; }
60  void setId(int id) { m_id = id; }
61  void set(const NSMVar& var) { m_var = var; }
62  void set(int val) { m_var = val; }
63  void set(float val) { m_var = val; }
64  void set(const std::string& val) { m_var = val; }
65  void set(const std::vector<int>& val) { m_var = val; }
66  void set(const std::vector<float>& val) { m_var = val; }
67  const NSMVar& get() const { return m_var; }
68  NSMVar& get() { return m_var; }
69  NSMVar::Type getType() const { return m_var.getType(); }
70  const char* getTypeLabel() const { return m_var.getTypeLabel(); }
71  bool isDumped() const { return m_isdump; }
72  void setDumped(bool isdump) { m_isdump = isdump; }
73 
74  protected:
75  int m_id;
76  int m_timestamp;
77  std::string m_node;
78  std::string m_name;
79  bool m_useget;
80  bool m_useset;
81  NSMVar m_var;
82  bool m_isdump;
83 
84  };
85 
86  typedef std::map<std::string, NSMVHandler*> NSMVHandlerList;
87 
88  class NSMVHandlerInt : public NSMVHandler {
89 
90  public:
91  NSMVHandlerInt(const std::string& name,
92  bool useget, bool useset, int val = 0)
93  : NSMVHandler("", name, useget, useset)
94  {
95  m_var = val;
96  }
97  NSMVHandlerInt(const std::string& node, const std::string& name,
98  bool useget, bool useset, int val = 0)
99  : NSMVHandler(node, name, useget, useset)
100  {
101  m_var = val;
102  }
103  virtual ~NSMVHandlerInt() {}
104 
105  public:
106  bool handleGet(NSMVar& var) override;
107  bool handleSet(const NSMVar& var) override;
108 
109  public:
110  virtual bool handleGetInt(int& val)
111  {
112  val = m_var.getInt();
113  return true;
114  }
115  virtual bool handleSetInt(int val)
116  {
117  m_var = val;
118  return true;
119  }
120 
121  };
122 
123  class NSMVHandlerFloat : public NSMVHandler {
124 
125  public:
126  NSMVHandlerFloat(const std::string& name,
127  bool useget, bool useset, float val = 0)
128  : NSMVHandler("", name, useget, useset)
129  {
130  m_var = val;
131  }
132  NSMVHandlerFloat(const std::string& node, const std::string& name,
133  bool useget, bool useset, float val = 0)
134  : NSMVHandler(node, name, useget, useset)
135  {
136  m_var = val;
137  }
138  virtual ~NSMVHandlerFloat() {}
139 
140  private:
141  bool handleGet(NSMVar& var) override;
142  bool handleSet(const NSMVar& var) override;
143 
144  public:
145  virtual bool handleGetFloat(float& val)
146  {
147  val = m_var.getFloat();
148  return true;
149  }
150  virtual bool handleSetFloat(float val)
151  {
152  m_var = val;
153  return true;
154  }
155 
156  };
157 
158  class NSMVHandlerText : public NSMVHandler {
159 
160  public:
161  NSMVHandlerText(const std::string& name,
162  bool useget, bool useset, const std::string& val = "")
163  : NSMVHandler("", name, useget, useset)
164  {
165  m_var = val;
166  }
167  NSMVHandlerText(const std::string& node, const std::string& name,
168  bool useget, bool useset, const std::string& val = "")
169  : NSMVHandler(node, name, useget, useset)
170  {
171  m_var = val;
172  }
173  virtual ~NSMVHandlerText() {}
174 
175  private:
176  bool handleGet(NSMVar& var) override;
177  bool handleSet(const NSMVar& var) override;
178 
179  public:
180  virtual bool handleGetText(std::string& val)
181  {
182  val = m_var.getText();
183  return true;
184  }
185  virtual bool handleSetText(const std::string& val)
186  {
187  m_var = val;
188  return true;
189  }
190 
191  };
192 
193  class NSMVHandlerIntArray : public NSMVHandler {
194 
195  public:
196  NSMVHandlerIntArray(const std::string& name,
197  bool useget, bool useset,
198  const std::vector<int>& val = std::vector<int>())
199  : NSMVHandler("", name, useget, useset)
200  {
201  m_var = val;
202  }
203  NSMVHandlerIntArray(const std::string& node, const std::string& name,
204  bool useget, bool useset,
205  const std::vector<int>& val = std::vector<int>())
206  : NSMVHandler(node, name, useget, useset)
207  {
208  m_var = val;
209  }
210  virtual ~NSMVHandlerIntArray() {}
211 
212  public:
213  bool handleGet(NSMVar& var) override;
214  bool handleSet(const NSMVar& var) override;
215 
216  public:
217  virtual bool handleGetIntArray(std::vector<int>& val);
218  virtual bool handleSetIntArray(const std::vector<int>& val)
219  {
220  m_var = val;
221  return true;
222  }
223 
224  };
225 
226  class NSMVHandlerFloatArray : public NSMVHandler {
227 
228  public:
229  NSMVHandlerFloatArray(const std::string& name,
230  bool useget, bool useset,
231  const std::vector<float>& val = std::vector<float>())
232  : NSMVHandler("", name, useset, useget)
233  {
234  m_var = val;
235  }
236  NSMVHandlerFloatArray(const std::string& node, const std::string& name,
237  bool useget, bool useset,
238  const std::vector<float>& val = std::vector<float>())
239  : NSMVHandler(node, name, useset, useget)
240  {
241  m_var = val;
242  }
243  virtual ~NSMVHandlerFloatArray() {}
244 
245  public:
246  bool handleGet(NSMVar& var) override;
247  bool handleSet(const NSMVar& var) override;
248 
249  public:
250  virtual bool handleGetFloatArray(std::vector<float>& val);
251  virtual bool handleSetFloatArray(const std::vector<float>& val)
252  {
253  m_var = val;
254  return true;
255  }
256 
257  };
258 
259  class NSMCallback;
260 
261  class NSMVHandlerRef : public NSMVHandler {
262 
263  public:
264  NSMVHandlerRef(NSMCallback& callback,
265  const std::string& name,
266  const std::string& refname)
267  : NSMVHandler("", name, true, true),
268  m_callback(callback), m_refname(refname) {}
269  virtual ~NSMVHandlerRef() {}
270 
271  public:
272  bool handleGet(NSMVar& var) override;
273  bool handleSet(const NSMVar& var) override;
274 
275  private:
276  NSMCallback& m_callback;
277  std::string m_refname;
278 
279  };
280 
282 };
283 
284 #endif
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17