util::quantities::details Namespace Reference

Functions
template<typename Quantity >
std::pair< std::string, typename Quantity::value_t >	readUnit (std::string const &str, bool unitOptional=false)
	Parses the unit of a string representing a Quantity. More...

Function Documentation

template<typename Quantity >

std::pair< std::string, typename Quantity::value_t > util::quantities::details::readUnit	(	std::string const &	str,
		bool	unitOptional = false
	)

Parses the unit of a string representing a Quantity.

Template Parameters

Quantity

the quantity being represented

Parameters

str	the string to be parsed
unitOptional	(default: false) whether unit is not required

Returns

a pair: the unparsed part of str and the factor for parsed unit

Exceptions

MissingUnit	s does not contain the required unit
ValueError	the numerical value in s is not parseable
ExtraCharactersError	spurious characters after the numeric value (including an unrecognised unit prefix)

Definition at line 1474 of file quantities.h.

References e, scale, and util::to_string().

{
  using Quantity_t = Quantity;
  using value_t = typename Quantity_t::value_t;
  using unit_t = typename Quantity_t::unit_t;
  using baseunit_t = typename unit_t::baseunit_t;

  // --- BEGIN -- static initialization ----------------------------------------
  using namespace std::string_literals;

  using PrefixMap_t = std::map<std::string, value_t>;
  using PrefixValue_t = typename PrefixMap_t::value_type;
  static PrefixMap_t const factors{PrefixValue_t{"a"s, 1e-18},
                                   PrefixValue_t{"f"s, 1e-15},
                                   PrefixValue_t{"p"s, 1e-12},
                                   PrefixValue_t{"n"s, 1e-09},
                                   PrefixValue_t{"u"s, 1e-06},
                                   PrefixValue_t{"m"s, 1e-03},
                                   PrefixValue_t{"c"s, 1e-02},
                                   PrefixValue_t{"d"s, 1e-01},
                                   PrefixValue_t{""s, 1e+00},
                                   PrefixValue_t{"da"s, 1e+01},
                                   PrefixValue_t{"h"s, 1e+02},
                                   PrefixValue_t{"k"s, 1e+03},
                                   PrefixValue_t{"M"s, 1e+06},
                                   PrefixValue_t{"G"s, 1e+09},
                                   PrefixValue_t{"T"s, 1e+12},
                                   PrefixValue_t{"P"s, 1e+15},
                                   PrefixValue_t{"E"s, 1e+18}}; // factors
  static auto const composePrefixPattern = [](auto b, auto e) -> std::string {
    std::string pattern = "(";
    if (b != e) {
      pattern += b->first;
      while (++b != e) {
        pattern += '|';
        pattern += b->first;
      }
    }
    return pattern += ")";
  };
  static std::string const prefixPattern = composePrefixPattern(factors.begin(), factors.end());
  // --- END -- static initialization ------------------------------------------

  std::regex const unitPattern{"[[:blank:]]*(" + prefixPattern + "?" +
                               util::to_string(baseunit_t::symbol) + ")[[:blank:]]*$"};

  std::smatch unitMatch;
  if (!std::regex_search(str, unitMatch, unitPattern)) {
    if (!unitOptional) {
      throw MissingUnit("Unit is mandatory and must derive from '" +
                        util::to_string(baseunit_t::symbol) + "' (parsing: '" + str + "')");
    }
    return {str, value_t{1}};
  }

  //
  // we do have a unit:
  //

  // " 7 cm " => [0] full match (" cm ") [1] unit ("cm") [2] unit prefix ("c")
  auto const iFactor = factors.find(unitMatch.str(2U));
  if (iFactor == factors.end()) {
    throw InvalidUnitPrefix("Unit '" + unitMatch.str(1U) + "' has unsupported prefix '" +
                            unitMatch.str(2U) + "' (parsing '" + str + "')");
  }

  return {str.substr(0U, str.length() - unitMatch.length()),
          static_cast<value_t>(unit_t::scale(iFactor->second))};

} // util::quantities::details::readUnit()