CLASS TEMPLATE QU(3)

NAME
boost::units::quantity - class declaration

SYNOPSIS

// In header: <boost/units/quantity.hpp>
template<typename Unit, typename Y = double>
class quantity {
public:
  // types
  typedef quantity< Unit, Y > this_type;
  typedef Y                   value_type;
  typedef Unit                unit_type;
  // construct/copy/destruct
  quantity();
  quantity(unspecified_null_pointer_constant_type);
  quantity(const this_type &);
  template<typename YY>
    quantity(const quantity< Unit, YY > &, unspecified = 0);
  template<typename YY>
    quantity(const quantity< Unit, YY > &, unspecified = 0);
  template<typename Unit2, typename YY>
    quantity(const quantity< Unit2, YY > &, unspecified = 0);
  template<typename Unit2, typename YY>
    quantity(const quantity< Unit2, YY > &, unspecified = 0);
  quantity(const value_type &, int);
  quantity& operator=(const this_type &);
  template<typename YY> quantity& operator=(const quantity< Unit, YY > &);
  template<typename Unit2, typename YY>
    quantity& operator=(const quantity< Unit2, YY > &);
  // private member functions
   BOOST_MPL_ASSERT_NOT(unspecified);
  // public member functions
  const value_type & value() const;
  template<typename Unit2, typename YY>
    this_type & operator+=(const quantity< Unit2, YY > &);
  template<typename Unit2, typename YY>
    this_type & operator-=(const quantity< Unit2, YY > &);
  template<typename Unit2, typename YY>
    this_type & operator*=(const quantity< Unit2, YY > &);
  template<typename Unit2, typename YY>
    this_type & operator/=(const quantity< Unit2, YY > &);
  this_type & operator*=(const value_type &);
  this_type & operator/=(const value_type &);
  // public static functions
  static this_type from_value(const value_type &);
};

DESCRIPTION

  quantity public construct/copy/destruct

    1.

    quantity();

    2.

    quantity(unspecified_null_pointer_constant_type);

    3.

    quantity(const this_type & source);

    4.

    template<typename YY>
      quantity(const quantity< Unit, YY > & source, unspecified = 0);
    implicit conversion between value types is allowed if allowed for value types themselves .RE

        5.

        template<typename YY>
          quantity(const quantity< Unit, YY > & source, unspecified = 0);
        implicit conversion between value types is not allowed if not allowed for value types themselves .RE

            6.

            template<typename Unit2, typename YY>
              quantity(const quantity< Unit2, YY > & source, unspecified = 0);
            explicit conversion between different unit systems is allowed if implicit conversion is disallowed .RE

                7.

                template<typename Unit2, typename YY>
                  quantity(const quantity< Unit2, YY > & source, unspecified = 0);
                implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible .RE

                    8.

                    quantity(const value_type & val, int);

                    9.

                    quantity& operator=(const this_type & source);

                    10.

                    template<typename YY> quantity& operator=(const quantity< Unit, YY > & source);
                    implicit assignment between value types is allowed if allowed for value types themselves .RE

                        11.

                        template<typename Unit2, typename YY>
                          quantity& operator=(const quantity< Unit2, YY > & source);
                        implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible .RE

  quantity private member functions

    1.

     BOOST_MPL_ASSERT_NOT(unspecified);

  quantity public member functions

    1.

    const value_type & value() const;

    constant accessor to value can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type

    2.

    template<typename Unit2, typename YY>
      this_type & operator+=(const quantity< Unit2, YY > & source);
    can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type .RE

        3.

        template<typename Unit2, typename YY>
          this_type & operator-=(const quantity< Unit2, YY > & source);

        4.

        template<typename Unit2, typename YY>
          this_type & operator*=(const quantity< Unit2, YY > & source);

        5.

        template<typename Unit2, typename YY>
          this_type & operator/=(const quantity< Unit2, YY > & source);
        can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type .RE

            6.

            this_type & operator*=(const value_type & source);
            can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type .RE

                7.

                this_type & operator/=(const value_type & source);

  quantity public static functions

    1.

    static this_type from_value(const value_type & val);
    Construct quantity directly from value_type (potentially dangerous). .RE

  Specializations

    &#8226; Class template quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y>