Class template quantity

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> 
    explicit quantity(const quantity< Unit, YY > &, unspecified = 0);
  template<typename Unit2, typename YY> 
    explicit quantity(const quantity< Unit2, YY > &, unspecified = 0);
  template<typename Unit2, typename YY> 
    quantity(const quantity< Unit2, YY > &, unspecified = 0);
  explicit 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

```
quantity();
```

quantity(unspecified_null_pointer_constant_type);

```
quantity(const this_type & source);
```

template<typename YY> 
  quantity(const quantity< Unit, YY > & source, unspecified = 0);

implicit conversion between value types is allowed if allowed for value types themselves

template<typename YY> 
  explicit quantity(const quantity< Unit, YY > & source, unspecified = 0);

implicit conversion between value types is not allowed if not allowed for value types themselves

template<typename Unit2, typename YY> 
  explicit quantity(const quantity< Unit2, YY > & source, unspecified = 0);

explicit conversion between different unit systems is allowed if implicit conversion is disallowed

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

explicit quantity(const value_type & val, int);

quantity& operator=(const this_type & source);

template<typename YY> quantity& operator=(const quantity< Unit, YY > & source);

implicit assignment between value types is allowed if allowed for value types themselves

```
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

`quantity` private member functions

```
 BOOST_MPL_ASSERT_NOT(unspecified);
```

`quantity` public member functions

```
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
```
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

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

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

```
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
```
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

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

`quantity` public static functions

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

Specializations

Class template quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y>