| Home | Libraries | People | FAQ | More

## Class template wrapping_int2

boost::date_time::wrapping_int2 — A wrapping integer used to wrap around at the top (WARNING: only instantiate with a signed type)

## Synopsis

    // In header: <boost/date_time/wrapping_int.hpp>

    template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
    class wrapping_int2 {
    public:
      // types
      typedef int_type_ int_type;

      // construct/copy/destruct
      wrapping_int2(int_type);

      // public static functions
      static int_type wrap_value();
      static int_type min_value();

      // public member functions
      int_type as_int() const;
      operator int_type() const;
      template<typename IntT> IntT add(IntT);
      template<typename IntT> IntT subtract(IntT);

      // private member functions
      template<typename IntT> IntT calculate_wrap(IntT);
    };

## Description

Bad name, quick impl to fix a bug <ndash></ndash> fix later!! This allows the wrap to restart at a value other than 0.

### `wrapping_int2` public construct/copy/destruct

1.     wrapping_int2(int_type v);

   If initializing value is out of range of [wrap_min, wrap_max], value will be initialized to closest of min or max

### `wrapping_int2` public static functions

1.     static int_type wrap_value();

2.     static int_type min_value();

### `wrapping_int2` public member functions

1.     int_type as_int() const;

   Explicit converion method.

2.     operator int_type() const;

3.     template<typename IntT> IntT add(IntT v);

   Add, return number of wraps performed.

   The sign of the returned value will indicate which direction the wraps went. Ex: add a negative number and wrapping under could occur, this would be indicated by a negative return value. If wrapping over took place, a positive value would be returned

4.     template<typename IntT> IntT subtract(IntT v);

   Subtract will return '-d' if wrapping under took place ('d' is the number of wraps)

   The sign of the returned value will indicate which direction the wraps went. Ex: subtract a negative number and wrapping over could occur, this would be indicated by a positive return value. If wrapping under took place, a negative value would be returned

### `wrapping_int2` private member functions

1.     template<typename IntT> IntT calculate_wrap(IntT wrap);