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 1569 of file quantities.h.

{
  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()