GearDir Class Reference

GearDir is the basic class used for accessing the parameter store. More...

#include <GearDir.h>

Inheritance diagram for GearDir:

Collaboration diagram for GearDir:

Public Member Functions
	GearDir (const gearbox::Interface &start, const std::string &path, int index=0)
	Create a GearDir starting at a given base path and appending some subpath and optionally an index.
	GearDir (const std::string &path="", int index=0)
	Create a GearDir with an absolute path and optionally appending an index.
	GearDir (const GearDir &other)
	Copy constructor.
void	append (const std::string &path)
	Append something to the current path, modifying the GearDir in place.
virtual int	getNumberNodes (const std::string &path="") const override
	Return the number of nodes a given path will expand to.
virtual std::string	getString (const std::string &path="") const noexcept(false) override
	Get the parameter path as a string.
std::string	getString (const std::string &path, const std::string &defaultValue) const
	Get the parameter path as a string.
virtual std::pair< std::string, std::string >	getStringWithUnit (const std::string &path="") const noexcept(false) override
	Get the parameter path as string and also return the unit it was defined with.
virtual const TObject *	getTObject (const std::string &path) const noexcept(false) override
	Get the parameter path as a TObject.
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< GearDir >	getNodes (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.
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

GearDir is the basic class used for accessing the parameter store.

To access parameters, just create a GearDir with the correct path and use the getter functions defined by gearbox::Interface to retrieve any parameter in the given path

GearDir parameters("/test/"); int foo = parameters.getInt("bar");

will return an integer value of the parameter /test/bar

Definition at line 31 of file GearDir.h.

Constructor & Destructor Documentation

GearDir() [1/3]

GearDir ( const gearbox::Interface &  start, const std::string &  path, int  index = 0  )

inline

Create a GearDir starting at a given base path and appending some subpath and optionally an index.

Definition at line 34 of file GearDir.h.

    {
      m_path = ensurePath(start.getPath()) + path;
      if (index > 0) m_path = addIndex(m_path, index);
    }

GearDir() [2/3]

GearDir ( const std::string &  path = "", int  index = 0  )

inline

Create a GearDir with an absolute path and optionally appending an index.

Definition at line 40 of file GearDir.h.

    {
      m_path = path;
      if (index > 0) m_path = addIndex(path, index);
    }

GearDir() [3/3]

GearDir ( const GearDir &  other )

inline

Copy constructor.

Definition at line 46 of file GearDir.h.

                                 : gearbox::Interface(other)
    {
      m_path = other.m_path;
    }

Member Function Documentation

addIndex()

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

protectedinherited

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

Definition at line 166 of file Interface.cc.

  {
    static boost::format index_fmt("%1%[%2%]");
    return (index_fmt % ensureNode(path) % index).str();
  }

append()

void append ( const std::string &  path )

inline

Append something to the current path, modifying the GearDir in place.

Definition at line 52 of file GearDir.h.

{ m_path += path; }

ensureNode()

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

protectedinherited

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

Definition at line 156 of file Interface.cc.

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

ensurePath()

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

protectedinherited

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

Definition at line 161 of file Interface.cc.

  {
    return ensureNode(path) + '/';
  }

exists()

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

inlineinherited

Check if a given parameter path exists.

Returns

true if path exists, false otherwise

Definition at line 54 of file Interface.h.

{ return getNumberNodes(path) > 0; }

getAngle() [1/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 321 of file Interface.h.

      {
        return getWithUnit(path, defaultValue);
      }

getAngle() [2/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 299 of file Interface.h.

      {
        return getWithUnit(path);
      }

getArray() [1/2]

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

inherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 123 of file Interface.cc.

  {
    using tokenizer = boost::tokenizer<boost::char_separator<char> >;
    boost::char_separator<char> sep(",; \t\n\r");
 
    std::pair<std::string, std::string> value = getStringWithUnit(path);
    tokenizer tokens(value.first, sep);
    std::vector<double> result;
    double numValue(0);
    for (const std::string& tok : tokens) {
      try {
        numValue = boost::lexical_cast<double>(tok);
      } catch (boost::bad_lexical_cast&) {
        throw (ConversionError() << path << value.first);
      }
      if (!value.second.empty()) {
        numValue = Unit::convertValue(numValue, value.second);
      }
      result.push_back(numValue);
    }
    return result;
  }

getArray() [2/2]

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

inherited

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::ConversionError

if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 146 of file Interface.cc.

  {
    try {
      return getArray(path);
    } catch (PathEmptyError&) {
      return defaultValue;
    }
  }

getBool() [1/2]

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

inherited

Get the parameter path as a bool.

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

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 88 of file Interface.cc.

  {
    try {
      return getBool(path);
    } catch (PathEmptyError&) {
      return defaultValue;
    }
  }

getBool() [2/2]

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

inherited

Get the parameter path as a bool.

Exceptions

gearbox::PathEmptyError

if path is empty or does not exist

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 80 of file Interface.cc.

  {
    std::string value = getString(path);
    boost::to_lower(value);
    if (value.empty() || value == "false" || value == "off" || value == "0") return false;
    return true;
  }

getDensity() [1/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 401 of file Interface.h.

      {
        return getWithUnit(path, defaultValue);
      }

getDensity() [2/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 379 of file Interface.h.

      {
        return getWithUnit(path);
      }

getDouble() [1/2]

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

inherited

Get the parameter path as a double.

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

Exceptions

gearbox::ConversionError

if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 51 of file Interface.cc.

  {
    try {
      return getDouble(path);
    } catch (PathEmptyError&) {
      return defaultValue;
    }
  }

getDouble() [2/2]

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

inherited

Get the parameter path as a double.

Exceptions

gearbox::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 41 of file Interface.cc.

  {
    std::string value = getString(path);
    try {
      return boost::lexical_cast<double>(value);
    } catch (boost::bad_lexical_cast&) {
      throw ConversionError() << path << value;
    }
  }

getEnergy() [1/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 361 of file Interface.h.

      {
        return getWithUnit(path, defaultValue);
      }

getEnergy() [2/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 339 of file Interface.h.

      {
        return getWithUnit(path);
      }

getFrequency() [1/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 481 of file Interface.h.

      {
        return getWithUnit(path, defaultValue);
      }

getFrequency() [2/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 459 of file Interface.h.

      {
        return getWithUnit(path);
      }

getInt() [1/2]

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

inherited

Get the parameter path as a int.

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

Exceptions

gearbox::ConversionError

if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 71 of file Interface.cc.

  {
    try {
      return getInt(path);
    } catch (PathEmptyError&) {
      return defaultValue;
    }
  }

getInt() [2/2]

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

inherited

Get the parameter path as a int.

Exceptions

gearbox::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 60 of file Interface.cc.

  {
    std::string value = getString(path);
    try {
      //hide spurious warning in boost
      return boost::lexical_cast<int>(value);
    } catch (boost::bad_lexical_cast&) {
      throw ConversionError() << path << value;
    }
  }

getLength() [1/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 281 of file Interface.h.

      {
        return getWithUnit(path, defaultValue);
      }

getLength() [2/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 259 of file Interface.h.

      {
        return getWithUnit(path);
      }

getNodes()

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

inherited

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

Parameters

path	Path of the parameters to get

Definition at line 21 of file Interface.cc.

  {
    int size = getNumberNodes(path);
    std::vector<GearDir> result;
    result.reserve(size);
    for (int i = 1; i <= size; ++i) {
      result.emplace_back(*this, path, i);
    }
    return result;
  }

getNumberNodes()

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

inlineoverridevirtual

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

Returns

number of nodes, 0 if path does not exist

Implements Interface.

Definition at line 58 of file GearDir.h.

    {
      return Gearbox::getInstance().getNumberNodes(ensurePath(m_path) + path);
    }

getPath()

std::string getPath ( ) const

inlineinherited

Return path of the current interface.

Definition at line 70 of file Interface.h.

{ return m_path; }

getString() [1/2]

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

inline

Get the parameter path as a string.

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

Parameters

path	path of the parameter to get
defaultValue	value to return if the path es empty or does not exist

Returns

value of the parameter

Definition at line 82 of file GearDir.h.

    {
      return gearbox::Interface::getString(path, defaultValue);
    }

getString() [2/2]

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

inlineoverridevirtual

Get the parameter path as a string.

Exceptions

gearbox::PathEmptyError

if path is empty or does not exist

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Implements Interface.

Definition at line 69 of file GearDir.h.

    {
      return Gearbox::getInstance().getString(ensurePath(m_path) + path);
    }

getStringWithUnit()

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

inlineoverridevirtual

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::PathEmptyError

if path is empty or does not exist

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Implements Interface.

Definition at line 98 of file GearDir.h.

    {
      return Gearbox::getInstance().getStringWithUnit(ensurePath(m_path) + path);
    }

getTime() [1/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 441 of file Interface.h.

      {
        return getWithUnit(path, defaultValue);
      }

getTime() [2/2]

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

inlineinherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 419 of file Interface.h.

      {
        return getWithUnit(path);
      }

getTObject()

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

inlineoverridevirtual

Get the parameter path as a TObject.

Exceptions

gearbox::PathEmptyError	if path is empty or does not exist
gearbox::TObjectConversionError	if the value could not be deserialized

Parameters

path	Path 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)

Implements Interface.

Definition at line 112 of file GearDir.h.

    {
      return Gearbox::getInstance().getTObject(ensurePath(m_path) + path);
    }

getWithUnit() [1/2]

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

inherited

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::PathEmptyError	if path is empty or does not exist
gearbox::ConversionError	if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get

Returns

value of the parameter

Definition at line 97 of file Interface.cc.

  {
    std::pair<std::string, std::string> value = getStringWithUnit(path);
    double numValue(0);
    try {
      numValue = boost::lexical_cast<double>(value.first);
    } catch (boost::bad_lexical_cast&) {
      throw ConversionError() << path << value.first;
    }
    if (value.second.empty()) {
      B2WARNING("Requested unit conversion for parameter '" << path << "' but no unit found");
    } else {
      numValue = Unit::convertValue(numValue, value.second);
    }
    return numValue;
  }

getWithUnit() [2/2]

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

inherited

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::ConversionError

if the value could not converted to a numerical type

Parameters

path	Path of the parameter to get
defaultValue	Value to return if the Path es empty or does not exist

Returns

value of the parameter

Definition at line 114 of file Interface.cc.

  {
    try {
      return getWithUnit(path);
    } catch (PathEmptyError&) {
      return defaultValue;
    }
  }

joinPath()

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

protectedinherited

joind to paths, inserting a slash if neccessary

Definition at line 172 of file Interface.cc.

  {
    return ensurePath(path) + boost::trim_left_copy_if(subpath, boost::is_any_of("/"));
  }

operator bool()

operator bool ( ) const

inlineinherited

Convert to bool to simplify checking of existence.

Returns

true if path exists, false otherwise

Definition at line 60 of file Interface.h.

{ return exists(); }

Member Data Documentation

m_path

std::string m_path

protectedinherited

path of the current interface

Definition at line 498 of file Interface.h.

---

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

• framework/gearbox/include/GearDir.h