| // 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 <iosfwd> |
| |
| #include <boost/units/detail/absolute_impl.hpp> |
| |
| 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> +/- T -> absolute<T> and subtraction of one absolute |
| /// unit from another results in a relative unit : absolute<T> - absolute<T> -> T. |
| template<class Y> |
| class absolute |
| { |
| public: |
| typedef absolute<Y> this_type; |
| typedef Y value_type; |
| |
| absolute() : val_() { } |
| absolute(const value_type& val) : val_(val) { } |
| absolute(const this_type& source) : val_(source.val_) { } |
| |
| this_type& operator=(const this_type& source) { val_ = source.val_; return *this; } |
| |
| const value_type& value() const { return val_; } |
| |
| const this_type& operator+=(const value_type& val) { val_ += val; return *this; } |
| 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<class Y> |
| absolute<Y> operator+(const absolute<Y>& aval,const Y& rval) |
| { |
| return absolute<Y>(aval.value()+rval); |
| } |
| |
| /// add a relative value to an absolute one |
| template<class Y> |
| absolute<Y> operator+(const Y& rval,const absolute<Y>& aval) |
| { |
| return absolute<Y>(aval.value()+rval); |
| } |
| |
| /// subtract a relative value from an absolute one |
| template<class Y> |
| absolute<Y> operator-(const absolute<Y>& aval,const Y& rval) |
| { |
| return absolute<Y>(aval.value()-rval); |
| } |
| |
| /// subtracting two absolutes gives a difference |
| template<class Y> |
| Y operator-(const absolute<Y>& aval1,const absolute<Y>& aval2) |
| { |
| return Y(aval1.value()-aval2.value()); |
| } |
| |
| /// creates a quantity from an absolute unit and a raw value |
| template<class D, class S, class T> |
| quantity<absolute<unit<D, S> >, T> operator*(const T& t, const absolute<unit<D, S> >&) |
| { |
| return(quantity<absolute<unit<D, S> >, T>::from_value(t)); |
| } |
| |
| /// creates a quantity from an absolute unit and a raw value |
| template<class D, class S, class T> |
| quantity<absolute<unit<D, S> >, T> operator*(const absolute<unit<D, S> >&, const T& t) |
| { |
| return(quantity<absolute<unit<D, S> >, T>::from_value(t)); |
| } |
| |
| /// Print an absolute unit |
| template<class Char, class Traits, class Y> |
| std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,const absolute<Y>& 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<From::unit_type>::type, \ |
| reduce_unit<To::unit_type>::type> \ |
| { \ |
| static const bool is_defined = true; \ |
| typedef type_ type; \ |
| static type value() { return(value_); } \ |
| }; \ |
| } \ |
| } \ |
| void boost_units_require_semicolon() |
| |
| } // namespace units |
| |
| } // namespace boost |
| |
| #endif // BOOST_UNITS_ABSOLUTE_HPP |