//

// Units.h

//

// $Id: //poco/1.4/Util/include/Poco/Util/Units.h#1 $

//

// Library: Util

// Package: Units

// Module: Units

//

// Definitions for the C++ Units library.

//

// Copyright (c) 2007-2010, Applied Informatics Software Engineering GmbH.

// and Contributors.

//

// SPDX-License-Identifier: BSL-1.0

//

// Adapted for POCO from the following source:

//

// C++ Units by Calum Grant

//

// Written by Calum Grant

// Copyright (C) Calum Grant 2007

//

// Home page: http://calumgrant.net/units

// File location: http://calumgrant.net/units/units.hpp

// Manual: http://calumgrant.net/units/units.html

//

// Copying permitted under the terms of the Boost software license.

//

#ifndef Util_Units_INCLUDED

#define Util_Units_INCLUDED

#include "Poco/Util/Util.h"

#include <cmath>

namespace Poco {

namespace Util {

namespace Units {

namespace Internal

{

template <typename T1, typename T2> struct Convert;

struct None;

template <int Num, int Den, int Div=Num/Den, int Mod=Num%Den>

struct FixedPower;

}

template <typename Unit1, typename Unit2>

struct Compose;

/// Construct a unit equivalent to Unit1*Unit2

template <typename U, int Num, int Den = 1>

struct Scale;

/// Constructs a unit equivalent to U*Num/Den

template <typename U, int Num, int Den = 1>

struct Translate;

/// Constructs a Unit equivalent to U+Num/Den

template <typename U, int Num, int Den = 1>

struct Power;

/// Constructs a Unit equivalent to U^(Num/Den)

typedef Power<Internal::None, 0> Unit;

/// A unit which is effectively no units at all.

template <typename V, typename U>

class Value

/// A Value with a unit.

/// - V is the type you are storing

/// - U is the unit of the Value

///

/// This class is usually not used directly;

/// client code should use the typedef'd

/// instantiations defined in the Values and

/// Constants namespace.

///

/// Example:

///

/// using namespace Poco::Util::Units::Values;

///

/// std::cout << "One mile is " << km(mile(1)) << std::endl;

/// // Output: One mile is 1.60934 km

///

/// std::cout << "Flow rate is " << m3(mile(1)*inch(80)*foot(9))/s(minute(5));

/// // Output: Flow rate is 29.9026 (m)^3.(s)^-1

///

/// hours h;

/// h = cm(3); // Compile-time error: incompatible units

/// h = 4; // Compile-time error: 4 of what?

/// h = days(4); // Ok: h is 96 hours

{

public:

typedef V ValueType;

typedef U Unit;

Value(): _rep()

{

}

explicit Value(const ValueType& v): _rep(v)

{

}

template <typename OV, typename OU>

Value(const Value<OV, OU>& v):

_rep(Internal::Convert<OU, U>::fn(v.get()))

{

}

const ValueType& get() const

{

return _rep;

}

template <typename OV, typename OU>

Value& operator = (const Value<OV, OU>& other)

{

_rep = Value(other).get();

return *this;

}

template <typename OV, typename OU>

Value operator + (const Value<OV, OU>& other) const

{

return Value(get() + Value(other).get());

}

template <typename OV, typename OU>

Value& operator += (const Value<OV, OU>& other)

{

_rep += Value(other).get();

return *this;

}

template <typename OV, typename OU>

Value& operator -= (const Value<OV, OU>& other)

{

_rep -= Value(other).get();

return *this;

}

template <typename OV, typename OU>

Value operator - (const Value<OV, OU>& other) const

{

return Value(get() - Value(other).get());

}

Value operator - () const

{

return Value(-get());

}

template <typename OV, typename OU>

Value<V, Compose<U, OU> >

operator * (const Value<OV, OU>& other) const

{

return Value<V, Compose<U, OU> >(get() * other.get());

}

Value operator * (const ValueType& v) const

{

return Value(get() * v);

}

Value& operator *= (const ValueType& v)

{

_rep *= v;

return *this;

}

template <typename OV, typename OU>

Value<V, Compose<U, Power<OU, -1> > > operator / (const Value<OV, OU>& other) const

{

return Value<V, Compose<U, Power<OU, -1> > >(get() / other.get());

}

Value operator / (const ValueType& v) const

{

return Value(get() / v);

}

Value& operator /= (const ValueType& v)

{

_rep /= v;

return *this;

}

template <typename OV, typename OU>

bool operator == (const Value<OV, OU>& other) const

{

return get() == Value(other).get();

}

template <typename OV, typename OU>

bool operator != (const Value<OV, OU>& other) const

{

return get() != Value(other).get();

}

template <typename OV, typename OU>

bool operator < (const Value<OV, OU>& other) const

{

return get() < Value(other).get();

}

template <typename OV, typename OU>

bool operator <= (const Value<OV, OU>& other) const

{

return get() <= Value(other).get();

}

template <typename OV, typename OU>

bool operator > (const Value<OV, OU>& other) const

{

return get() > Value(other).get();

}

template <typename OV, typename OU>

bool operator >= (const Value<OV, OU>& other) const

{

return get() >= Value(other).get();

}

Value& operator ++ ()

{

++_rep;

return *this;

}

Value operator ++ (int)

{

Value v = *this;

++_rep;

return v;

}

Value& operator -- ()

{

--_rep;

return *this;

}

Value operator -- (int)

{

Value v = *this;

--_rep;

return v;

}

private:

ValueType _rep;

};

template <typename V, typename U>

Value<V, Power<U, -1> > operator / (const V& a, const Value<V, U>& b)

{

return Value<V, Power<U, -1> >(a / b.get());

}

template <typename V, typename U>

Value<V, U > operator * (const V& a, const Value<V, U>& b)

{

return Value<V, U>(a * b.get());

}

template <typename V, typename U>

Value<V, Power<U, 1, 2> > sqrt(const Value<V, U>& a)

{

return Value<V, Power<U, 1, 2> >(std::sqrt(a.get()));

}

template <typename V, typename U>

Value<V, Power<U, 2, 1> > square(const Value<V, U>& a)

{

return Value<V, Power<U, 2, 1> >(std::pow(a.get(), 2));

}

template <typename V, typename U>

Value<V, Power<U, 3, 1> > cube(const Value<V, U>& a)

{

return Value<V, Power<U, 3, 1> >(std::pow(a.get(), 3));

}

template <int Num, int Den, typename V, typename U>

Value<V, Power<U, Num, Den> > raise(const Value<V, U>& a)

{

return Value<V, Power<U, Num, Den> >(Internal::FixedPower<Num, Den>::Power(a.get()));

}

namespace Internal

{

template <typename T1, typename T2>

struct Convertible;

template <typename U>

struct ScalingFactor;

template <typename T1, typename T2>

struct Convert3

/// Converts T1 to T2.

/// Stage 3 - performed after Stage 1 and Stage 2.

/// The reason we perform Convert in stages is so that the compiler

/// can resolve templates in the order we want it to.

{

template <typename V>

static V fn(const V& v)

/// The default implementation assumes that the two quantities are in compatible

/// Units up to some scaling factor. Find the scaling factor and apply it.

{

return v * ScalingFactor<T2>::template fn<V>() / ScalingFactor<T1>::template fn<V>();

}

};

template <typename T1, typename T2>

struct Convert2

/// Converts T1 to T2.

/// Template matches the first argument (T1),

/// this is the fall-through to Convert3.

{

template <typename V>

static V fn(const V& v)

{

return Convert3<T1,T2>::fn(v);

}

};

template <typename T1, typename T2>

struct Convert

/// Converts T1 to T2.

/// If you really want to implement your own conversion routine,

/// specialize this template.

/// The default implementation falls through to Convert2.

{

/// If this fails, then T1 is not Convertible to T2:

poco_static_assert ((Convertible<T1,T2>::Value));

template <typename V>

static V fn(const V& v)

{

return Convert2<T1,T2>::fn(v);

}

};

template <typename T>

struct Convert<T, T>

// Trivial conversion to the same type.

{

template <typename U>

static const U& fn(const U& u) { return u; }

};

template <typename T>

struct Convert3<T, T>

// Convert to same type.

{

template <typename U>

static const U& fn(const U& u) { return u; }

};

template <typename T, typename U, int Num, int Den>

struct Convert2<Scale<T, Num, Den>, U>

// Convert from a scaled Unit.

{

template <typename V>

static V fn(const V& v)

{

return Convert<T, U>::fn((v * Den)/Num);

}

};

template <typename T, typename U, int Num, int Den>

struct Convert3<T, Scale<U, Num, Den> >

// Convert to a scaled Unit.

{

template <typename V>

static V fn(const V& v)

{

return (Convert<T, U>::fn(v) * Num)/ Den;

}

};

template <typename T, typename U, int Num, int Den>

struct Convert2<Translate<T, Num, Den>, U>

// Convert from a translated Unit.

{

template <typename V>

static V fn(const V& v)

{

return Convert<T, U>::fn(v - static_cast<V>(Num) / static_cast<V>(Den));

}

};

template <typename T, typename U, int Num, int Den>

struct Convert3<T, Translate<U, Num, Den> >

// Convert to a translated Unit.

{

template <typename V>

static V fn(const V& v)

{

return Convert<T, U>::fn(v) + static_cast<V>(Num) / static_cast<V>(Den);

}

};

template <typename Term, typename List>

struct CountTerms

/// Count the power to which Unit Term is raised in the Unit List.

/// Returns a rational num/den of the power of term Term in List.

/// The default assumes that Term is not found (num/den=0).

{

static const int num = 0;

static const int den = 1;

};

template <typename Term>

struct CountTerms<Term, Term>

{

static const int num = 1;

static const int den = 1;

};

template <typename Term, typename U, int N, int D>

struct CountTerms<Term, Scale<U, N, D> >

// CountTerms ignores scaling factors - that is taken care of by ScalingFactor.

{

typedef CountTerms<Term, U> result;

static const int num = result::num;

static const int den = result::den;

};

template <typename Term, typename U, int N, int D>

struct CountTerms<Term, Translate<U, N, D> >

// CountTerms ignores translation.

{

typedef CountTerms<Term, U> result;

static const int num = result::num;

static const int den = result::den;

};

template <typename Term, typename T1, typename T2>

struct CountTerms<Term, Compose<T1,T2> >

// Addition of fractions.

{

typedef CountTerms<Term, T1> result1;

typedef CountTerms<Term, T2> result2;

static const int num = result1::num * result2::den + result1::den * result2::num;

static const int den = result1::den * result2::den;

};

template <typename Term, typename U, int N, int D>

struct CountTerms<Term, Power<U, N, D> >

// Multiplication of fractions.

{

typedef CountTerms<Term, U> result;

static const int num = N * result::num;

static const int den = D * result::den;

};

template <typename Term, typename T1, typename T2>

struct CheckTermsEqual

/// Counts the power of the Unit Term in Units T1 and T2.

/// Reports if they are equal, using equality of fractions.

/// Does a depth-first search of the Unit "Term",

/// or counts the terms in the default case.

{

typedef CountTerms<Term, T1> count1;

typedef CountTerms<Term, T2> count2;

static const bool Value =

count1::num * count2::den ==

count1::den * count2::num;

};

template <typename U, int N, int D, typename T1, typename T2>

struct CheckTermsEqual<Power<U, N, D>, T1, T2 >

{

static const bool Value = CheckTermsEqual<U, T1, T2>::Value;

};

template <typename U, int N, int D, typename T1, typename T2>

struct CheckTermsEqual<Scale<U, N, D>, T1, T2 >

{

static const bool Value = CheckTermsEqual<U, T1, T2>::Value;

};

template <typename U, int N, int D, typename T1, typename T2>

struct CheckTermsEqual<Translate<U, N, D>, T1, T2 >

{

static const bool Value = CheckTermsEqual<U, T1, T2>::Value;

};

template <typename T1, typename T2, typename T3, typename T4>

struct CheckTermsEqual<Compose<T1,T2>,T3,T4>

{

static const bool Value =

CheckTermsEqual<T1, T3, T4>::Value &&

CheckTermsEqual<T2, T3, T4>::Value;

};

template <typename T1, typename T2>

struct Convertible

/// Determines whether two types are Convertible.

/// Counts the powers in the LHS and RHS and ensures they are equal.

{

static const bool Value =

CheckTermsEqual<T1,T1,T2>::Value &&

CheckTermsEqual<T2,T1,T2>::Value;

};

template <int Num, int Den, int Div, int Mod>

struct FixedPower

/// A functor that raises a Value to the power Num/Den.

/// The template is specialised for efficiency

/// so that we don't always have to call the std::power function.

{

template <typename T> static T Power(const T& t)

{

return std::pow(t, static_cast<T>(Num)/static_cast<T>(Den));

}

};

template <int N, int D>

struct FixedPower<N, D, 1, 0>

{

template <typename T> static const T& Power(const T& t)

{

return t;

}

};

template <int N, int D>

struct FixedPower<N, D, 2, 0>

{

template <typename T> static T Power(const T& t)

{

return t*t;

}

};

template <int N, int D>

struct FixedPower<N, D, 3, 0>

{

template <typename T> static T Power(const T& t)

{

return t*t*t;

}

};

template <int N, int D>

struct FixedPower<N, D, 4, 0>

{

template <typename T> static const T& Power(const T& t)

{

T u = t*t;

return u*u;

}

};

template <int N, int D>

struct FixedPower<N, D, -1, 0>

{

template <typename T> static T Power(const T& t)

{

return 1/t;

}

};

template <int N, int D>

struct FixedPower<N, D, -2, 0>

{

template <typename T> static T Power(const T& t)

{

return 1/(t*t);

}

};

template <int N, int D>

struct FixedPower<N, D, 0, 0>

{

template <typename T> static T Power(const T& t)

{

return 1;

}

};

template <typename U>

struct ScalingFactor

/// Determine the scaling factor of a Unit in relation to its "base" Units.

/// Default is that U is a primitive Unit and is not scaled.

{

template <typename T>

static T fn() { return 1; }

};

template <typename U1, typename U2>

struct ScalingFactor< Compose<U1, U2> >

{

template <typename T>

static T fn()

{

return

ScalingFactor<U1>::template fn<T>() *

ScalingFactor<U2>::template fn<T>();

}

};

template <typename U, int N, int D>

struct ScalingFactor< Scale<U, N, D> >

{

template <typename T>

static T fn()

{

return

ScalingFactor<U>::template fn<T>() *

static_cast<T>(N) / static_cast<T>(D);

}

};

template <typename U, int N, int D>

struct ScalingFactor< Power<U, N, D> >

{

template <typename T>

static T fn()

{

return FixedPower<N, D>::Power(ScalingFactor<U>::template fn<T>());

}

};

template <typename U, int N, int D>

struct ScalingFactor< Translate<U, N, D> >

{

template <typename T>

static T fn()

{

return ScalingFactor<U>::template fn<T>();

}

};

} // namespace Internal

///

/// Display

///

#define UNIT_DISPLAY_NAME(Unit, string) \

template <> \

struct OutputUnit<Unit> \

{ \

template <typename Stream> \

static void fn(Stream& os) \

{ \

os << string; \

} \

}

namespace Internal

{

template <typename U>

struct OutputUnit2

/// The default Unit formatting mechanism.

{

template <typename Stream>

static void fn(Stream &os)

{

os << "Units";

}

};

}

template <typename U>

struct OutputUnit

/// Functor to write Unit text to stream.

{

template <typename Stream>

static void fn(Stream &os)

{

Internal::OutputUnit2<U>::fn(os);

}

};

UNIT_DISPLAY_NAME(Unit, "1");

namespace Internal

{

template <typename U1, typename U2>

struct OutputUnit2< Compose<U1,U2> >

{

template <typename Stream>

static void fn(Stream &os)

{

OutputUnit<U1>::fn(os);

os << '.';

OutputUnit<U2>::fn(os);

}

};

template <typename U, int Num, int Den>

struct OutputUnit2< Power<U, Num, Den > >

{

template <typename Stream>

static void fn(Stream &os)

{

if(Num!=Den) os << '(';

OutputUnit<U>::fn(os);

if(Num!=Den)

{

os << ')';

os << '^' << Num;

if(Num%Den)

{

os << '/' << Den;

}

}

}

};

template <typename U, int Num, int Den>

struct OutputUnit2< Translate<U, Num, Den > >

{

template <typename Stream>

static void fn(Stream &os)

{

os << '(';

OutputUnit<U>::fn(os);

os << '+' << Num;

if(Den!=1) os << '/' << Den;

os << ')';

}

};

template <typename U, int Num, int Den>

struct OutputUnit2< Scale<U, Num, Den > >

{

template <typename Stream>

static void fn(Stream &os)

{

os << Den;

if(Num != 1)

os << '/' << Num;

os << '.';

OutputUnit<U>::fn(os);

}

};

} // namespace Internal

template <typename Str, typename V, typename U>

Str& operator << (Str& os, const Value<V, U>& value)

{

os << value.get() << ' ';

OutputUnit<U>::fn(os);

return os;

}

///

/// Additional Units

///

namespace Units

{

typedef Poco::Util::Units::Unit Unit;

// SI base Units:

struct m; /// meter

struct kg; /// kilogram

struct s; /// second

struct K; /// Kelvin

struct A; /// Ampere

struct mol; /// mole

struct cd; /// candela

}

UNIT_DISPLAY_NAME(Units::m, "m");

UNIT_DISPLAY_NAME(Units::kg, "kg");

UNIT_DISPLAY_NAME(Units::s, "s");

UNIT_DISPLAY_NAME(Units::K, "K");

UNIT_DISPLAY_NAME(Units::A, "A");

UNIT_DISPLAY_NAME(Units::mol, "mol");

UNIT_DISPLAY_NAME(Units::cd, "cd");

namespace Units

{

// SI derived Units:

typedef Compose<m, Power<m, -1> > rad;

typedef Compose<Power<m, 2>, Power<m, -2> > sr;

typedef Power<s, -1> Hz;

typedef Compose<m, Compose<kg, Power<s, -2> > > N;

typedef Compose<N, Power<m, -2> > Pa;

typedef Compose<N, m> J;

typedef Compose<J, Power<s, -1> > W;

typedef Compose<s, A> C;

typedef Compose<W, Power<A, -1> > V;

typedef Compose<C, Power<V, -1> > F;

typedef Compose<V, Power<A, -1> > Ohm;

typedef Compose<A, Power<V, -1> > S;

typedef Compose<V, s> Wb;

typedef Compose<Wb, Power<m, -2> > T;

typedef Compose<Wb, Power<A, -1> > H;

typedef cd lm;

typedef Compose<lm, Power<m, -2> > lx;

typedef Power<s, -1> Bq;

typedef Compose<J, Power<kg, -1> > Gy;

typedef Gy Sv;

typedef Compose<Power<s, -1>,mol> kat;

}

UNIT_DISPLAY_NAME(Units::rad, "rad");

UNIT_DISPLAY_NAME(Units::sr, "sr");

// UNIT_DISPLAY_NAME(Units::Hz, "Hz"); // Too problematic

UNIT_DISPLAY_NAME(Units::N, "N");

UNIT_DISPLAY_NAME(Units::Pa, "Pa");

UNIT_DISPLAY_NAME(Units::J, "J");

UNIT_DISPLAY_NAME(Units::W, "W");

UNIT_DISPLAY_NAME(Units::C, "C");

UNIT_DISPLAY_NAME(Units::V, "V");

UNIT_DISPLAY_NAME(Units::F, "F");

UNIT_DISPLAY_NAME(Units::Ohm, "Ohm");

UNIT_DISPLAY_NAME(Units::S, "S");

UNIT_DISPLAY_NAME(Units::Wb, "Wb");

UNIT_DISPLAY_NAME(Units::T, "T");

UNIT_DISPLAY_NAME(Units::H, "H");

UNIT_DISPLAY_NAME(Units::lx, "lx");

UNIT_DISPLAY_NAME(Units::Gy, "Gy");

UNIT_DISPLAY_NAME(Units::kat, "kat");

namespace Units

{

// SI prefixes:

template <typename U> struct deca { typedef Scale<U, 1, 10> type; };

template <typename U> struct hecto { typedef Scale<U, 1, 100> type; };

template <typename U> struct kilo { typedef Scale<U, 1, 1000> type; };

template <typename U> struct mega { typedef Scale<typename kilo<U>::type, 1, 1000> type; };

template <typename U> struct giga { typedef Scale<typename mega<U>::type, 1, 1000> type; };

template <typename U> struct tera { typedef Scale<typename giga<U>::type, 1, 1000> type; };

template <typename U> struct peta { typedef Scale<typename tera<U>::type, 1, 1000> type; };

template <typename U> struct exa { typedef Scale<typename peta<U>::type, 1, 1000> type; };

template <typename U> struct zetta { typedef Scale<typename exa<U>::type, 1, 1000> type; };

template <typename U> struct yotta { typedef Scale<typename zetta<U>::type, 1, 1000> type; };

template <typename U> struct deci { typedef Scale<U, 10> type; };

template <typename U> struct centi { typedef Scale<U, 100> type; };

template <typename U> struct milli { typedef Scale<U, 1000> type; };

template <typename U> struct micro { typedef Scale<typename milli<U>::type, 1000> type; };

template <typename U> struct nano { typedef Scale<typename micro<U>::type, 1000> type; };

template <typename U> struct pico { typedef Scale<typename nano<U>::type, 1000> type; };

template <typename U> struct femto { typedef Scale<typename pico<U>::type, 1000> type; };

template <typename U> struct atto { typedef Scale<typename femto<U>::type, 1000> type; };

template <typename U> struct zepto { typedef Scale<typename atto<U>::type, 1000> type; };

template <typename U> struct yocto { typedef Scale<typename zepto<U>::type, 1000> type; };

// Some prefixed SI Units:

typedef centi<m>::type cm;

typedef milli<m>::type mm;

typedef kilo<m>::type km;

typedef milli<kg>::type g;

typedef milli<g>::type mg;

typedef milli<s>::type ms;

class Prefix

/// Parent class for unit prefixes.

/// Use classes inheriting from this class to scale

/// the values.

{

public:

template <typename T>

Prefix(const T& val, double multiplier = 1, const std::string& prefix = ""):

_pHolder(new Holder<T>(val)),

_multiplier(multiplier),

_prefix(prefix)

{

}

double value() const

{

return _pHolder->get() * _multiplier;

}

void addPrefix(std::ostream& os) const

{

os << _prefix;

}

void addUnit(std::ostream& os) const

{

_pHolder->appendUnit(os);

}

private:

Prefix();

class Placeholder

{

public:

virtual ~Placeholder() { }

virtual double get() const = 0;

virtual void appendUnit(std::ostream& os) const = 0;

};

template <typename U>

struct Holder : public Placeholder

{

typedef Value<typename U::ValueType, typename U::Unit> ValueType;

Holder (const U& val): _val(ValueType(val))

{

}

double get() const

{

return _val.get();

}

void appendUnit(std::ostream& os) const

{

OutputUnit<typename U::Unit>::fn(os);

}

ValueType _val;

};

Placeholder* _pHolder;

double _multiplier;

std::string _prefix;

};

}

template <typename Str>

Str& streamOp (Str& os, const Units::Prefix& val)

{

os << val.value() << ' ';

val.addPrefix(os);

val.addUnit(os);

return os;

}

template <typename Str>

Str& operator << (Str& os, const Units::Prefix& val)

/// Streaming operator for prefixed values.

{

return streamOp(os, val);

}

UNIT_DISPLAY_NAME(Units::cm, "cm");

UNIT_DISPLAY_NAME(Units::mm, "mm");

UNIT_DISPLAY_NAME(Units::km, "km");

UNIT_DISPLAY_NAME(Units::g, "g");

UNIT_DISPLAY_NAME(Units::mg, "mg");

UNIT_DISPLAY_NAME(Units::ms, "ms");

namespace Units

{

// Non-SI mass

typedef Scale<kg, 22046223, 10000000> lb;

typedef Scale<lb, 16> oz;

typedef Scale<kg, 1, 1000> tonne;

// Non-SI temperature

typedef Translate<K, -27315, 100> Celsius;

typedef Translate<Scale<Celsius, 9, 5>, 32> Fahrenheit;

// Non-SI time

typedef Scale<s, 1, 60> minute;

typedef Scale<minute, 1, 60> hour;

typedef Scale<hour, 1, 24> day;