Edit: /usr/include/boost/units/absolute.hpp (5540B)
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
///
/// \file
/// \brief Absolute units (points rather than vectors).
/// \details Operations between absolute units, and relative units like temperature differences.
///
#ifndef BOOST_UNITS_ABSOLUTE_HPP
#define BOOST_UNITS_ABSOLUTE_HPP
#include
#include
namespace boost {
namespace units {
/// A wrapper to represent absolute units (points rather than vectors). Intended
/// originally for temperatures, this class implements operators for absolute units
/// so that addition of a relative unit to an absolute unit results in another
/// absolute unit : absolute +/- T -> absolute and subtraction of one absolute
/// unit from another results in a relative unit : absolute - absolute -> T.
template
class absolute
{
public:
typedef absolute this_type;
typedef Y value_type;
BOOST_CONSTEXPR absolute() : val_() { }
BOOST_CONSTEXPR absolute(const value_type& val) : val_(val) { }
BOOST_CONSTEXPR absolute(const this_type& source) : val_(source.val_) { }
BOOST_CXX14_CONSTEXPR this_type& operator=(const this_type& source) { val_ = source.val_; return *this; }
BOOST_CONSTEXPR const value_type& value() const { return val_; }
BOOST_CXX14_CONSTEXPR const this_type& operator+=(const value_type& val) { val_ += val; return *this; }
BOOST_CXX14_CONSTEXPR const this_type& operator-=(const value_type& val) { val_ -= val; return *this; }
private:
value_type val_;
};
/// add a relative value to an absolute one
template
BOOST_CONSTEXPR absolute operator+(const absolute& aval,const Y& rval)
{
return absolute(aval.value()+rval);
}
/// add a relative value to an absolute one
template
BOOST_CONSTEXPR absolute operator+(const Y& rval,const absolute& aval)
{
return absolute(aval.value()+rval);
}
/// subtract a relative value from an absolute one
template
BOOST_CONSTEXPR absolute operator-(const absolute& aval,const Y& rval)
{
return absolute(aval.value()-rval);
}
/// subtracting two absolutes gives a difference
template
BOOST_CONSTEXPR Y operator-(const absolute& aval1,const absolute& aval2)
{
return Y(aval1.value()-aval2.value());
}
/// creates a quantity from an absolute unit and a raw value
template
BOOST_CONSTEXPR quantity >, T> operator*(const T& t, const absolute >&)
{
return(quantity >, T>::from_value(t));
}
/// creates a quantity from an absolute unit and a raw value
template
BOOST_CONSTEXPR quantity >, T> operator*(const absolute >&, const T& t)
{
return(quantity >, T>::from_value(t));
}
/// Print an absolute unit
template
std::basic_ostream& operator<<(std::basic_ostream& os,const absolute& aval)
{
os << "absolute " << aval.value();
return os;
}
} // namespace units
} // namespace boost
#if BOOST_UNITS_HAS_BOOST_TYPEOF
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::absolute, (class))
#endif
namespace boost {
namespace units {
/// Macro to define the offset between two absolute units.
/// Requires the value to be in the destination units e.g
/// @code
/// BOOST_UNITS_DEFINE_CONVERSION_OFFSET(celsius_base_unit, fahrenheit_base_unit, double, 32.0);
/// @endcode
/// @c BOOST_UNITS_DEFINE_CONVERSION_FACTOR is also necessary to
/// specify the conversion factor. Like @c BOOST_UNITS_DEFINE_CONVERSION_FACTOR
/// this macro defines both forward and reverse conversions so
/// defining, e.g., the conversion from celsius to fahrenheit as above will also
/// define the inverse conversion from fahrenheit to celsius.
#define BOOST_UNITS_DEFINE_CONVERSION_OFFSET(From, To, type_, value_) \
namespace boost { \
namespace units { \
template<> \
struct affine_conversion_helper< \
reduce_unit::type, \
reduce_unit::type> \
{ \
BOOST_STATIC_CONSTEXPR bool is_defined = true; \
typedef type_ type; \
static BOOST_CONSTEXPR type value() { return(value_); } \
}; \
} \
} \
void boost_units_require_semicolon()
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_ABSOLUTE_HPP