#ifndef _DATE_TIME_WRAPPING_INT_HPP__ | |
#define _DATE_TIME_WRAPPING_INT_HPP__ | |
/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc. | |
* Use, modification and distribution is subject to the | |
* Boost Software License, Version 1.0. (See accompanying | |
* file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) | |
* Author: Jeff Garland, Bart Garst | |
* $Date: 2008-11-12 14:37:53 -0500 (Wed, 12 Nov 2008) $ | |
*/ | |
namespace boost { | |
namespace date_time { | |
//! A wrapping integer used to support time durations (WARNING: only instantiate with a signed type) | |
/*! In composite date and time types this type is used to | |
* wrap at the day boundary. | |
* Ex: | |
* A wrapping_int<short, 10> will roll over after nine, and | |
* roll under below zero. This gives a range of [0,9] | |
* | |
* NOTE: it is strongly recommended that wrapping_int2 be used | |
* instead of wrapping_int as wrapping_int is to be depricated | |
* at some point soon. | |
* | |
* Also Note that warnings will occur if instantiated with an | |
* unsigned type. Only a signed type should be used! | |
*/ | |
template<typename int_type_, int_type_ wrap_val> | |
class wrapping_int { | |
public: | |
typedef int_type_ int_type; | |
//typedef overflow_type_ overflow_type; | |
static int_type wrap_value() {return wrap_val;} | |
//!Add, return true if wrapped | |
wrapping_int(int_type v) : value_(v) {}; | |
//! Explicit converion method | |
int_type as_int() const {return value_;} | |
operator int_type() const {return value_;} | |
//!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 */ | |
template< typename IntT > | |
IntT add(IntT v) | |
{ | |
int_type remainder = static_cast<int_type>(v % (wrap_val)); | |
IntT overflow = static_cast<IntT>(v / (wrap_val)); | |
value_ = static_cast<int_type>(value_ + remainder); | |
return calculate_wrap(overflow); | |
} | |
//! 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 (positive indicates wrap under, negative indicates wrap over). | |
* Ex: subtract a negative number and wrapping over could | |
* occur, this would be indicated by a negative return value. If | |
* wrapping under took place, a positive value would be returned. */ | |
template< typename IntT > | |
IntT subtract(IntT v) | |
{ | |
int_type remainder = static_cast<int_type>(v % (wrap_val)); | |
IntT underflow = static_cast<IntT>(-(v / (wrap_val))); | |
value_ = static_cast<int_type>(value_ - remainder); | |
return calculate_wrap(underflow) * -1; | |
} | |
private: | |
int_type value_; | |
template< typename IntT > | |
IntT calculate_wrap(IntT wrap) | |
{ | |
if ((value_) >= wrap_val) | |
{ | |
++wrap; | |
value_ -= (wrap_val); | |
} | |
else if(value_ < 0) | |
{ | |
--wrap; | |
value_ += (wrap_val); | |
} | |
return wrap; | |
} | |
}; | |
//! A wrapping integer used to wrap around at the top (WARNING: only instantiate with a signed type) | |
/*! Bad name, quick impl to fix a bug -- fix later!! | |
* This allows the wrap to restart at a value other than 0. | |
*/ | |
template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max> | |
class wrapping_int2 { | |
public: | |
typedef int_type_ int_type; | |
static int_type wrap_value() {return wrap_max;} | |
static int_type min_value() {return wrap_min;} | |
/*! If initializing value is out of range of [wrap_min, wrap_max], | |
* value will be initialized to closest of min or max */ | |
wrapping_int2(int_type v) : value_(v) { | |
if(value_ < wrap_min) | |
{ | |
value_ = wrap_min; | |
} | |
if(value_ > wrap_max) | |
{ | |
value_ = wrap_max; | |
} | |
} | |
//! Explicit converion method | |
int_type as_int() const {return value_;} | |
operator int_type() const {return value_;} | |
//!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 */ | |
template< typename IntT > | |
IntT add(IntT v) | |
{ | |
int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1)); | |
IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1)); | |
value_ = static_cast<int_type>(value_ + remainder); | |
return calculate_wrap(overflow); | |
} | |
//! 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 */ | |
template< typename IntT > | |
IntT subtract(IntT v) | |
{ | |
int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1)); | |
IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1))); | |
value_ = static_cast<int_type>(value_ - remainder); | |
return calculate_wrap(underflow); | |
} | |
private: | |
int_type value_; | |
template< typename IntT > | |
IntT calculate_wrap(IntT wrap) | |
{ | |
if ((value_) > wrap_max) | |
{ | |
++wrap; | |
value_ -= (wrap_max - wrap_min + 1); | |
} | |
else if((value_) < wrap_min) | |
{ | |
--wrap; | |
value_ += (wrap_max - wrap_min + 1); | |
} | |
return wrap; | |
} | |
}; | |
} } //namespace date_time | |
#endif | |