ConstrainedNumeric.h

/*
 * #%L
 * OME-XML C++ library for working with OME-XML metadata structures.
 * %%
 * Copyright © 2006 - 2016 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

#ifndef OME_XML_MODEL_PRIMITIVES_CONSTRAINEDNUMERIC_H
#define OME_XML_MODEL_PRIMITIVES_CONSTRAINEDNUMERIC_H

#include <cstdint>
#include <limits>
#include <string>
#include <sstream>

#include <boost/format.hpp>
#include <boost/operators.hpp>

namespace ome
{
  namespace xml
  {
    namespace model
    {
      namespace primitives
      {

        struct ConstrainedNumericError
        {
          template<typename T>
          inline void
          operator() (const T&           value,
                      const std::string& typestr)
          {
            boost::format fmt("‘%1%’ not a supported value of %2%");
            fmt % value % typestr;
            throw std::invalid_argument(fmt.str());
          }
        };

        template<typename N,
                 typename C,
                 typename E = ConstrainedNumericError>
        class ConstrainedNumeric : private boost::partially_ordered<ConstrainedNumeric<N, C, E>, N,
                                           boost::partially_ordered<ConstrainedNumeric<N, C, E>,
                                           boost::equality_comparable2<ConstrainedNumeric<N, C, E>, N,
                                           boost::equality_comparable<ConstrainedNumeric<N, C, E>,
                                           boost::addable2<ConstrainedNumeric<N, C, E>, N,
                                           boost::addable<ConstrainedNumeric<N, C, E>,
                                           boost::subtractable2<ConstrainedNumeric<N, C, E>, N,
                                           boost::subtractable<ConstrainedNumeric<N, C, E>,
                                           boost::dividable2<ConstrainedNumeric<N, C, E>, N,
                                           boost::dividable<ConstrainedNumeric<N, C, E>,
                                           boost::multipliable2<ConstrainedNumeric<N, C, E>, N,
                                           boost::multipliable<ConstrainedNumeric<N, C, E>,
                                           boost::incrementable<ConstrainedNumeric<N, C, E>,
                                           boost::decrementable<ConstrainedNumeric<N, C, E>>>>>>>>>>>>>>>
        {
        public:
          typedef N value_type;
          typedef C constraint_type;
          typedef E error_policy_type;

          static const value_type default_value;

          ConstrainedNumeric():
            value(default_value)
          {
            check();
          }

          ConstrainedNumeric(value_type value):
            value(value)
          {
            check();
          }

          ConstrainedNumeric(const std::string& value)
          {
            std::istringstream is(value);
            is.imbue(std::locale::classic());
            value_type nval;
            is >> nval;
            if (!is)
              {
                error_policy_type error;
                error(value, this->typestr);
              }
            this->value = nval;
            check();
          }

          ConstrainedNumeric(const ConstrainedNumeric& value):
            value(value)
          {
            check();
          }

          inline
          operator value_type () const
          {
            return this->value;
          }

          inline ConstrainedNumeric&
          operator= (const ConstrainedNumeric& value)
          {
            this->value = value.value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator= (const value_type& value)
          {
            this->value = value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator+= (const ConstrainedNumeric& value)
          {
            this->value += value.value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator-= (const ConstrainedNumeric& value)
          {
            this->value -= value.value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator*= (const ConstrainedNumeric& value)
          {
            this->value *= value.value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator/= (const ConstrainedNumeric& value)
          {
            this->value /= value.value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator%= (const ConstrainedNumeric& value)
          {
            this->value %= value.value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator+= (const value_type& value)
          {
            this->value += value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator-= (const value_type& value)
          {
            this->value -= value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator*= (const value_type& value)
          {
            this->value *= value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator/= (const value_type& value)
          {
            this->value /= value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator%= (const value_type& value)
          {
            this->value %= value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator++ ()
          {
            ++this->value;
            check();
            return *this;
          }

          inline ConstrainedNumeric&
          operator-- ()
          {
            --this->value;
            check();
            return *this;
          }

          inline bool
          operator< (const ConstrainedNumeric& value) const
          {
            return this->value < value.value;
          }

          inline bool
          operator< (const value_type& value) const
          {
            return this->value < value;
          }

          // Note operator> (const ConstrainedNumeric& value) const is
          // provided by Boost.Operators.

          inline bool
          operator> (const value_type& value) const
          {
            return this->value > value;
          }

          inline bool
          operator== (const ConstrainedNumeric& value) const
          {
            return this->value == value.value;
          }

          inline bool
          operator== (const value_type& value) const
          {
            return this->value == value;
          }

        private:
          inline void
          check ()
          {
            constraint_type constraint;
            if (!constraint(this->value))
              {
                error_policy_type error;
                error(this->value, this->typestr);
              }
          }

          value_type value;
          static const std::string typestr;

          template<class _charT,
                   class _traits,
                   typename _N,
                   typename _C,
                   typename _E>
          friend
          std::basic_istream<_charT,_traits>&
          operator>> (std::basic_istream<_charT,_traits>& is,
                      ConstrainedNumeric<_N, _C, _E>&     value);
        };

        template<class charT,
                 class traits,
                 typename N,
                 typename C,
                 typename E>
        inline std::basic_istream<charT,traits>&
        operator>> (std::basic_istream<charT,traits>& is,
                    ConstrainedNumeric<N, C, E>&      value)
        {
          typename ConstrainedNumeric<N, C, E>::value_type nval;
          is >> nval;
          if (!is)
            {
              boost::format fmt("Failed to parse invalid input for %1%");
              fmt % ConstrainedNumeric<N, C, E>::typestr;
              throw std::invalid_argument(fmt.str());
            }

          value = nval;

          return is;
        }

        template<class charT,
                 class traits,
                 typename N,
                 typename C,
                 typename E>
        inline std::basic_ostream<charT,traits>&
        operator<< (std::basic_ostream<charT,traits>&  os,
                    const ConstrainedNumeric<N, C, E>& value)
        {
          return os << static_cast<typename ConstrainedNumeric<N, C, E>::value_type>(value);
        }

      }
    }
  }
}

#endif // OME_XML_MODEL_PRIMITIVES_CONSTRAINEDNUMERIC_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */