Belle II Software  release-08-01-10
AbstractDBObject.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_AbstractDBObject_hh
9 #define _Belle2_AbstractDBObject_hh
10 
11 #include <daq/slc/base/FieldProperty.h>
12 
13 #include <daq/slc/base/Serializable.h>
14 
15 #include <string>
16 #include <stdexcept>
17 
18 namespace Belle2 {
25  class AbstractDBObject : public Serializable {
26 
27  public:
28  AbstractDBObject();
29  AbstractDBObject(const AbstractDBObject& obj);
30  virtual ~AbstractDBObject();
31 
35  const AbstractDBObject& operator=(const AbstractDBObject& object);
36 
37  public:
38  const std::string& getPath() const { return m_path; }
39  void setPath(const std::string& path) { m_path = path; }
40  int getId() const { return m_id; }
41  void setId(int id) { m_id = id; }
42  const std::string& getName() const { return m_name; }
43  void setName(const std::string& name) { m_name = name; }
44  int getIndex() const { return m_index; }
45  void setIndex(int index) { m_index = index; }
46  DBField::NameList& getFieldNames() { return m_name_v; }
47  const DBField::NameList& getFieldNames() const { return m_name_v; }
48  DBField::Property getProperty(const std::string& name) const;
49  bool hasField(const std::string& name) const;
50  bool hasValue(const std::string& name) const;
51  bool hasText(const std::string& name) const;
52  bool hasObject(const std::string& name) const;
53  void add(const std::string& name, DBField::Property pro);
54  void setValue(const std::string& name, const std::string& value);
55  void setText(const std::string& name, const std::string& value) { addText(name, value); }
56 
57  public:
58  bool getBool(const std::string& name, int index = 0) const;
59  char getChar(const std::string& name, int index = 0) const;
60  short getShort(const std::string& name, int index = 0) const;
61  int getInt(const std::string& name, int index = 0) const;
62  long long getLong(const std::string& name, int index = 0) const;
63  float getFloat(const std::string& name, int index = 0) const;
64  double getDouble(const std::string& name, int index = 0) const;
65  void addBool(const std::string& name, bool value);
66  void addChar(const std::string& name, char value);
67  void addShort(const std::string& name, short value);
68  void addInt(const std::string& name, int value);
69  void addLong(const std::string& name, long long value);
70  void addFloat(const std::string& name, float value);
71  void addDouble(const std::string& name, double value);
72  void setBool(const std::string& name, bool value, int index = 0);
73  void setChar(const std::string& name, int value, int index = 0);
74  void setShort(const std::string& name, int value, int index = 0);
75  void setInt(const std::string& name, int value, int index = 0);
76  void setLong(const std::string& name, long long value, int index = 0);
77  void setFloat(const std::string& name, float value, int index = 0);
78  void setDouble(const std::string& name, double value, int index = 0);
79  const std::string getValueText(const std::string& name) const;
80 
81  public:
82  virtual const void* getValue(const std::string& name) const = 0;
83  virtual const std::string& getText(const std::string& name) const = 0;
84  virtual void addText(const std::string& name, const std::string& value) = 0;
85  virtual void addValue(const std::string& name, const void* value,
86  DBField::Type type, int length) = 0;
87  virtual void setValue(const std::string& name, const void* value, int index) = 0;
88  virtual void setValueText(const std::string& name, const std::string& value);
89 
90  protected:
91  virtual void reset();
92 
93  private:
94  int m_index;
95  std::string m_path;
96  int m_id;
97  std::string m_name;
98  DBField::NameList m_name_v;
99  DBField::PropertyList m_pro_m;
100 
101  private:
102  template<typename T>
103  T getD(const std::string& name, int index = 0) const
104  {
105  const void* value = getValue(name);
106  if (value == NULL/* || index >= getProperty(name).getLength()*/) {
107  throw (std::out_of_range(name + " not found"));
108  }
109  DBField::Type type(getProperty(name).getType());
110  if (type == DBField::INT) return (T)(((int*)value)[index]);
111  if (type == DBField::FLOAT) return (T)(((float*)value)[index]);
112  if (type == DBField::DOUBLE) return (T)(((double*)value)[index]);
113  if (type == DBField::SHORT) return (T)(((short*)value)[index]);
114  if (type == DBField::CHAR) return (T)(((char*)value)[index]);
115  if (type == DBField::LONG) return (T)(((long*)value)[index]);
116  return ((T*)value)[index];
117  }
118 
119  };
120 
121  inline bool AbstractDBObject::getBool(const std::string& name, int index) const
122  {
123  return getD<bool>(name, index);
124  }
125 
126  inline char AbstractDBObject::getChar(const std::string& name, int index) const
127  {
128  return getD<char>(name, index);
129  }
130 
131  inline short AbstractDBObject::getShort(const std::string& name, int index) const
132  {
133  return getD<short>(name, index);
134  }
135 
136  inline int AbstractDBObject::getInt(const std::string& name, int index) const
137  {
138  return getD<int>(name, index);
139  }
140 
141  inline long long AbstractDBObject::getLong(const std::string& name, int index) const
142  {
143  return getD<long long>(name, index);
144  }
145 
146  inline float AbstractDBObject::getFloat(const std::string& name, int index) const
147  {
148  return getD<float>(name, index);
149  }
150 
151  inline double AbstractDBObject::getDouble(const std::string& name, int index) const
152  {
153  return getD<double>(name, index);
154  }
155 
156  inline void AbstractDBObject::setBool(const std::string& name, bool value, int index)
157  {
158  setValue(name, &value, index);
159  }
160 
161  inline void AbstractDBObject::setChar(const std::string& name, int value, int index)
162  {
163  setValue(name, &value, index);
164  }
165 
166  inline void AbstractDBObject::setShort(const std::string& name, int value, int index)
167  {
168  setValue(name, &value, index);
169  }
170 
171  inline void AbstractDBObject::setInt(const std::string& name, int value, int index)
172  {
173  setValue(name, &value, index);
174  }
175 
176  inline void AbstractDBObject::setLong(const std::string& name, long long value, int index)
177  {
178  setValue(name, &value, index);
179  }
180 
181  inline void AbstractDBObject::setFloat(const std::string& name, float value, int index)
182  {
183  setValue(name, &value, index);
184  }
185 
186  inline void AbstractDBObject::setDouble(const std::string& name, double value, int index)
187  {
188  setValue(name, &value, index);
189  }
190 
191  inline void AbstractDBObject::addBool(const std::string& name, bool value)
192  {
193  addValue(name, &value, DBField::BOOL, 0);
194  }
195 
196  inline void AbstractDBObject::addChar(const std::string& name, char value)
197  {
198  addValue(name, &value, DBField::CHAR, 0);
199  }
200 
201  inline void AbstractDBObject::addShort(const std::string& name, short value)
202  {
203  addValue(name, &value, DBField::SHORT, 0);
204  }
205 
206  inline void AbstractDBObject::addInt(const std::string& name, int value)
207  {
208  addValue(name, &value, DBField::INT, 0);
209  }
210 
211  inline void AbstractDBObject::addLong(const std::string& name, long long value)
212  {
213  addValue(name, &value, DBField::LONG, 0);
214  }
215 
216  inline void AbstractDBObject::addFloat(const std::string& name, float value)
217  {
218  addValue(name, &value, DBField::FLOAT, 0);
219  }
220 
221  inline void AbstractDBObject::addDouble(const std::string& name, double value)
222  {
223  addValue(name, &value, DBField::DOUBLE, 0);
224  }
225 
227 }
228 
229 #endif
Belle2::AbstractDBObject::operator=
const AbstractDBObject & operator=(const AbstractDBObject &object)
Operator =.
Definition: AbstractDBObject.cc:32
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17