Boost logo

Boost :

From: Jeff Garland (jeff_at_[hidden])
Date: 2004-04-05 07:19:03

Sorry to come late to this discussion, busy, busy...

In the date_time library there is a class called constrained_value that does
something very similar to what you are attempting. It uses a policy to define
the error handling -- so you throw an exception or whatever. In the case of
date_time it is used exclusively during construction to do range checking of
input. So the class doesn't support arithmetic operators. By creating a bunch
of these small utitlity classes almost all user input checking is performed
transparently by simple construction. That is:

  //actually constructs 3 objects to check range of year, month, day
  date d(2004, 4, 1);

So I think you can argue that there is some use to the subrange idea.

Here's the details on how it gets used:

//from boost/date_time/greg_month.hpp
  //! Exception thrown if a greg_month is constructed with a value out of range
  struct bad_month : public std::out_of_range
    bad_month() : std::out_of_range(std::string("Month number is out of range
1..12")) {}
  //! Build a policy class for the greg_month_rep
  typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month>
  //! A constrained range that implements the gregorian_month rules
  typedef CV::constrained_value<greg_month_policies> greg_month_rep;

And here's the code that implements it.

//from boost/date_time/constrained_value.hpp
namespace boost {

//! Namespace containing constrained_value template and types
namespace CV {
  //! Represent a min or max violation type
  enum violation_enum {min_violation, max_violation};
  //! A template to specify a constrained basic value type
  /*! This template provides a quick way to generate
   * an integer type with a constrained range. The type
   * provides for the ability to specify the min, max, and
   * and error handling policy.
   * <b>value policies</b>
   * A class that provides the range limits via the min and
   * max functions as well as a function on_error that
   * determines how errors are handled. A common strategy
   * would be to assert or throw and exception. The on_error
   * is passed both the current value and the new value that
   * is in error.
  template<class value_policies>
  class constrained_value {
    typedef typename value_policies::value_type value_type;
    // typedef except_type exception_type;
    constrained_value(value_type value)
    constrained_value& operator=(value_type v)
      return *this;
    //! Return the max allowed value (traits method)
    static value_type max BOOST_PREVENT_MACRO_SUBSTITUTION () {return
    //! Return the min allowed value (traits method)
    static value_type min BOOST_PREVENT_MACRO_SUBSTITUTION () {return
    //! Coerce into the representation type
    operator value_type() const {return value_;};
    value_type value_;
    void assign(value_type value)
      //adding 1 below gets rid of a compiler warning which occurs when the
      //min_value is 0 and the type is unsigned....
      if (value+1 < (min)()+1) {
        value_policies::on_error(value_, value, min_violation);
      if (value > (max)()) {
        value_policies::on_error(value_, value, max_violation);
      value_ = value;


  //! Template to shortcut the constrained_value policy creation process
  template<typename rep_type, rep_type min_value,
           rep_type max_value, class exception_type>
  class simple_exception_policy
    typedef rep_type value_type;
    static rep_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return min_value; };
    static rep_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return max_value;};
    static void on_error(rep_type, rep_type, violation_enum)
      throw exception_type();

} } //namespace CV

Boost list run by bdawes at, gregod at, cpdaniel at, john at