C:/Work/specialnumbers_svn/NumberLib/NumbersLib/RangedNumber.h

Go to the documentation of this file.

#ifndef _RANGED_NUMBER_H
#define _RANGED_NUMBER_H

#include "numbers.h"

namespace luma
{
namespace numbers
{

template <class T>
class RangedNumber
{
protected:
    T mValue;
   T mMin;
   T mMax;
   T mIncrement;

public:
   RangedNumber(T value, T min, T max, T increment);

   virtual RangedNumber& operator=(const RangedNumber<T>&);
   virtual RangedNumber& operator=(const T&);
   virtual void setIncrement(const T&);
   void setValue(const T& value) { mValue = getValidValue(value);}
   
   void modify(const T& max, const T& min, const T& increment);

   RangedNumber(const RangedNumber& other);


   virtual ~RangedNumber(){};

   virtual operator T() const;

   /*friend ostream& operator<<(ostream& os, const RangedNumber<T>& num)
   {
      os << num.mValue;
      return os;
   }*/

   virtual RangedNumber<T>& operator++() = 0;
   //virtual RangedNumber<T> operator++(int);

   virtual RangedNumber<T>& operator--() = 0;
   //virtual RangedNumber<T> operator--(int);

   virtual void inc(float elapsedTime = 1) = 0;
   virtual void dec(float elapsedTime = 1) = 0;

   const T& min() const;

   const T& max() const;

   const T& increment() const;

   virtual T getValidValue(const T& value) const = 0;

   T getValue() const;
};



template <class T>
RangedNumber<T>::RangedNumber(T value, T min, T max, T increment):
   mValue(value),
   mMin(min),
   mMax(max),
   mIncrement(increment)   
{
}

template <class T>
RangedNumber<T>::RangedNumber(const RangedNumber& other):
   mValue(other.mValue),
   mMin(other.mMin),
   mMax(other.mMax),
   mIncrement(other.mIncrement)
{
}

template <class T>
RangedNumber<T>& RangedNumber<T>::operator=(const RangedNumber<T>& other)
{
   modify(other.mMin, other.mMax, other.mIncrement);
   mValue = getValidValue(other.mValue);

   return *this;
}

template <class T>
RangedNumber<T>& RangedNumber<T>::operator=(const T& value)
{
   mValue = getValidValue(value);

   return *this;
}

template <class T>
const T& RangedNumber<T>::min() const
{
   return mMin;
}

template <class T>
const T& RangedNumber<T>::max() const
{
   return mMax;
}

template <class T>
const T& RangedNumber<T>::increment() const
{
   return mIncrement;
}

template <class T>
RangedNumber<T>::operator T() const
{
   return mValue;
}

template <class T>
void RangedNumber<T>::modify(const T& min, const T& max, const T& increment)
{
   mMin = min;
   mMax = max;
   mIncrement = increment;

   mValue = getValidValue(mValue);
}

template <class T>
void RangedNumber<T>::setIncrement(const T& increment)
{
   mIncrement = increment;
   mValue = getValidValue(mValue);
}

template <class T>
T RangedNumber<T>::getValue() const
{
   return mValue;
}

}} //namespace
#endif

---