Belle II Software light-2406-ragdoll
Interface Class Referenceabstract

Exception to be thrown in case of an empty result. More...

#include <Interface.h>

Inheritance diagram for Interface:
Collaboration diagram for Interface:

Public Member Functions

 Interface ()
 default constructor initializing to toplevel parameter space
 
virtual ~Interface ()
 empty, virtual destructor
 
virtual int getNumberNodes (const std::string &path="") const =0
 Return the number of nodes a given path will expand to.
 
bool exists (const std::string &path="") const
 Check if a given parameter path exists.
 
 operator bool () const
 Convert to bool to simplify checking of existence.
 
std::vector< GearDirgetNodes (const std::string &path="") const
 Get vector of GearDirs which point to all the nodes the given path evaluates to.
 
std::string getPath () const
 Return path of the current interface.
 
virtual std::string getString (const std::string &path="") const noexcept(false)=0
 Get the parameter path as a string.
 
virtual std::pair< std::string, std::string > getStringWithUnit (const std::string &path) const noexcept(false)=0
 Get the parameter path as string and also return the unit it was defined with.
 
std::string getString (const std::string &path, const std::string &defaultValue) const
 Get the parameter path as a string.
 
virtual const TObject * getTObject (const std::string &path) const noexcept(false)=0
 Get the parameter path as a TObject.
 
double getDouble (const std::string &path="") const noexcept(false)
 Get the parameter path as a double.
 
double getDouble (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double.
 
int getInt (const std::string &path="") const noexcept(false)
 Get the parameter path as a int.
 
int getInt (const std::string &path, int defaultValue) const noexcept(false)
 Get the parameter path as a int.
 
bool getBool (const std::string &path="") const noexcept(false)
 Get the parameter path as a bool.
 
bool getBool (const std::string &path, bool defaultValue) const
 Get the parameter path as a bool.
 
double getWithUnit (const std::string &path) const noexcept(false)
 Get the parameter path as a double converted to the standard unit.
 
double getWithUnit (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard unit.
 
std::vector< double > getArray (const std::string &path) const noexcept(false)
 Get the parameter path as a list of double values converted to the standard unit.
 
std::vector< double > getArray (const std::string &path, const std::vector< double > &defaultValue) const noexcept(false)
 Get the parameter path as a list of double values converted to the standard unit.
 
double getLength (const std::string &path="") const noexcept(false)
 Get the parameter path as a double converted to the standard length unit.
 
double getLength (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard length unit.
 
double getAngle (const std::string &path="") const noexcept(false)
 Get the parameter path as a double converted to the standard angle unit.
 
double getAngle (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard angle unit.
 
double getEnergy (const std::string &path="") const noexcept(false)
 Get the parameter path as a double converted to the standard energy unit.
 
double getEnergy (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard energy unit.
 
double getDensity (const std::string &path="") const noexcept(false)
 Get the parameter path as a double converted to the standard density unit.
 
double getDensity (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard density unit.
 
double getTime (const std::string &path="") const noexcept(false)
 Get the parameter path as a double converted to the standard time unit.
 
double getTime (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard time unit.
 
double getFrequency (const std::string &path="") const noexcept(false)
 Get the parameter path as a double converted to the standard frequency unit.
 
double getFrequency (const std::string &path, double defaultValue) const noexcept(false)
 Get the parameter path as a double converted to the standard frequency unit.
 

Protected Member Functions

std::string ensureNode (const std::string &path) const
 make sure the path really corresponds to an XPath node expression by removing trailing slashes
 
std::string ensurePath (const std::string &path) const
 make sure the path really corresponds to a path by appending a trailing slash if neccessary
 
std::string addIndex (const std::string &path, int index) const
 add [index] to the path (after stripping trailing slashes)
 
std::string joinPath (const std::string &path, const std::string &subpath) const
 joind to paths, inserting a slash if neccessary
 

Protected Attributes

std::string m_path
 path of the current interface
 

Detailed Description

Exception to be thrown in case of an empty result.

Exception to be thrown in case of an conversion error getTObject() couldn't deserialize data. common interface for Gearbox and GearDir.

Definition at line 35 of file Interface.h.

Constructor & Destructor Documentation

◆ Interface()

Interface ( )
inline

default constructor initializing to toplevel parameter space

Definition at line 39 of file Interface.h.

39: m_path("/") {}
std::string m_path
path of the current interface
Definition: Interface.h:498

◆ ~Interface()

virtual ~Interface ( )
inlinevirtual

empty, virtual destructor

Definition at line 42 of file Interface.h.

42{}

Member Function Documentation

◆ addIndex()

std::string addIndex ( const std::string &  path,
int  index 
) const
protected

add [index] to the path (after stripping trailing slashes)

Definition at line 166 of file Interface.cc.

167 {
168 static boost::format index_fmt("%1%[%2%]");
169 return (index_fmt % ensureNode(path) % index).str();
170 }
std::string ensureNode(const std::string &path) const
make sure the path really corresponds to an XPath node expression by removing trailing slashes
Definition: Interface.cc:156

◆ ensureNode()

std::string ensureNode ( const std::string &  path) const
protected

make sure the path really corresponds to an XPath node expression by removing trailing slashes

Definition at line 156 of file Interface.cc.

157 {
158 return boost::trim_right_copy_if(path, boost::is_any_of("/"));
159 }

◆ ensurePath()

std::string ensurePath ( const std::string &  path) const
protected

make sure the path really corresponds to a path by appending a trailing slash if neccessary

Definition at line 161 of file Interface.cc.

162 {
163 return ensureNode(path) + '/';
164 }

◆ exists()

bool exists ( const std::string &  path = "") const
inline

Check if a given parameter path exists.

Returns
true if path exists, false otherwise

Definition at line 54 of file Interface.h.

54{ return getNumberNodes(path) > 0; }
virtual int getNumberNodes(const std::string &path="") const =0
Return the number of nodes a given path will expand to.

◆ getAngle() [1/2]

double getAngle ( const std::string &  path,
double  defaultValue 
) const
inline

Get the parameter path as a double converted to the standard angle unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 321 of file Interface.h.

322 {
323 return getWithUnit(path, defaultValue);
324 }
double getWithUnit(const std::string &path) const noexcept(false)
Get the parameter path as a double converted to the standard unit.
Definition: Interface.cc:97

◆ getAngle() [2/2]

double getAngle ( const std::string &  path = "") const
inline

Get the parameter path as a double converted to the standard angle unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 299 of file Interface.h.

300 {
301 return getWithUnit(path);
302 }

◆ getArray() [1/2]

std::vector< double > getArray ( const std::string &  path) const

Get the parameter path as a list of double values converted to the standard unit.

The content of the parameter will be split at whitespace, comma and semi-colon and returned as a vector of numbers

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 123 of file Interface.cc.

124 {
125 using tokenizer = boost::tokenizer<boost::char_separator<char> >;
126 boost::char_separator<char> sep(",; \t\n\r");
127
128 std::pair<std::string, std::string> value = getStringWithUnit(path);
129 tokenizer tokens(value.first, sep);
130 std::vector<double> result;
131 double numValue(0);
132 for (const std::string& tok : tokens) {
133 try {
134 numValue = boost::lexical_cast<double>(tok);
135 } catch (boost::bad_lexical_cast&) {
136 throw (ConversionError() << path << value.first);
137 }
138 if (!value.second.empty()) {
139 numValue = Unit::convertValue(numValue, value.second);
140 }
141 result.push_back(numValue);
142 }
143 return result;
144 }
virtual std::pair< std::string, std::string > getStringWithUnit(const std::string &path) const noexcept(false)=0
Get the parameter path as string and also return the unit it was defined with.
static double convertValue(double value, const std::string &unitString)
Converts a floating point value to the standard framework unit.
Definition: UnitConst.cc:129

◆ getArray() [2/2]

std::vector< double > getArray ( const std::string &  path,
const std::vector< double > &  defaultValue 
) const

Get the parameter path as a list of double values converted to the standard unit.

The content of the parameter will be split at whitespace, comma and semi-colon and returned as a vector of numbers

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 146 of file Interface.cc.

147 {
148 try {
149 return getArray(path);
150 } catch (PathEmptyError&) {
151 return defaultValue;
152 }
153 }
std::vector< double > getArray(const std::string &path) const noexcept(false)
Get the parameter path as a list of double values converted to the standard unit.
Definition: Interface.cc:123

◆ getBool() [1/2]

bool getBool ( const std::string &  path,
bool  defaultValue 
) const

Get the parameter path as a bool.

If the parameter is empty or does not exist, the defaultValue will be returned.

Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 88 of file Interface.cc.

89 {
90 try {
91 return getBool(path);
92 } catch (PathEmptyError&) {
93 return defaultValue;
94 }
95 }
bool getBool(const std::string &path="") const noexcept(false)
Get the parameter path as a bool.
Definition: Interface.cc:80

◆ getBool() [2/2]

bool getBool ( const std::string &  path = "") const

Get the parameter path as a bool.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 80 of file Interface.cc.

81 {
82 std::string value = getString(path);
83 boost::to_lower(value);
84 if (value.empty() || value == "false" || value == "off" || value == "0") return false;
85 return true;
86 }
virtual std::string getString(const std::string &path="") const noexcept(false)=0
Get the parameter path as a string.

◆ getDensity() [1/2]

double getDensity ( const std::string &  path,
double  defaultValue 
) const
inline

Get the parameter path as a double converted to the standard density unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 401 of file Interface.h.

402 {
403 return getWithUnit(path, defaultValue);
404 }

◆ getDensity() [2/2]

double getDensity ( const std::string &  path = "") const
inline

Get the parameter path as a double converted to the standard density unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 379 of file Interface.h.

380 {
381 return getWithUnit(path);
382 }

◆ getDouble() [1/2]

double getDouble ( const std::string &  path,
double  defaultValue 
) const

Get the parameter path as a double.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 51 of file Interface.cc.

52 {
53 try {
54 return getDouble(path);
55 } catch (PathEmptyError&) {
56 return defaultValue;
57 }
58 }
double getDouble(const std::string &path="") const noexcept(false)
Get the parameter path as a double.
Definition: Interface.cc:41

◆ getDouble() [2/2]

double getDouble ( const std::string &  path = "") const

Get the parameter path as a double.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 41 of file Interface.cc.

42 {
43 std::string value = getString(path);
44 try {
45 return boost::lexical_cast<double>(value);
46 } catch (boost::bad_lexical_cast&) {
47 throw ConversionError() << path << value;
48 }
49 }

◆ getEnergy() [1/2]

double getEnergy ( const std::string &  path,
double  defaultValue 
) const
inline

Get the parameter path as a double converted to the standard energy unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 361 of file Interface.h.

362 {
363 return getWithUnit(path, defaultValue);
364 }

◆ getEnergy() [2/2]

double getEnergy ( const std::string &  path = "") const
inline

Get the parameter path as a double converted to the standard energy unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 339 of file Interface.h.

340 {
341 return getWithUnit(path);
342 }

◆ getFrequency() [1/2]

double getFrequency ( const std::string &  path,
double  defaultValue 
) const
inline

Get the parameter path as a double converted to the standard frequency unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 481 of file Interface.h.

482 {
483 return getWithUnit(path, defaultValue);
484 }

◆ getFrequency() [2/2]

double getFrequency ( const std::string &  path = "") const
inline

Get the parameter path as a double converted to the standard frequency unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 459 of file Interface.h.

460 {
461 return getWithUnit(path);
462 }

◆ getInt() [1/2]

int getInt ( const std::string &  path,
int  defaultValue 
) const

Get the parameter path as a int.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 71 of file Interface.cc.

72 {
73 try {
74 return getInt(path);
75 } catch (PathEmptyError&) {
76 return defaultValue;
77 }
78 }
int getInt(const std::string &path="") const noexcept(false)
Get the parameter path as a int.
Definition: Interface.cc:60

◆ getInt() [2/2]

int getInt ( const std::string &  path = "") const

Get the parameter path as a int.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 60 of file Interface.cc.

61 {
62 std::string value = getString(path);
63 try {
64 //hide spurious warning in boost
65 return boost::lexical_cast<int>(value);
66 } catch (boost::bad_lexical_cast&) {
67 throw ConversionError() << path << value;
68 }
69 }

◆ getLength() [1/2]

double getLength ( const std::string &  path,
double  defaultValue 
) const
inline

Get the parameter path as a double converted to the standard length unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 281 of file Interface.h.

282 {
283 return getWithUnit(path, defaultValue);
284 }

◆ getLength() [2/2]

double getLength ( const std::string &  path = "") const
inline

Get the parameter path as a double converted to the standard length unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 259 of file Interface.h.

260 {
261 return getWithUnit(path);
262 }

◆ getNodes()

std::vector< GearDir > getNodes ( const std::string &  path = "") const

Get vector of GearDirs which point to all the nodes the given path evaluates to.

Parameters
pathPath of the parameters to get

Definition at line 21 of file Interface.cc.

22 {
23 int size = getNumberNodes(path);
24 std::vector<GearDir> result;
25 result.reserve(size);
26 for (int i = 1; i <= size; ++i) {
27 result.emplace_back(*this, path, i);
28 }
29 return result;
30 }

◆ getNumberNodes()

virtual int getNumberNodes ( const std::string &  path = "") const
pure virtual

Return the number of nodes a given path will expand to.

Returns
number of nodes, 0 if path does not exist

Implemented in Gearbox, and GearDir.

◆ getPath()

std::string getPath ( ) const
inline

Return path of the current interface.

Definition at line 70 of file Interface.h.

70{ return m_path; }

◆ getString() [1/2]

std::string getString ( const std::string &  path,
const std::string &  defaultValue 
) const

Get the parameter path as a string.

if the parameter is empty or does not exist, the defaultvalue will be returned.

Parameters
pathpath of the parameter to get
defaultValuevalue to return if the path es empty or does not exist
Returns
value of the parameter

Definition at line 32 of file Interface.cc.

33 {
34 try {
35 return getString(path);
36 } catch (PathEmptyError&) {
37 return defaultValue;
38 }
39 }

◆ getString() [2/2]

virtual std::string getString ( const std::string &  path = "") const
pure virtual

Get the parameter path as a string.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Implemented in Gearbox, and GearDir.

◆ getStringWithUnit()

virtual std::pair< std::string, std::string > getStringWithUnit ( const std::string &  path) const
pure virtual

Get the parameter path as string and also return the unit it was defined with.

If no unit was defined, an empty string will be returned for the unit. No parsing of the unit is performed, this funtion is primarily used by getWithUnit.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Implemented in Gearbox, and GearDir.

◆ getTime() [1/2]

double getTime ( const std::string &  path,
double  defaultValue 
) const
inline

Get the parameter path as a double converted to the standard time unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 441 of file Interface.h.

442 {
443 return getWithUnit(path, defaultValue);
444 }

◆ getTime() [2/2]

double getTime ( const std::string &  path = "") const
inline

Get the parameter path as a double converted to the standard time unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 419 of file Interface.h.

420 {
421 return getWithUnit(path);
422 }

◆ getTObject()

virtual const TObject * getTObject ( const std::string &  path) const
pure virtual

Get the parameter path as a TObject.

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::TObjectConversionErrorif the value could not be deserialized
Parameters
pathPath of the parameter to get
Returns
pointer to object, owned and managed by gearbox. Object will be deleted once it is no longer valid (e.g. after the current run if it belongs to this run)

Implemented in Gearbox, and GearDir.

◆ getWithUnit() [1/2]

double getWithUnit ( const std::string &  path) const

Get the parameter path as a double converted to the standard unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted

Exceptions
gearbox::PathEmptyErrorif path is empty or does not exist
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
Returns
value of the parameter

Definition at line 97 of file Interface.cc.

98 {
99 std::pair<std::string, std::string> value = getStringWithUnit(path);
100 double numValue(0);
101 try {
102 numValue = boost::lexical_cast<double>(value.first);
103 } catch (boost::bad_lexical_cast&) {
104 throw ConversionError() << path << value.first;
105 }
106 if (value.second.empty()) {
107 B2WARNING("Requested unit conversion for parameter '" << path << "' but no unit found");
108 } else {
109 numValue = Unit::convertValue(numValue, value.second);
110 }
111 return numValue;
112 }

◆ getWithUnit() [2/2]

double getWithUnit ( const std::string &  path,
double  defaultValue 
) const

Get the parameter path as a double converted to the standard unit.

Gearbox will try to determine the unit with which the parameter was saved and convert it to the default system. If no unit can be determinded, it will be assumed that the parameter does not need to be converted.

If the parameter is empty or does not exist, the defaultValue will be returned.

Exceptions
gearbox::ConversionErrorif the value could not converted to a numerical type
Parameters
pathPath of the parameter to get
defaultValueValue to return if the Path es empty or does not exist
Returns
value of the parameter

Definition at line 114 of file Interface.cc.

115 {
116 try {
117 return getWithUnit(path);
118 } catch (PathEmptyError&) {
119 return defaultValue;
120 }
121 }

◆ joinPath()

std::string joinPath ( const std::string &  path,
const std::string &  subpath 
) const
protected

joind to paths, inserting a slash if neccessary

Definition at line 172 of file Interface.cc.

173 {
174 return ensurePath(path) + boost::trim_left_copy_if(subpath, boost::is_any_of("/"));
175 }
std::string ensurePath(const std::string &path) const
make sure the path really corresponds to a path by appending a trailing slash if neccessary
Definition: Interface.cc:161

◆ operator bool()

operator bool ( ) const
inline

Convert to bool to simplify checking of existence.

Returns
true if path exists, false otherwise

Definition at line 60 of file Interface.h.

60{ return exists(); }
bool exists(const std::string &path="") const
Check if a given parameter path exists.
Definition: Interface.h:54

Member Data Documentation

◆ m_path

std::string m_path
protected

path of the current interface

Definition at line 498 of file Interface.h.


The documentation for this class was generated from the following files: