but here goes. I was experimenting and wrote the following code:
#include <limits.h>
#include <stdexcept>
#include <sstream>
namespace exceptions
{
class out_of_range : public std::exception
{
std::string m_msg;
protected:
out_of_range const& operator = (out_of_range const&);
public:
out_of_range(int p_min, int p_max, int p_value)
{
std::stringstream strbuf;
strbuf << "The value " << p_value << " is not in the
range [" << p_min << ", " << p_max << "].";
m_msg = strbuf.str();
}
out_of_range(out_of_range const& src)
{
m_msg = src.m_msg;
}
char const* what() const
{
return m_msg.c_str();
}
};
};
template
<
int t_Min,
int t_Max,
bool t_Validate,
bool t_useExceptions
struct IntegerValidator
{
bool IsInRange(int value)
{
return true;
}
};
template
<
int t_Min,
int t_Max struct IntegerValidator<t_Min, t_Max, true, false> {
bool IsInRange(int value)
{
return ((value <= t_Max) && (value >= t_Min));
}
};
template
<
int t_Min,
int t_Max struct IntegerValidator<t_Min, t_Max, true, true> : public IntegerValidator<t_Min, t_Max, true, false> {
bool IsInRange(int value)
{
if(!::IntegerValidator<t_Min, t_Max, true,
false>::IsInRange(value))
{
throw exceptions::out_of_range(t_Min, t_Max, value);
}
return true;
}
};
template
<
int t_Min = INT_MIN,
int t_Max = INT_MAX,
bool t_Validate = true,
bool t_useExceptions = false
class IntegerAttribute : public IntegerValidator<t_Min, t_Max,
t_Validate, t_useExceptions>
{
int m_value;
bool m_valid;
protected:
void SetValue(int p_value)
{
if(IsInRange(p_value))
{
m_value = p_value;
m_valid = true;
}
}
public:
IntegerAttribute() : m_value(0), m_valid(true)
{
}
explicit IntegerAttribute(int p_value) : m_value(0),
m_valid(false)
{
SetValue(p_value);
}
IntegerAttribute const& operator = (int p_value)
{
SetValue(p_value);
return *this;
}
IntegerAttribute const& operator = (IntegerAttribute const&
p_src)
{
SetValue(p_src.m_value);
}
operator int () const
{
return m_value;
}
};
#endif // end IntegerAttribute.h
just for fun. Here are now a few particular instantiations that I
tried:
typedef IntegerAttribute<0> PositiveInteger;
typedef IntegerAttribute<INT_MIN, 0> NegativeInteger;
typedef IntegerAttribute<0, INT_MAX, true, true> PositiveIntegerEx;
typedef IntegerAttribute<INT_MIN, 0, true, true> NegativeIntegerEx;
IMHO, I had to mix C style type ranges with C++. Shouldn't I ideally,
IMHO, have used
typedef IntegerAttribute<0> PositiveInteger;
typedef IntegerAttribute<std::numeric_limits<int>::min, 0>
NegativeInteger;
typedef IntegerAttribute<0, std::numeric_limits<int>::max, true, true>
PositiveIntegerEx;
typedef IntegerAttribute<std::numeric_limits<int>::min, 0, true, true>
NegativeIntegerEx;
instead. I cannot however do that because the above instantiations
require a compile time constant and min and max actually are functions.
Is this good? (Not from a style perspective, but from a usability
perspective.) Or am I missing something here?
Ultimately, anyway, in the particular compiler I am using the functions
min () and max() are anyway implemented as follows:
static _Ty (__CRTDECL min)() _THROW0()
{ // return minimum value
return (INT_MIN);
}
static _Ty (__CRTDECL max)() _THROW0()
{ // return maximum value
return (INT_MAX);
}
regards,
-vijai.
