Jpp
Classes | Enumerations | Functions | Variables
JEEP Namespace Reference

General puprpose classes and methods. More...

Classes

class  JArgs
 Data structure to store command line arguments. More...
 
struct  JComment
 Auxiliary class for comment. More...
 
class  JCommunicator
 Auxiliary class to control standard input and output. More...
 
struct  JFunctionAdaptor
 Function adaptor. More...
 
struct  JFunctionAdaptor< JReturn_t, JFirst_t, void >
 Function adaptor for function with one argument. More...
 
struct  JFunctionAdaptorHelper
 Auxiliary base class for function adaptor. More...
 
struct  JMessage
 Auxiliary class for handling debug parameter within a class. More...
 
class  JProperties
 Utility class to parse parameter values. More...
 
class  JPropertiesElement
 The property value class. More...
 
class  JPropertiesElementInterface
 Interface for I/O of properties element. More...
 
class  JPropertiesTemplateElement
 Template class for I/O of properties element. More...
 
class  JPropertiesTemplateElement< const T >
 Template specialisation of JPropertiesTemplateElement for const data type. More...
 
class  JPropertiesTemplateElement< JProperties >
 Template specialisation for JProperties. More...
 
class  JPropertiesTemplateElement< JProperties::JFileReader >
 Template specialisation for JFileReader. More...
 
class  JStatus
 Auxiliary class for status identifier. More...
 
class  JTimekeeper
 Time keeper. More...
 
class  JTimer
 Auxiliary class for CPU timing and usage. More...
 
class  JVersion
 Auxiliary class for version identifier. More...
 

Enumerations

enum  JMessage_t {
  debug_t = 3, status_t = 2, warning_t = 2, notice_t = 1,
  error_t = 0, fatal_t = 0
}
 Debug level. More...
 
enum  JPrintOption_t { SHORT_PRINT = 1, MEDIUM_PRINT = 2, LONG_PRINT = 3 }
 Print options. More...
 
enum  JScale_t {
  femto_t = -15, pico_t = -12, nano_t = -9, micro_t = -6,
  milli_t = -3, unit_t = 0, kilo_t = +3, mega_t = +6,
  giga_t = +9, tera_t = +12, peta_t = +15, exa_t = +18
}
 Enumeration for scaling of quantity. More...
 

Functions

template<class T >
bool compareObjects (const T &first, const T &second, JBool< true >)
 Comparison of comparable objects. More...
 
template<class T >
bool compareObjects (const T &first, const T &second, JBool< false >)
 Comparison of uncomparable objects. More...
 
template<class T >
bool compareObjects (const T &first, const T &second)
 Comparison of objects. More...
 
std::string strip (const std::string &file_name)
 Strip leading and trailing white spaces from file name. More...
 
std::string getFilenameExtension (const std::string &file_name)
 Get file name extension, i.e. More...
 
std::string getFilename (const std::string &file_name)
 Get file name part, i.e. More...
 
std::string getPath (const std::string &file_name)
 Get path, i.e. More...
 
std::string getFullPath (const std::string &path)
 Get full path, i.e. More...
 
std::string getFilename (const std::string &path, const std::string &file_name)
 Compose full file name and introduce JEEP::PATHNAME_SEPARATOR if needed. More...
 
std::string getPath (const std::string &variable, const std::string &file_name)
 Get selected path from environment variable for given file name. More...
 
std::string getFullFilename (const std::string &variable, const std::string &file_name)
 Get full file name (see JEEP::getPath). More...
 
std::string getNamespace (const std::string &type_name)
 Get name space, i.e. More...
 
std::string getClassname (const std::string &type_name)
 Get type name, i.e. More...
 
std::string getProtocol (const std::string &file_name)
 Get protocol, i.e. More...
 
std::string getURL ()
 Get URL of document pages. More...
 
template<class T >
T * open (const std::string &file_name)
 Open file. More...
 
template<>
std::istream * open (const std::string &file_name)
 Open file. More...
 
template<>
std::ostream * open (const std::string &file_name)
 Open file. More...
 
void close (std::istream *pf)
 Close file. More...
 
void close (std::ostream *pf)
 Close file. More...
 
template<class T >
int sign (const T &value)
 Get sign of value. More...
 
int getIndex ()
 Get index for user I/O manipulation. More...
 
std::ostream & getOstream ()
 Get output stream for conversion to std::string. More...
 
const char * getCString (const std::string &input)
 Get output C-string. More...
 
bool fail (std::istream &in)
 Check for stream state. More...
 
template<class T >
JPropertiesgetProperties (T &object, const JEquationParameters &parameters=JEquationParameters(), const int debug=1)
 Get properties of a given object. More...
 
template<class T >
JPropertiesgetProperties (const T &object, const JEquationParameters &parameters=JEquationParameters(), const int debug=1)
 Get properties of a given object. More...
 
double getValue (const JScale_t scale)
 Get numerical value corresponding to scale. More...
 
const char * getUnit (const int scale)
 Get textual unit corresponding to scale. More...
 
JScale_t getScale (const char unit)
 Get scale corresponding to textual unit. More...
 
template<class T >
std::istream & readObject (std::istream &in, T &object)
 Stream input of object. More...
 
template<class T >
std::ostream & writeObject (std::ostream &out, const T &object)
 Stream output of object. More...
 
template<class T >
std::ostream & writeObject (std::ostream &out, const char *prefix, const T &object, const char postfix)
 Stream output of object. More...
 
template<class JFirst_t , class JSecond_t >
std::istream & readObject (std::istream &in, std::pair< JFirst_t, JSecond_t > &object)
 Template specialisation of method readObject() for std::pair. More...
 
template<class JFirst_t , class JSecond_t >
std::ostream & writeObject (std::ostream &out, const std::pair< JFirst_t, JSecond_t > &object)
 Template specialisation of method writeObject() for std::pair. More...
 
template<class JFirst_t , class JSecond_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::pair< JFirst_t, JSecond_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::pair. More...
 
template<class JElement_t , class JAllocator_t >
std::istream & readObject (std::istream &in, std::vector< JElement_t, JAllocator_t > &object)
 Template specialisation of method readObject() for std::vector. More...
 
template<class JElement_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const std::vector< JElement_t, JAllocator_t > &object)
 Template specialisation of method writeObject() for std::vector. More...
 
template<class JElement_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::vector< JElement_t, JAllocator_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::vector. More...
 
template<class JElement_t , class JAllocator_t >
std::istream & readObject (std::istream &in, std::list< JElement_t, JAllocator_t > &object)
 Template specialisation of method readObject() for std::list. More...
 
template<class JElement_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const std::list< JElement_t, JAllocator_t > &object)
 Template specialisation of method writeObject() for std::list. More...
 
template<class JElement_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::list< JElement_t, JAllocator_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::list. More...
 
template<class JElement_t , class JComparator_t , class JAllocator_t >
std::istream & readObject (std::istream &in, std::set< JElement_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method readObject() for std::set. More...
 
template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const std::set< JElement_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method writeObject() for std::set. More...
 
template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::set< JElement_t, JComparator_t, JAllocator_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::set. More...
 
template<class JElement_t , class JComparator_t , class JAllocator_t >
std::istream & readObject (std::istream &in, std::multiset< JElement_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method readObject() for std::multiset. More...
 
template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const std::multiset< JElement_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method writeObject() for std::multiset. More...
 
template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::multiset< JElement_t, JComparator_t, JAllocator_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::multiset. More...
 
template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::istream & readObject (std::istream &in, std::map< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method readObject() for std::map. More...
 
template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const std::map< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method writeObject() for std::map. More...
 
template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::map< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::map. More...
 
template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::istream & readObject (std::istream &in, std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method readObject() for std::multimap. More...
 
template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object)
 Template specialisation of method writeObject() for std::multimap. More...
 
template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream & writeObject (std::ostream &out, const char *prefix, const std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object, const char postfix)
 Template specialisation of method writeObject() for std::multimap. More...
 
template<class T >
std::ostream & writeArray (std::ostream &out, const char *left, const char *right, const char *sep, T __begin, T __end)
 Write array of objects. More...
 
bool operator< (const JVersion &first, const JVersion &second)
 Less-than operator for versions. More...
 

Variables

static const char *const LD_LIBRARY_PATH = "LD_LIBRARY_PATH"
 Nick names of environment variables. More...
 
static const char *const PATH = "PATH"
 binary file paths More...
 
static const char *const SHELL = "SHELL"
 SHELL. More...
 
static const char *const JPP_PAGES = "JPP_PAGES"
 Jpp document pages. More...
 
static const char PATHNAME_SEPARATOR = '/'
 path name separator More...
 
static const char PATHLIST_SEPARATOR = ':'
 path list separator More...
 
static const char FILENAME_SEPARATOR = '.'
 file name separator More...
 
static const char *const TYPENAME_SEPARATOR = "::"
 type name separator More...
 
static const char PROTOCOL_SEPARATOR = ':'
 protocol separator More...
 

Detailed Description

General puprpose classes and methods.

Author
mdejong

Enumeration Type Documentation

◆ JMessage_t

Debug level.

Enumerator
debug_t 

debug

status_t 

status

warning_t 

warning

notice_t 

notice

error_t 

error

fatal_t 

fatal; exit

Definition at line 27 of file JMessage.hh.

27  {
28 
29  debug_t = 3, //!< debug
30  status_t = 2, //!< status
31  warning_t = 2, //!< warning
32  notice_t = 1, //!< notice
33  error_t = 0, //!< error
34  fatal_t = 0 //!< fatal; exit
35  };

◆ JPrintOption_t

Print options.

Enumerator
SHORT_PRINT 

short print

MEDIUM_PRINT 

medium print

LONG_PRINT 

long print

Definition at line 38 of file JPrint.hh.

38  {
39  SHORT_PRINT = 1, //!< short print
40  MEDIUM_PRINT = 2, //!< medium print
41  LONG_PRINT = 3 //!< long print
42  };

◆ JScale_t

Enumeration for scaling of quantity.

Enumerator
femto_t 

femto

pico_t 

pico

nano_t 

nano

micro_t 

micro

milli_t 

milli

unit_t 

unit

kilo_t 

kilo

mega_t 

mega

giga_t 

giga

tera_t 

tera

peta_t 

peta

exa_t 

exa

Definition at line 24 of file JScale.hh.

24  {
25 
26  femto_t = -15, //!< femto
27  pico_t = -12, //!< pico
28  nano_t = -9, //!< nano
29  micro_t = -6, //!< micro
30  milli_t = -3, //!< milli
31  unit_t = 0, //!< unit
32  kilo_t = +3, //!< kilo
33  mega_t = +6, //!< mega
34  giga_t = +9, //!< giga
35  tera_t = +12, //!< tera
36  peta_t = +15, //!< peta
37  exa_t = +18 //!< exa
38  };

Function Documentation

◆ compareObjects() [1/3]

template<class T >
bool JEEP::compareObjects ( const T &  first,
const T &  second,
JBool< true >   
)
inline

Comparison of comparable objects.

Parameters
firstfirst object
secondsecond object
Returns
true if objects are equal; else false

Definition at line 30 of file JComparisonToolkit.hh.

33  {
34  return first == second;
35  }

◆ compareObjects() [2/3]

template<class T >
bool JEEP::compareObjects ( const T &  first,
const T &  second,
JBool< false >   
)
inline

Comparison of uncomparable objects.

Parameters
firstfirst object
secondsecond object
Returns
false

Definition at line 46 of file JComparisonToolkit.hh.

49  {
50  return false;
51  }

◆ compareObjects() [3/3]

template<class T >
bool JEEP::compareObjects ( const T &  first,
const T &  second 
)
inline

Comparison of objects.

Parameters
firstfirst object
secondsecond object
Returns
true if objects are comparable and equal; else false

Definition at line 62 of file JComparisonToolkit.hh.

64  {
65  return compareObjects(first, second, JBool<JComparisonAvailable<T>::has_eq>());
66  }

◆ strip()

std::string JEEP::strip ( const std::string &  file_name)
inline

Strip leading and trailing white spaces from file name.

Parameters
file_namefile name
Returns
file name

Definition at line 47 of file JeepToolkit.hh.

48  {
49  using namespace std;
50 
51  string::const_iterator p = file_name. begin();
52  string::const_reverse_iterator q = file_name.rbegin();
53 
54  for ( ; p != file_name.end() && q != file_name.rend() && isspace(*p); ++p) {}
55  for ( ; p != file_name.end() && q != file_name.rend() && isspace(*q); ++q) {}
56 
57  return string(p,q.base());
58  }

◆ getFilenameExtension()

std::string JEEP::getFilenameExtension ( const std::string &  file_name)
inline

Get file name extension, i.e.

part after last JEEP::FILENAME_SEPARATOR if any.

Parameters
file_namefile name
Returns
extension (excluding separator)

Definition at line 67 of file JeepToolkit.hh.

68  {
69  using namespace std;
70 
71  const size_t pos = file_name.rfind(FILENAME_SEPARATOR);
72 
73  if (pos != string::npos)
74  return file_name.substr(pos + 1);
75  else
76  return "";
77  }

◆ getFilename() [1/2]

std::string JEEP::getFilename ( const std::string &  file_name)
inline

Get file name part, i.e.

part after last JEEP::PATHNAME_SEPARATOR if any.

Parameters
file_namefile name
Returns
file name part (excluding separator)

Definition at line 86 of file JeepToolkit.hh.

87  {
88  using namespace std;
89 
90  const string buffer = strip(file_name);
91  const size_t pos = buffer.rfind(PATHNAME_SEPARATOR);
92 
93  if (pos != string::npos)
94  return buffer.substr(pos + 1);
95  else
96  return buffer;
97  }

◆ getPath() [1/2]

std::string JEEP::getPath ( const std::string &  file_name)
inline

Get path, i.e.

part before last JEEP::PATHNAME_SEPARATOR if any.

Parameters
file_namefile name
Returns
path (including separator)

Definition at line 106 of file JeepToolkit.hh.

107  {
108  using namespace std;
109 
110  const string buffer = strip(file_name);
111  const size_t pos = buffer.rfind(PATHNAME_SEPARATOR);
112 
113  if (pos != string::npos)
114  return buffer.substr(0, pos + 1);
115  else
116  return "";
117  }

◆ getFullPath()

std::string JEEP::getFullPath ( const std::string &  path)
inline

Get full path, i.e.

add JEEP::PATHNAME_SEPARATOR if necessary.

Parameters
pathpath
Returns
path (including separator)

Definition at line 126 of file JeepToolkit.hh.

127  {
128  using namespace std;
129 
130  const string buffer = strip(path);
131 
132  if (buffer.empty() || *buffer.rbegin() == PATHNAME_SEPARATOR) {
133 
134  return buffer;
135 
136  } else {
137 
138  return buffer + PATHNAME_SEPARATOR;
139  }
140  }

◆ getFilename() [2/2]

std::string JEEP::getFilename ( const std::string &  path,
const std::string &  file_name 
)
inline

Compose full file name and introduce JEEP::PATHNAME_SEPARATOR if needed.

Parameters
pathpath
file_namefile name
Returns
file name

Definition at line 150 of file JeepToolkit.hh.

151  {
152  using namespace std;
153 
154  const string buffer = getFullPath(path);
155 
156  if (buffer.empty())
157  return strip(file_name);
158  else
159  return buffer + strip(file_name);
160  }

◆ getPath() [2/2]

std::string JEEP::getPath ( const std::string &  variable,
const std::string &  file_name 
)
inline

Get selected path from environment variable for given file name.

The environment variable is parsed according character JEEP::PATHLIST_SEPARATOR. The first path in which a file exists with the given file name is returned. If no existing file is found, an empty path is returned.

Parameters
variableenvironment variable
file_namefile name
Returns
path

Definition at line 174 of file JeepToolkit.hh.

175  {
176  using namespace std;
177 
178  string path = "";
179 
180  if (!file_name.empty() && file_name[0] != PATHNAME_SEPARATOR) {
181 
182  const string buffer(getenv(variable.c_str()));
183 
184  if (!buffer.empty()) {
185 
186  size_t pos = 0, len;
187 
188  do {
189 
190  len = buffer.substr(pos).find(PATHLIST_SEPARATOR);
191  path = buffer.substr(pos,len);
192 
193  } while (!ifstream(getFilename(path, file_name).c_str()).good() && len != string::npos && (pos += len + 1) != buffer.length());
194  }
195  }
196 
197  if (ifstream(getFilename(path, file_name).c_str()).good())
198  return path;
199  else
200  return "";
201  }

◆ getFullFilename()

std::string JEEP::getFullFilename ( const std::string &  variable,
const std::string &  file_name 
)
inline

Get full file name (see JEEP::getPath).

Parameters
variableenvironment variable
file_namefile name
Returns
file name

Definition at line 211 of file JeepToolkit.hh.

212  {
213  return getFilename(getPath(variable, file_name), file_name);
214  }

◆ getNamespace()

std::string JEEP::getNamespace ( const std::string &  type_name)
inline

Get name space, i.e.

part before JEEP::TYPENAME_SEPARATOR.

Parameters
type_nametype name
Returns
name space (possibly empty)

Definition at line 223 of file JeepToolkit.hh.

224  {
225  using namespace std;
226 
227  const size_t pos = type_name.rfind(TYPENAME_SEPARATOR);
228 
229  if (pos != string::npos)
230  return type_name.substr(0, pos);
231  else
232  return "";
233  }

◆ getClassname()

std::string JEEP::getClassname ( const std::string &  type_name)
inline

Get type name, i.e.

part after JEEP::TYPENAME_SEPARATOR.

Parameters
type_nametype name
Returns
class name

Definition at line 242 of file JeepToolkit.hh.

243  {
244  using namespace std;
245 
246  const size_t pos = type_name.rfind(TYPENAME_SEPARATOR);
247 
248  if (pos != string::npos)
249  return type_name.substr(pos + 2);
250  else
251  return type_name;
252  }

◆ getProtocol()

std::string JEEP::getProtocol ( const std::string &  file_name)
inline

Get protocol, i.e.

part before first JEEP::PROTOCOL_SEPARATOR if any.

Parameters
file_namefile name
Returns
protocol (excluding separator)

Definition at line 261 of file JeepToolkit.hh.

262  {
263  using namespace std;
264 
265  const size_t pos = file_name.find(PROTOCOL_SEPARATOR);
266 
267  if (pos != string::npos)
268  return file_name.substr(0, pos);
269  else
270  return "";
271  }

◆ getURL()

std::string JEEP::getURL ( )
inline

Get URL of document pages.

Returns
URL

Definition at line 279 of file JeepToolkit.hh.

280  {
281  return std::string(getenv(JPP_PAGES));
282  }

◆ open() [1/3]

template<class T >
T* JEEP::open ( const std::string &  file_name)
inline

Open file.

Parameters
file_namefile name
Returns
pointer to input stream
Parameters
file_namefile name
Returns
pointer to output stream

Definition at line 302 of file JeepToolkit.hh.

303  {
304  using namespace std;
305  using namespace JPP;
306 
307  if (getFilenameExtension(file_name) == "gz")
308  return new igzstream(file_name.c_str());
309  else if (getFilenameExtension(file_name) == "txt")
310  return new ifstream (file_name.c_str());
311  else
312  return NULL;
313  }

◆ open() [2/3]

template<>
std::istream* JEEP::open ( const std::string &  file_name)
inline

Open file.

Parameters
file_namefile name
Returns
pointer to input stream

Definition at line 302 of file JeepToolkit.hh.

303  {
304  using namespace std;
305  using namespace JPP;
306 
307  if (getFilenameExtension(file_name) == "gz")
308  return new igzstream(file_name.c_str());
309  else if (getFilenameExtension(file_name) == "txt")
310  return new ifstream (file_name.c_str());
311  else
312  return NULL;
313  }

◆ open() [3/3]

template<>
std::ostream* JEEP::open ( const std::string &  file_name)
inline

Open file.

Parameters
file_namefile name
Returns
pointer to output stream

Definition at line 323 of file JeepToolkit.hh.

324  {
325  using namespace std;
326  using namespace JPP;
327 
328  if (getFilenameExtension(file_name) == "gz")
329  return new ogzstream(file_name.c_str());
330  else if (getFilenameExtension(file_name) == "txt")
331  return new ofstream (file_name.c_str());
332  else
333  return NULL;
334  }

◆ close() [1/2]

void JEEP::close ( std::istream *  pf)
inline

Close file.

Parameters
pfpointer to file stream

Definition at line 342 of file JeepToolkit.hh.

343  {
344  using namespace std;
345  using namespace JPP;
346 
347  if (dynamic_cast<ifstream*> (pf) != NULL) { dynamic_cast<ifstream*> (pf)->close(); return; }
348  if (dynamic_cast<igzstream*>(pf) != NULL) { dynamic_cast<igzstream*>(pf)->close(); return; }
349  }

◆ close() [2/2]

void JEEP::close ( std::ostream *  pf)
inline

Close file.

Parameters
pfpointer to file stream

Definition at line 357 of file JeepToolkit.hh.

358  {
359  using namespace std;
360  using namespace JPP;
361 
362  if (dynamic_cast<ofstream*> (pf) != NULL) { dynamic_cast<ofstream*> (pf)->close(); return; }
363  if (dynamic_cast<ogzstream*>(pf) != NULL) { dynamic_cast<ogzstream*>(pf)->close(); return; }
364  }

◆ sign()

template<class T >
int JEEP::sign ( const T &  value)
inline

Get sign of value.

Parameters
valuevalue
Returns
-1 if value < 0; 0 if value == 0; +1 if value > 0

Definition at line 20 of file JLib.hh.

21  {
22  return (value > T(0)) - (value < T(0));
23  }

◆ getIndex()

int JEEP::getIndex ( )
inline

Get index for user I/O manipulation.

Returns
index

Definition at line 27 of file JPrint.hh.

28  {
29  static const int index = std::ios_base::xalloc();
30 
31  return index;
32  }

◆ getOstream()

std::ostream& JEEP::getOstream ( )
inline

Get output stream for conversion to std::string.

Note that the stream is emptied before use.

Returns
output stream

Definition at line 52 of file JPrint.hh.

53  {
54  static std::ostringstream buffer;
55 
56  buffer.str("");
57 
58  return buffer;
59  }

◆ getCString()

const char* JEEP::getCString ( const std::string &  input)
inline

Get output C-string.

Note that this method is needed to guarentee livetime of underlying std::string.

Parameters
inputinput
Returns
C-string

Definition at line 70 of file JPrint.hh.

71  {
72  static std::string buffer;
73 
74  buffer = input;
75 
76  return buffer.c_str();
77  }

◆ fail()

bool JEEP::fail ( std::istream &  in)
inline

Check for stream state.

Note that end-of-file is not defined as an error so to normally process e.g. std::string and std::vector.

Parameters
ininput stream
Returns
true if failure; else false

Definition at line 57 of file JProperties.hh.

58  {
59  return in.bad() || (in.fail() && !in.eof());
60  }

◆ getProperties() [1/2]

template<class T >
JProperties& JEEP::getProperties ( T &  object,
const JEquationParameters parameters = JEquationParameters(),
const int  debug = 1 
)
inline

Get properties of a given object.

This method transfers the making of the property object to the corresponding class whilst preserving the constness of the argument.
The corresponding class should implement the method:

  template<bool is_const>
  static JProperties getProperties(typename JCategory<T, is_const>::reference_type object,
                                const JEquationParameters& equation,
                                const int debug)
Parameters
objectobject
parametersequation parameters
debugdebug level

Definition at line 1267 of file JProperties.hh.

1270  {
1271  static JProperties properties;
1272 
1273  properties = T::template getProperties<true>(object, parameters, debug);
1274 
1275  return properties;
1276  }

◆ getProperties() [2/2]

template<class T >
JProperties& JEEP::getProperties ( const T &  object,
const JEquationParameters parameters = JEquationParameters(),
const int  debug = 1 
)
inline

Get properties of a given object.

This method transfers the making of the property object to the corresponding class whilst preserving the constness of the argument.
The corresponding class should implement the method:

  template<bool is_const>
  static JProperties getProperties(typename JCategory<T, is_const>::reference_type object,
                                const JEquationParameters& equation,
                                const int debug)
Parameters
objectobject
parametersequation parameters
debugdebug level

Definition at line 1297 of file JProperties.hh.

1300  {
1301  static JProperties properties;
1302 
1303  properties = T::template getProperties<false>(object, parameters, debug);
1304 
1305  return properties;
1306  }

◆ getValue()

double JEEP::getValue ( const JScale_t  scale)
inline

Get numerical value corresponding to scale.

Parameters
scalescale
Returns
value

Definition at line 47 of file JScale.hh.

48  {
49  return pow(10.0, scale);
50  }

◆ getUnit()

const char* JEEP::getUnit ( const int  scale)
inline

Get textual unit corresponding to scale.

Parameters
scalescale
Returns
textual unit

Definition at line 59 of file JScale.hh.

60  {
61  switch (scale) {
62 
63  case femto_t:
64  return "f";
65 
66  case pico_t:
67  return "p";
68 
69  case nano_t:
70  return "n";
71 
72  case micro_t:
73  return "u";
74 
75  case milli_t:
76  return "m";
77 
78  case unit_t:
79  return "";
80 
81  case kilo_t:
82  return "k";
83 
84  case mega_t:
85  return "M";
86 
87  case giga_t:
88  return "G";
89 
90  case tera_t:
91  return "T";
92 
93  case peta_t:
94  return "P";
95 
96  case exa_t:
97  return "E";
98 
99  default:
100  THROW(JValueOutOfRange, "getUnit(): invalid scale " << scale);
101  };
102  }

◆ getScale()

JScale_t JEEP::getScale ( const char  unit)
inline

Get scale corresponding to textual unit.

Parameters
unittextual unit
Returns
scale

Definition at line 111 of file JScale.hh.

112  {
113  switch (unit) {
114 
115  case 'f':
116  return femto_t;
117 
118  case 'p':
119  return pico_t;
120 
121  case 'n':
122  return nano_t;
123 
124  case 'u':
125  return micro_t;
126 
127  case 'm':
128  return milli_t;
129 
130  case ' ':
131  return unit_t;
132 
133  case 'k':
134  return kilo_t;
135 
136  case 'M':
137  return mega_t;
138 
139  case 'G':
140  return giga_t;
141 
142  case 'T':
143  return tera_t;
144 
145  case 'P':
146  return peta_t;
147 
148  case 'E':
149  return exa_t;
150 
151  default:
152  THROW(JValueOutOfRange, "getScale(): invalid unit " << unit);
153  };
154  }

◆ readObject() [1/8]

template<class T >
std::istream& JEEP::readObject ( std::istream &  in,
T &  object 
)
inline

Stream input of object.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 28 of file JStreamToolkit.hh.

29  {
30  return in >> object;
31  }

◆ writeObject() [1/16]

template<class T >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const T &  object 
)
inline

Stream output of object.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 42 of file JStreamToolkit.hh.

43  {
44  return out << object;
45  }

◆ writeObject() [2/16]

template<class T >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const T &  object,
const char  postfix 
)
inline

Stream output of object.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 58 of file JStreamToolkit.hh.

62  {
63  return out << prefix << object << postfix;
64  }

◆ readObject() [2/8]

template<class JFirst_t , class JSecond_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::pair< JFirst_t, JSecond_t > &  object 
)
inline

Template specialisation of method readObject() for std::pair.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 75 of file JStreamToolkit.hh.

76  {
77  readObject(in, object.first);
78  readObject(in, object.second);
79 
80  return in;
81  }

◆ writeObject() [3/16]

template<class JFirst_t , class JSecond_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::pair< JFirst_t, JSecond_t > &  object 
)
inline

Template specialisation of method writeObject() for std::pair.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 92 of file JStreamToolkit.hh.

93  {
94  writeObject(out, object.first);
95  writeObject(out, ' ');
96  writeObject(out, object.second);
97 
98  return out;
99  }

◆ writeObject() [4/16]

template<class JFirst_t , class JSecond_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::pair< JFirst_t, JSecond_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::pair.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 112 of file JStreamToolkit.hh.

116  {
117  writeObject(out, prefix);
118  writeObject(out, object.first);
119  writeObject(out, ' ');
120  writeObject(out, object.second);
121  writeObject(out, postfix);
122 
123  return out;
124  }

◆ readObject() [3/8]

template<class JElement_t , class JAllocator_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::vector< JElement_t, JAllocator_t > &  object 
)
inline

Template specialisation of method readObject() for std::vector.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 135 of file JStreamToolkit.hh.

136  {
137  for (JElement_t element; readObject(in, element); ) {
138  object.push_back(element);
139  }
140 
141  return in;
142  }

◆ writeObject() [5/16]

template<class JElement_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::vector< JElement_t, JAllocator_t > &  object 
)
inline

Template specialisation of method writeObject() for std::vector.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 153 of file JStreamToolkit.hh.

154  {
155  for (typename std::vector<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
156  writeObject(out, ' ');
157  writeObject(out, *i);
158  }
159 
160  return out;
161  }

◆ writeObject() [6/16]

template<class JElement_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::vector< JElement_t, JAllocator_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::vector.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 174 of file JStreamToolkit.hh.

178  {
179  for (typename std::vector<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
180  writeObject(out, prefix, *i, postfix);
181  }
182 
183  return out;
184  }

◆ readObject() [4/8]

template<class JElement_t , class JAllocator_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::list< JElement_t, JAllocator_t > &  object 
)
inline

Template specialisation of method readObject() for std::list.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 195 of file JStreamToolkit.hh.

196  {
197  for (JElement_t element; readObject(in, element); ) {
198  object.push_back(element);
199  }
200 
201  return in;
202  }

◆ writeObject() [7/16]

template<class JElement_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::list< JElement_t, JAllocator_t > &  object 
)
inline

Template specialisation of method writeObject() for std::list.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 213 of file JStreamToolkit.hh.

214  {
215  for (typename std::list<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
216  writeObject(out, ' ');
217  writeObject(out, *i);
218  }
219 
220  return out;
221  }

◆ writeObject() [8/16]

template<class JElement_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::list< JElement_t, JAllocator_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::list.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 234 of file JStreamToolkit.hh.

238  {
239  for (typename std::list<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
240  writeObject(out, prefix, *i, postfix);
241  }
242 
243  return out;
244  }

◆ readObject() [5/8]

template<class JElement_t , class JComparator_t , class JAllocator_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::set< JElement_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method readObject() for std::set.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 255 of file JStreamToolkit.hh.

256  {
257  for (JElement_t element; readObject(in, element); ) {
258 
260 
261  if (!result.second) {
262  object.erase (result.first);
263  object.insert(element);
264  }
265  }
266 
267  return in;
268  }

◆ writeObject() [9/16]

template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::set< JElement_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method writeObject() for std::set.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 279 of file JStreamToolkit.hh.

280  {
281  for (typename std::set<JElement_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
282  writeObject(out, ' ');
283  writeObject(out, *i);
284  }
285 
286  return out;
287  }

◆ writeObject() [10/16]

template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::set< JElement_t, JComparator_t, JAllocator_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::set.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 300 of file JStreamToolkit.hh.

304  {
305  for (typename std::set<JElement_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
306  writeObject(out, prefix, *i, postfix);
307  }
308 
309  return out;
310  }

◆ readObject() [6/8]

template<class JElement_t , class JComparator_t , class JAllocator_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::multiset< JElement_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method readObject() for std::multiset.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 321 of file JStreamToolkit.hh.

322  {
323  for (JElement_t element; readObject(in, element); ) {
324  object.insert(element);
325  }
326 
327  return in;
328  }

◆ writeObject() [11/16]

template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::multiset< JElement_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method writeObject() for std::multiset.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 339 of file JStreamToolkit.hh.

340  {
341  for (typename std::multiset<JElement_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
342  writeObject(out, ' ');
343  writeObject(out, *i);
344  }
345 
346  return out;
347  }

◆ writeObject() [12/16]

template<class JElement_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::multiset< JElement_t, JComparator_t, JAllocator_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::multiset.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 360 of file JStreamToolkit.hh.

364  {
365  for (typename std::multiset<JElement_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
366  writeObject(out, prefix, *i, postfix);
367  }
368 
369  return out;
370  }

◆ readObject() [7/8]

template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::map< JKey_t, JValue_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method readObject() for std::map.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 381 of file JStreamToolkit.hh.

382  {
383  for (std::pair<JKey_t, JValue_t> element; readObject(in, element); ) {
384 
386 
387  if (!result.second) {
388  result.first->second = element.second;
389  }
390  }
391 
392  return in;
393  }

◆ writeObject() [13/16]

template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::map< JKey_t, JValue_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method writeObject() for std::map.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 404 of file JStreamToolkit.hh.

405  {
406  for (typename std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
407  writeObject(out, ' ');
408  writeObject(out, *i);
409  }
410 
411  return out;
412  }

◆ writeObject() [14/16]

template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::map< JKey_t, JValue_t, JComparator_t, JAllocator_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::map.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 425 of file JStreamToolkit.hh.

429  {
430  for (typename std::map<JKey_t, JValue_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
431  writeObject(out, prefix, *i, postfix);
432  }
433 
434  return out;
435  }

◆ readObject() [8/8]

template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::istream& JEEP::readObject ( std::istream &  in,
std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method readObject() for std::multimap.

Parameters
ininput stream
objectobject
Returns
input stream

Definition at line 446 of file JStreamToolkit.hh.

447  {
448  for (std::pair<JKey_t, JValue_t> element; readObject(in, element); ) {
449  object.insert(element);
450  }
451 
452  return in;
453  }

◆ writeObject() [15/16]

template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &  object 
)
inline

Template specialisation of method writeObject() for std::multimap.

Parameters
outoutput stream
objectobject
Returns
output stream

Definition at line 464 of file JStreamToolkit.hh.

465  {
466  for (typename std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
467  writeObject(out, ' ');
468  writeObject(out, *i);
469  }
470 
471  return out;
472  }

◆ writeObject() [16/16]

template<class JKey_t , class JValue_t , class JComparator_t , class JAllocator_t >
std::ostream& JEEP::writeObject ( std::ostream &  out,
const char *  prefix,
const std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &  object,
const char  postfix 
)
inline

Template specialisation of method writeObject() for std::multimap.

Parameters
outoutput stream
prefixprefix
objectobject
postfixpostfix
Returns
output stream

Definition at line 485 of file JStreamToolkit.hh.

489  {
490  for (typename std::multimap<JKey_t, JValue_t, JComparator_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
491  writeObject(out, prefix, *i, postfix);
492  }
493 
494  return out;
495  }

◆ writeArray()

template<class T >
std::ostream& JEEP::writeArray ( std::ostream &  out,
const char *  left,
const char *  right,
const char *  sep,
__begin,
__end 
)
inline

Write array of objects.

Parameters
outoutput stream
leftleft bracket
rightright bracket
sepseparator
__beginbegin of data
__endend of data
Returns
output stream

Definition at line 510 of file JStreamToolkit.hh.

516  {
517  if (std::distance(__begin, __end) != 0) {
518 
519  out << left;
520 
521  T i = __begin;
522 
523  writeObject(out, *i);
524 
525  while (++i != __end) {
526 
527  out << sep;
528 
529  JEEP::writeObject(out, *i);
530  }
531 
532  out << right;
533  }
534 
535  return out;
536  }

◆ operator<()

bool JEEP::operator< ( const JVersion first,
const JVersion second 
)
inline

Less-than operator for versions.

Parameters
firstfirst version
secondsecond version
Returns
true if first version before second; else false

Definition at line 182 of file JVersion.hh.

183  {
184  return first.getVariant() < second.getVariant();
185  }

Variable Documentation

◆ LD_LIBRARY_PATH

const char* const JEEP::LD_LIBRARY_PATH = "LD_LIBRARY_PATH"
static

Nick names of environment variables.

library file paths

Definition at line 29 of file JeepToolkit.hh.

◆ PATH

const char* const JEEP::PATH = "PATH"
static

binary file paths

Definition at line 30 of file JeepToolkit.hh.

◆ SHELL

const char* const JEEP::SHELL = "SHELL"
static

SHELL.

Definition at line 31 of file JeepToolkit.hh.

◆ JPP_PAGES

const char* const JEEP::JPP_PAGES = "JPP_PAGES"
static

Jpp document pages.

Definition at line 32 of file JeepToolkit.hh.

◆ PATHNAME_SEPARATOR

const char JEEP::PATHNAME_SEPARATOR = '/'
static

path name separator

Definition at line 34 of file JeepToolkit.hh.

◆ PATHLIST_SEPARATOR

const char JEEP::PATHLIST_SEPARATOR = ':'
static

path list separator

Definition at line 35 of file JeepToolkit.hh.

◆ FILENAME_SEPARATOR

const char JEEP::FILENAME_SEPARATOR = '.'
static

file name separator

Definition at line 36 of file JeepToolkit.hh.

◆ TYPENAME_SEPARATOR

const char* const JEEP::TYPENAME_SEPARATOR = "::"
static

type name separator

Definition at line 37 of file JeepToolkit.hh.

◆ PROTOCOL_SEPARATOR

const char JEEP::PROTOCOL_SEPARATOR = ':'
static

protocol separator

Definition at line 38 of file JeepToolkit.hh.

JEEP::exa_t
exa
Definition: JScale.hh:37
JEEP::writeObject
std::ostream & writeObject(std::ostream &out, const char *prefix, const std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object, const char postfix)
Template specialisation of method writeObject() for std::multimap.
Definition: JStreamToolkit.hh:485
JEEP::FILENAME_SEPARATOR
static const char FILENAME_SEPARATOR
file name separator
Definition: JeepToolkit.hh:36
igzstream
Definition: gzstream.h:203
JEEP::PATHLIST_SEPARATOR
static const char PATHLIST_SEPARATOR
path list separator
Definition: JeepToolkit.hh:35
JEEP::fatal_t
fatal; exit
Definition: JMessage.hh:34
JEEP::notice_t
notice
Definition: JMessage.hh:32
JEEP::micro_t
micro
Definition: JScale.hh:29
std::vector
Definition: JSTDTypes.hh:12
JEEP::kilo_t
kilo
Definition: JScale.hh:32
ogzstream
Definition: gzstream.h:213
JEEP::giga_t
giga
Definition: JScale.hh:34
distance
std::vector< T >::difference_type distance(typename std::vector< T >::const_iterator first, typename PhysicsEvent::const_iterator< T > second)
Specialisation of STL distance.
Definition: PhysicsEvent.hh:434
JEEP::TYPENAME_SEPARATOR
static const char *const TYPENAME_SEPARATOR
type name separator
Definition: JeepToolkit.hh:37
JEEP::milli_t
milli
Definition: JScale.hh:30
JEEP::getPath
std::string getPath(const std::string &variable, const std::string &file_name)
Get selected path from environment variable for given file name.
Definition: JeepToolkit.hh:174
std::set
Definition: JSTDTypes.hh:13
JEEP::error_t
error
Definition: JMessage.hh:33
JEEP::warning_t
warning
Definition: JMessage.hh:31
JPP
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
Definition: JAAnetToolkit.hh:37
JEEP::LONG_PRINT
long print
Definition: JPrint.hh:41
JEEP::getFilenameExtension
std::string getFilenameExtension(const std::string &file_name)
Get file name extension, i.e.
Definition: JeepToolkit.hh:67
debug
int debug
debug level
Definition: JSirene.cc:59
JTOOLS::result
return result
Definition: JPolint.hh:695
JEEP::getFullPath
std::string getFullPath(const std::string &path)
Get full path, i.e.
Definition: JeepToolkit.hh:126
JEEP::nano_t
nano
Definition: JScale.hh:28
JEEP::status_t
status
Definition: JMessage.hh:30
std::multiset
Definition: JSTDTypes.hh:14
THROW
#define THROW(JException_t, A)
Marco for throwing exception with std::ostream compatible message.
Definition: JException.hh:669
JEEP::strip
std::string strip(const std::string &file_name)
Strip leading and trailing white spaces from file name.
Definition: JeepToolkit.hh:47
std::map
Definition: JSTDTypes.hh:16
JEEP::writeObject
std::ostream & writeObject(std::ostream &out, const T &object)
Stream output of object.
Definition: JStreamToolkit.hh:42
std::pair
Definition: JSTDTypes.hh:15
JEEP::readObject
std::istream & readObject(std::istream &in, std::multimap< JKey_t, JValue_t, JComparator_t, JAllocator_t > &object)
Template specialisation of method readObject() for std::multimap.
Definition: JStreamToolkit.hh:446
JEEP::femto_t
femto
Definition: JScale.hh:26
JEEP::MEDIUM_PRINT
medium print
Definition: JPrint.hh:40
JEEP::peta_t
peta
Definition: JScale.hh:36
JEEP::SHORT_PRINT
short print
Definition: JPrint.hh:39
std::multimap
Definition: JSTDTypes.hh:17
JEEP::JProperties
Utility class to parse parameter values.
Definition: JProperties.hh:496
std
Definition: jaanetDictionary.h:36
JEEP::JVersion::getVariant
const std::string & getVariant() const
Get variant.
Definition: JVersion.hh:90
JEEP::mega_t
mega
Definition: JScale.hh:33
JEEP::unit_t
unit
Definition: JScale.hh:31
JEEP::tera_t
tera
Definition: JScale.hh:35
std::list
Definition: JSTDTypes.hh:24
scale
void scale(vector< double > &v, double c)
scale vector content
Definition: JBeaconSimulator.cc:72
JEEP::JPP_PAGES
static const char *const JPP_PAGES
Jpp document pages.
Definition: JeepToolkit.hh:32
JEEP::debug_t
debug
Definition: JMessage.hh:29
JEEP::pico_t
pico
Definition: JScale.hh:27
JEEP::getFilename
std::string getFilename(const std::string &path, const std::string &file_name)
Compose full file name and introduce JEEP::PATHNAME_SEPARATOR if needed.
Definition: JeepToolkit.hh:150
JEEP::compareObjects
bool compareObjects(const T &first, const T &second)
Comparison of objects.
Definition: JComparisonToolkit.hh:62
JEEP::PATHNAME_SEPARATOR
static const char PATHNAME_SEPARATOR
path name separator
Definition: JeepToolkit.hh:34
JEEP::PROTOCOL_SEPARATOR
static const char PROTOCOL_SEPARATOR
protocol separator
Definition: JeepToolkit.hh:38