#ifndef RANGED_NUM_H_INCLUDED
#define RANGED_NUM_H_INCLUDED


#define READJUST_VALUE(a, min, max) if(a < min) a = min; if(a > max) a = max


template <typename T> 
class RangedNum {
public:

	explicit RangedNum(T dat = 0, T min = 0, T max = 0) : Data(dat), Min(min), Max(max)
	{

	}

	explicit RangedNum(const RangedNum<T>& cpy)
	{
		Data = cpy.Data;
		Min = cpy.Min;
		Max = cpy.Max;
	}

	void SetMinimum(T min = 0)
	{
		Min = min;
		if(Min > Max) Min = Max;
		READJUST_VALUE(Data, Min, Max);
	}

	void SetMaximum(T max = 0) 
	{
		Max = max;
		if(Max < Min) Max = Min;
		READJUST_VALUE(Data, Min, Max);
	}

	void SetRanges(T min, T max)
	{
		Min = min;
		Max = max;
		if(Min > Max) Min = Max;
		READJUST_VALUE(Data, Min, Max);
	}

	operator T ()
	{
		return Data;
	}

	template <typename OpT>
	T& operator + (const OpT& arg)
	{
		Tmp = Data + Arg;
		READJUST_VALUE(Tmp, Min, Max);
		return Tmp;
	}

	template <typename OpT>
	T& operator += (const OpT& arg)
	{
		Data += arg;
		READJUST_VALUE(Data, Min, Max);
		return Data;
	}

	template <typename OpT>
	T& operator - (const OpT& arg)
	{
		Tmp = Data - Arg;
		READJUST_VALUE(Tmp, Min, Max);
		return Tmp;
	}

	template <typename OpT>
	T& operator -= (const OpT& arg)
	{
		Data -= arg;
		READJUST_VALUE(Data, Min, Max);
		return Data;
	}

	template <typename OpT>
	T& operator * (const OpT& arg)
	{
		Tmp = Data * Arg;
		READJUST_VALUE(Tmp, Min, Max);
		return Tmp;
	}

	template <typename OpT>
	T& operator *= (const OpT& arg)
	{
		Data *= arg;
		READJUST_VALUE(Data, Min, Max);
		return Data;
	}

	template <typename OpT>
	T& operator / (const OpT& arg)
	{
		if(arg = 0) arg = 1;
		Tmp = Data / Arg;
		READJUST_VALUE(Tmp, Min, Max);
		return Tmp;
	}

	template <typename OpT>
	T& operator /= (const OpT& arg)
	{
		if(arg = 0) arg = 1;
		Data /= arg;
		READJUST_VALUE(Data, Min, Max);
		return Data;
	}

	T& operator ++(RangedNum<T>& arg)
	{
		arg.Data++;
		return arg.Data;
	}

	T& operator ++ ()
	{
		Data++;
		return Data;
	}

	template <typename OpT>
	bool operator == (const OpT& arg) const
	{
		return (Data == arg);
	}

	template <typename OpT>
	bool operator != (const OpT& arg) const
	{
		return (Data != arg);
	}

protected:

	T Data, Min, Max, Tmp;
};


#endif // RANGED_NUM_H_INCLUDED

#define READJUST_VALUE(a, min, max) if((a) < (min)) (a) = (min); if((a) > (max)) (a) = (max)

#define READJUST_VALUE(a, min, max) if(a < min) a = min; if(a > max) a = max

template <typename T>
inline T& ReadjustValues(T* a, T min, T max)
{
  if((*a) < min) *a = min;
  if((*a) > max) *a = max;
  return *a;
}

template <typename T> 
inline T& ReAdjustValues(T* a, T min, T max)  throw()
{ 
	if((*a) < min)
	{
		*a = min;
		throw (UnderflowException<T>(*a - min));
	}
	if((*a) > max)
	{
		*a = max;
		throw (OverflowException<T>(*a - max));
	}
	return *a; 
}


template <typename T>
class LimitBreakException
{
protected:

	enum ExceptionType 
	{
		LBE_OVERFLOW, 
		LBE_UNDERFLOW 
	};

public:

	LimitBreakException(const T& diff) : Difference(diff)
	{

	}

	virtual ~LimitBreakException() = 0;

	const T& GetDifference() const
	{
		return Difference;
	}

	const ExceptionType& GetExceptionType() const
	{
		return EType;
	}

	const char* GetErrStr()
	{
		ErrStr.clear();
		ErrStr << ((EType == LBE_OVERFLOW) ? "Overflow" : "Underflow");
		ErrStr << " error by " << Difference;
		return ErrStr.str().c_str();
	}

protected:

	ExceptionType EType;
	T Difference;

private:

	std::stringstream ErrStr;
};


template <typename T>
class UnderflowException : public LimitBreakException<T>
{
public:

	UnderflowException(const T& diff) : LimitBreakException<T>(diff), EType(LBE_UNDERFLOW)
	{

	}

	~UnderflowException()
	{

	}

};


template <typename T>
class OverflowException : public LimitBreakException<T>
{
public:

	OverflowException(const T& diff) : LimitBreakException<T>(diff), EType(LBE_OVERFLOW)
	{

	}

	~OverflowException()
	{

	}

};