StringToVector Class Reference

The StringToVector class converts a given string to the std::vector<T>. More...

#include <ARICHDatabaseTools.h>

Collaboration diagram for StringToVector:

Static Public Member Functions
template<typename T >
static auto	convert (const std::string &rLine, const char delim=' ') -> std::vector< T >
	convert<T> converts the given string in to a std::vector<T> elements seperated by the given delimiter
template<typename T >
static auto	parse (const std::string &rLine, const char delim=' ') -> std::string
	parse<T> expands the given string and evaluats defined operators.

Static Public Attributes
static const std::string	m_gRangeOperator
	m_gRangeOperator is a std::wstring containing the range symbold

Static Private Member Functions
template<typename T >
static auto	expand (std::ostream &rStream, const char delim, const std::string &rToken) -> std::ostream &
	expand<T> applies the given range and fills the given std::ostream with each element in range seperated by the delimiter char

Detailed Description

The StringToVector class converts a given string to the std::vector<T>.

The input string is allowed to contain white spaces and the specific types.

Definition at line 351 of file ARICHDatabaseTools.h.

Member Function Documentation

convert()

static auto convert ( const std::string &  rLine, const char  delim = ' '  ) -> std::vector<T>

inlinestatic

convert<T> converts the given string in to a std::vector<T> elements seperated by the given delimiter

Parameters

rLine	tokens seperated by the delimiter
delim	delimiter character

Returns

std::vector<T>

Exceptions

std::runtime_error()

if rLine contains other characters than delimiter, white space, digits or allowed characters defined by PrivateHelperClasses::TokenCast<T>

See also

PrivateHelperClasses::TokenCast<T> and its specializations

Definition at line 371 of file ARICHDatabaseTools.h.

      {
        const auto cast = PrivateHelperClasses::TokenCast<T>();
        // check if line only contains white space, numbers and delimiter char.
        if (!std::all_of(rLine.begin(), rLine.end(),
        [&cast, delim](const unsigned char c) {
        return std::isdigit(c) || std::isspace(c) ||
                 (c == delim) || cast.isValidChar(c);
        }))
        throw std::runtime_error("Detected invalid character in '" + rLine +
                                 "'!");
 
        auto iss = std::istringstream(rLine);
        auto retval = std::vector<T>();
        auto token = std::string();
 
        // convert string to number and add it to vector...
        while (std::getline(iss, token, delim))
          try {
            retval.emplace_back(cast(token));
          } catch (const std::invalid_argument& rErr) {
            throw std::runtime_error("Invalid token, got:'" + token + "'! " +
                                     rErr.what());
          } catch (const std::out_of_range& rErr) {
            // if the values exceeds the requested type
            throw std::runtime_error("Conversion out of range, got: '" + token +
                                     "'! " + rErr.what());
          }
 
        return retval;
      }

expand()

static auto expand ( std::ostream &  rStream, const char  delim, const std::string &  rToken  ) -> std::ostream&

inlinestaticprivate

expand<T> applies the given range and fills the given std::ostream with each element in range seperated by the delimiter char

Parameters

rStream
delim
rToken

Exceptions

std::runtime_error

if invalid range definition, ie A to B with A > B

Note

the precrement operator of T has to be defined, ie T::operator++()

Definition at line 464 of file ARICHDatabaseTools.h.

      {
        auto itPos = std::search(rToken.begin(), rToken.end(),
                                 m_gRangeOperator.begin(), m_gRangeOperator.end());
        const auto cast = PrivateHelperClasses::TokenCast<T>();
        auto lhs = cast(std::string(rToken.begin(), itPos));
        std::advance(itPos, m_gRangeOperator.size());
        auto rhs = cast(std::string(itPos, rToken.end()));
 
        if (lhs >= rhs)
          throw std::runtime_error(
            "Invalid expansion! lhs ist greater then rhs, got: '" + rToken +
            "'!");
 
        rStream << lhs;
        for (++lhs; lhs <= rhs; ++lhs)
          rStream << delim << lhs;
        return rStream;
      }

parse()

static auto parse ( const std::string &  rLine, const char  delim = ' '  ) -> std::string

inlinestatic

parse<T> expands the given string and evaluats defined operators.

Currently only the range operator is defined and used.

Parameters

rLine
delim

Returns

the evaluated std::string.

Exceptions

std::runtime_error()

if invalid argument for during the operator parsing out of range convertion, ie casting 0xffff into int8_t

Definition at line 415 of file ARICHDatabaseTools.h.

      {
        auto out = std::stringstream();
        auto iss = std::istringstream(rLine);
        auto token = std::string();
 
        if (!std::getline(iss, token, delim))
          return std::string();
 
        if (std::search(token.begin(), token.end(), m_gRangeOperator.begin(),
                        m_gRangeOperator.end()) != token.end()) {
          StringToVector::expand<T>(out, delim, token);
        } else {
          out << token;
        }
 
        // convert string to number and add it to vector...
        while (std::getline(iss, token, delim))
          try {
            if (std::search(token.begin(), token.end(), m_gRangeOperator.begin(),
                            m_gRangeOperator.end()) != token.end()) {
              out << ',';
              StringToVector::expand<T>(out, delim, token);
            } else {
              out << delim << token;
            }
          } catch (const std::invalid_argument& rErr) {
            throw std::runtime_error("Invalid token, got:'" + token + "'! " +
                                     rErr.what());
          } catch (const std::out_of_range& rErr) {
            // if the values exceeds the requested type
            throw std::runtime_error("Conversion out of range, got: '" + token +
                                     "'! " + rErr.what());
          }
        return out.str();
      }

Member Data Documentation

m_gRangeOperator

const std::string m_gRangeOperator

static

m_gRangeOperator is a std::wstring containing the range symbold

Definition at line 356 of file ARICHDatabaseTools.h.

---

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

• arich/calibration/include/ARICHDatabaseTools.h