Classes | Static Public Member Functions | Static Private Member Functions | List of all members
PLMD::Tools Class Reference

#include <Tools.h>

Classes

class  CriticalSectionWithKey
 Utility to create named critical sections Key should be usable in a std::map. More...
 
class  DirectoryChanger
 Tiny class that changes directory and comes back when going out of scope. More...
 
class  FastStringUnorderedMap
 Tiny class implementing faster std::string_view access to an unordered_map It exposes a limited number of methods of std::unordered_map. More...
 

Static Public Member Functions

static double bessel0 (const double &val)
 Modified 0th-order Bessel function of the first kind. More...
 
static bool caseInSensStringCompare (const std::string &str1, const std::string &str2)
 compare two string in a case insensitive manner More...
 
static std::string concatenateExceptionMessages ()
 Build a concatenated exception message. More...
 
template<typename T , typename U >
static void convert (const T &t, U &u)
 Find a keyword on the input line, eventually deleting it, and saving its value to val. More...
 
static bool convertNoexcept (const std::string &str, AtomNumber &t)
 Convert a string to a atom number, reading it. More...
 
static bool convertNoexcept (const std::string &str, double &t)
 Convert a string to a double, reading it. More...
 
static bool convertNoexcept (const std::string &str, float &t)
 Convert a string to a float, reading it. More...
 
static bool convertNoexcept (const std::string &str, int &t)
 Convert a string to a int, reading it. More...
 
static bool convertNoexcept (const std::string &str, long double &t)
 Convert a string to a long double, reading it. More...
 
static bool convertNoexcept (const std::string &str, long int &t)
 Convert a string to a long int, reading it. More...
 
static bool convertNoexcept (const std::string &str, long long int &t)
 Convert a string to a long long int, reading it. More...
 
static bool convertNoexcept (const std::string &str, long long unsigned &t)
 Convert a string to a long long unsigned int, reading it. More...
 
static bool convertNoexcept (const std::string &str, long unsigned &t)
 Convert a string to a long unsigned int, reading it. More...
 
static bool convertNoexcept (const std::string &str, std::string &t)
 Convert a string to a string (i.e. copy) More...
 
static bool convertNoexcept (const std::string &str, unsigned &t)
 Convert a string to an unsigned int, reading it. More...
 
template<typename T >
static bool convertNoexcept (T i, std::string &str)
 Convert anything into a string. More...
 
static std::string extension (const std::string &)
 Extract the extensions from a file name. More...
 
static double fastpow (double base, int exp)
 Fast int power. More...
 
template<int exp, typename T = double>
static T fastpow (T base)
 Fast int power for power known at compile time. More...
 
static bool findKeyword (const std::vector< std::string > &line, const std::string &key)
 Find a keyword on the input line, just reporting if it exists or not. More...
 
static bool getKey (std::vector< std::string > &line, const std::string &key, std::string &s, int rep=-1)
 Retrieve a key from a vector of options. More...
 
static bool getline (FILE *, std::string &line)
 Get a line from the file pointer ifile. More...
 
static bool getParsedLine (IFile &ifile, std::vector< std::string > &line, const bool trimcomments=true)
 Get a parsed line from the file pointer ifile This function already takes care of joining continued lines and splitting the resulting line into an array of words. More...
 
static std::vector< std::string > getWords (std::string_view line, const char *sep=NULL, int *parlevel=NULL, const char *parenthesis="{", const bool &delete_parenthesis=true)
 Split the line in words using separators. More...
 
static void getWordsSimple (gch::small_vector< std::string_view > &words, std::string_view line)
 Faster version This version does not parse parenthesis and operates on a preallocated small_vector of string_view's. More...
 
static void interpretLabel (std::vector< std::string > &s)
 interpret ":" syntax for labels More...
 
static void interpretRanges (std::vector< std::string > &)
 Interpret atom ranges. More...
 
static std::vector< std::string > ls (const std::string &)
 list files in a directory More...
 
static void ltrim (std::string &s)
 Remove leading blanks. More...
 
template<class T , class... Args>
static auto make_unique (Args &&... args)
 
static std::unique_ptr< std::lock_guard< std::mutex > > molfile_lock ()
 
template<typename T >
static bool parse (std::vector< std::string > &line, const std::string &key, T &val, int rep=-1)
 
static bool parseFlag (std::vector< std::string > &line, const std::string &key, bool &val)
 Find a keyword without arguments on the input line. More...
 
template<class T >
static bool parseVector (std::vector< std::string > &line, const std::string &key, std::vector< T > &val, int rep=-1)
 Find a keyword on the input line, eventually deleting it, and saving its value to a vector. More...
 
static double pbc (double)
 Apply pbc for a unitary cell. More...
 
template<typename T >
static void removeDuplicates (std::vector< T > &vec)
 Remove duplicates from a vector of type T. More...
 
static void set_to_zero (double *ptr, unsigned n)
 
template<unsigned n, unsigned m>
static void set_to_zero (std::vector< TensorGeneric< n, m >> &vec)
 
template<unsigned n>
static void set_to_zero (std::vector< VectorGeneric< n >> &vec)
 
static bool startWith (const std::string &full, const std::string &start)
 Check if a string full starts with string start. More...
 
static void stripLeadingAndTrailingBlanks (std::string &str)
 removes leading and trailing blanks from a string More...
 
static void trim (std::string &s)
 Convert anything into anything, throwing an exception in case there is an error Remove trailing blanks. More...
 
static void trimComments (std::string &s)
 Remove trailing comments. More...
 
template<typename T >
static std::vector< const T * > unique2raw (const std::vector< std::unique_ptr< const T >> &)
 Tool to create a vector of raw pointers from a vector of unique_pointers. More...
 
template<typename T >
static std::vector< T * > unique2raw (const std::vector< std::unique_ptr< T >> &)
 Tool to create a vector of raw pointers from a vector of unique_pointers (const version). More...
 

Static Private Member Functions

template<class T >
static bool convertToAny (const std::string &str, T &t)
 class to convert a string to a generic type T More...
 
template<class T >
static bool convertToInt (const std::string &str, T &t)
 class to convert a string to a int type T More...
 
template<class T >
static bool convertToReal (const std::string &str, T &t)
 class to convert a string to a real type T. More...
 
template<int exp, typename T = double, std::enable_if_t<(exp >=0), bool > = true>
static T fastpow_rec (T base, T result)
 the recursive part of the template fastpow implementation More...
 

Detailed Description

Empty class which just contains several (static) tools

Member Function Documentation

◆ bessel0()

double PLMD::Tools::bessel0 ( const double &  val)
static

Modified 0th-order Bessel function of the first kind.

◆ caseInSensStringCompare()

bool PLMD::Tools::caseInSensStringCompare ( const std::string &  str1,
const std::string &  str2 
)
static

compare two string in a case insensitive manner

◆ concatenateExceptionMessages()

std::string PLMD::Tools::concatenateExceptionMessages ( )
static

Build a concatenated exception message.

Should be called with an in-flight exception.

◆ convert()

template<typename T , typename U >
static void PLMD::Tools::convert ( const T &  t,
U &  u 
)
inlinestatic

Find a keyword on the input line, eventually deleting it, and saving its value to val.

◆ convertNoexcept() [1/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
AtomNumber t 
)
static

Convert a string to a atom number, reading it.

◆ convertNoexcept() [2/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
double &  t 
)
static

Convert a string to a double, reading it.

◆ convertNoexcept() [3/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
float &  t 
)
static

Convert a string to a float, reading it.

◆ convertNoexcept() [4/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
int &  t 
)
static

Convert a string to a int, reading it.

◆ convertNoexcept() [5/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
long double &  t 
)
static

Convert a string to a long double, reading it.

◆ convertNoexcept() [6/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
long int &  t 
)
static

Convert a string to a long int, reading it.

◆ convertNoexcept() [7/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
long long int &  t 
)
static

Convert a string to a long long int, reading it.

◆ convertNoexcept() [8/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
long long unsigned &  t 
)
static

Convert a string to a long long unsigned int, reading it.

◆ convertNoexcept() [9/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
long unsigned &  t 
)
static

Convert a string to a long unsigned int, reading it.

◆ convertNoexcept() [10/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
std::string &  t 
)
static

Convert a string to a string (i.e. copy)

◆ convertNoexcept() [11/12]

bool PLMD::Tools::convertNoexcept ( const std::string &  str,
unsigned &  t 
)
static

Convert a string to an unsigned int, reading it.

◆ convertNoexcept() [12/12]

template<typename T >
bool PLMD::Tools::convertNoexcept ( i,
std::string &  str 
)
static

Convert anything into a string.

◆ convertToAny()

template<class T >
bool PLMD::Tools::convertToAny ( const std::string &  str,
T &  t 
)
staticprivate

class to convert a string to a generic type T

◆ convertToInt()

template<class T >
bool PLMD::Tools::convertToInt ( const std::string &  str,
T &  t 
)
staticprivate

class to convert a string to a int type T

◆ convertToReal()

template<class T >
bool PLMD::Tools::convertToReal ( const std::string &  str,
T &  t 
)
staticprivate

class to convert a string to a real type T.

T should be either float, double, or long double

◆ extension()

std::string PLMD::Tools::extension ( const std::string &  s)
static

Extract the extensions from a file name.

E.g.: extension("pippo.xyz")="xyz". It only returns extensions with a length between 1 and 4 E.g.: extension("pippo.12345")="" whereas extenion("pippo.1234")="1234"; It is also smart enough to detect "/", so that extension("pippo/.t")="" whereas extension("pippo/a.t")="t"

◆ fastpow() [1/2]

double PLMD::Tools::fastpow ( double  base,
int  exp 
)
inlinestatic

Fast int power.

◆ fastpow() [2/2]

template<int exp, typename T >
T PLMD::Tools::fastpow ( base)
inlinestatic

Fast int power for power known at compile time.

◆ fastpow_rec()

template<int exp, typename T , std::enable_if_t<(exp >=0), bool > >
T PLMD::Tools::fastpow_rec ( base,
result 
)
inlinestaticprivate

the recursive part of the template fastpow implementation

◆ findKeyword()

bool PLMD::Tools::findKeyword ( const std::vector< std::string > &  line,
const std::string &  key 
)
static

Find a keyword on the input line, just reporting if it exists or not.

◆ getKey()

bool PLMD::Tools::getKey ( std::vector< std::string > &  line,
const std::string &  key,
std::string &  s,
int  rep = -1 
)
static

Retrieve a key from a vector of options.

It finds a key starting with "key=" or equal to "key" and copy the part after the = on s. E.g.: line.push_back("aa=xx"); getKey(line,"aa",s); will set s="xx"

◆ getline()

bool PLMD::Tools::getline ( FILE *  fp,
std::string &  line 
)
static

Get a line from the file pointer ifile.

◆ getParsedLine()

bool PLMD::Tools::getParsedLine ( IFile ifile,
std::vector< std::string > &  line,
const bool  trimcomments = true 
)
static

Get a parsed line from the file pointer ifile This function already takes care of joining continued lines and splitting the resulting line into an array of words.

◆ getWords()

std::vector< std::string > PLMD::Tools::getWords ( std::string_view  line,
const char *  sep = NULL,
int *  parlevel = NULL,
const char *  parenthesis = "{",
const bool &  delete_parenthesis = true 
)
static

Split the line in words using separators.

It also take into account parenthesis. Outer parenthesis found are removed from output, and the text between them is considered as a single word. Only the outer parenthesis are processed, to allow nesting them. parlevel, if not NULL, is increased or decreased according to the number of opened/closed parenthesis

◆ getWordsSimple()

void PLMD::Tools::getWordsSimple ( gch::small_vector< std::string_view > &  words,
std::string_view  line 
)
static

Faster version This version does not parse parenthesis and operates on a preallocated small_vector of string_view's.

◆ interpretLabel()

void PLMD::Tools::interpretLabel ( std::vector< std::string > &  s)
static

interpret ":" syntax for labels

◆ interpretRanges()

void PLMD::Tools::interpretRanges ( std::vector< std::string > &  s)
static

Interpret atom ranges.

◆ ls()

std::vector< std::string > PLMD::Tools::ls ( const std::string &  d)
static

list files in a directory

◆ ltrim()

void PLMD::Tools::ltrim ( std::string &  s)
static

Remove leading blanks.

◆ make_unique()

template<class T , class... Args>
static auto PLMD::Tools::make_unique ( Args &&...  args)
inlinestatic

◆ molfile_lock()

std::unique_ptr< std::lock_guard< std::mutex > > PLMD::Tools::molfile_lock ( )
static

◆ parse()

template<class T >
bool PLMD::Tools::parse ( std::vector< std::string > &  line,
const std::string &  key,
T &  val,
int  rep = -1 
)
static

◆ parseFlag()

bool PLMD::Tools::parseFlag ( std::vector< std::string > &  line,
const std::string &  key,
bool &  val 
)
inlinestatic

Find a keyword without arguments on the input line.

◆ parseVector()

template<class T >
bool PLMD::Tools::parseVector ( std::vector< std::string > &  line,
const std::string &  key,
std::vector< T > &  val,
int  rep = -1 
)
static

Find a keyword on the input line, eventually deleting it, and saving its value to a vector.

◆ pbc()

double PLMD::Tools::pbc ( double  x)
inlinestatic

Apply pbc for a unitary cell.

beware: this brings any number into a pbc that ranges from -0.5 to 0.5

◆ removeDuplicates()

template<typename T >
void PLMD::Tools::removeDuplicates ( std::vector< T > &  vec)
static

Remove duplicates from a vector of type T.

◆ set_to_zero() [1/3]

static void PLMD::Tools::set_to_zero ( double *  ptr,
unsigned  n 
)
inlinestatic

◆ set_to_zero() [2/3]

template<unsigned n, unsigned m>
static void PLMD::Tools::set_to_zero ( std::vector< TensorGeneric< n, m >> &  vec)
inlinestatic

◆ set_to_zero() [3/3]

template<unsigned n>
static void PLMD::Tools::set_to_zero ( std::vector< VectorGeneric< n >> &  vec)
inlinestatic

◆ startWith()

bool PLMD::Tools::startWith ( const std::string &  full,
const std::string &  start 
)
static

Check if a string full starts with string start.

Same as full.find(start)==0

◆ stripLeadingAndTrailingBlanks()

void PLMD::Tools::stripLeadingAndTrailingBlanks ( std::string &  str)
static

removes leading and trailing blanks from a string

◆ trim()

void PLMD::Tools::trim ( std::string &  s)
static

Convert anything into anything, throwing an exception in case there is an error Remove trailing blanks.

◆ trimComments()

void PLMD::Tools::trimComments ( std::string &  s)
static

Remove trailing comments.

◆ unique2raw() [1/2]

template<typename T >
std::vector< const T * > PLMD::Tools::unique2raw ( const std::vector< std::unique_ptr< const T >> &  x)
static

Tool to create a vector of raw pointers from a vector of unique_pointers.

See the non const version.

◆ unique2raw() [2/2]

template<typename T >
std::vector< T * > PLMD::Tools::unique2raw ( const std::vector< std::unique_ptr< T >> &  x)
static

Tool to create a vector of raw pointers from a vector of unique_pointers (const version).

Returning a vector is fast in C++11. It can be used in order to feed a vector<unique_ptr<T>> to a function that takes a vector<T*>.

// some function that takes a vec
void func(std::vector<Data*> & vec);
std::vector<std::unique_ptr<Data>> vec;
// func(vec); // does not compile
func(Tools::unique2raw(vec)); // compiles

Notice that the conversion is fast but takes some time to allocate the new vector and copy the pointers. In case the function acting on the vector<T*> is very fast and we do not want to add significant overhead, it might be convenient to store a separate set of raw pointers.

// some function that takes a vec
void func(std::vector<Data*> & vec);
std::vector<std::unique_ptr<Data>> vec;

// conversion done only once:
auto vec_ptr=Tools::unique2raw(vec);

for(int i=0;i<1000;i++){
  func(vec_ptr);
}

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