//

// (C) Copyright Jeremy Siek 2000.

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//

// Revision History:

//   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)

//   02 April 2001: Removed limits header altogether. (Jeremy Siek)

//   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)

//

// See http://www.boost.org/libs/concept_check for documentation.

#ifndef BOOST_CONCEPT_CHECKS_HPP

# define BOOST_CONCEPT_CHECKS_HPP

# include <boost/concept/assert.hpp>

# include <boost/iterator.hpp>

# include <boost/type_traits/conversion_traits.hpp>

# include <utility>

# include <boost/type_traits/is_same.hpp>

# include <boost/type_traits/is_void.hpp>

# include <boost/mpl/assert.hpp>

# include <boost/mpl/bool.hpp>

# include <boost/detail/workaround.hpp>

# include <boost/detail/iterator.hpp>

# include <boost/concept/usage.hpp>

# include <boost/concept/detail/concept_def.hpp>

namespace boost

{

  //

  // Backward compatibility

  //

  template <class Model>

  inline void function_requires(Model* = 0)

  {

      BOOST_CONCEPT_ASSERT((Model));

  }    

  template <class T> inline void ignore_unused_variable_warning(T const&) {}

#  define BOOST_CLASS_REQUIRE(type_var, ns, concept)    \

    BOOST_CONCEPT_ASSERT((ns::concept<type_var>))

#  define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept)   \

    BOOST_CONCEPT_ASSERT((ns::concept<type_var1,type_var2>))

#  define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept)  \

    BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3>))

#  define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \

    BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>))

  //

  // Begin concept definitions

  //

  BOOST_concept(Integer, (T))

  {

      BOOST_CONCEPT_USAGE(Integer)

        { 

            x.error_type_must_be_an_integer_type();

        }

   private:

      T x;

  };

  template <> struct Integer<signed char> {};

  template <> struct Integer<unsigned char> {};

  template <> struct Integer<short> {};

  template <> struct Integer<unsigned short> {};

  template <> struct Integer<int> {};

  template <> struct Integer<unsigned int> {};

  template <> struct Integer<long> {};

  template <> struct Integer<unsigned long> {};

# if defined(BOOST_HAS_LONG_LONG)

  template <> struct Integer< ::boost::long_long_type> {};

  template <> struct Integer< ::boost::ulong_long_type> {};

# elif defined(BOOST_HAS_MS_INT64)

  template <> struct Integer<__int64> {};

  template <> struct Integer<unsigned __int64> {};

# endif

  BOOST_concept(SignedInteger,(T)) {

    BOOST_CONCEPT_USAGE(SignedInteger) { 

      x.error_type_must_be_a_signed_integer_type();

    }

   private:

    T x;

  };

  template <> struct SignedInteger<signed char> { };

  template <> struct SignedInteger<short> {};

  template <> struct SignedInteger<int> {};

  template <> struct SignedInteger<long> {};

# if defined(BOOST_HAS_LONG_LONG)

  template <> struct SignedInteger< ::boost::long_long_type> {};

# elif defined(BOOST_HAS_MS_INT64)

  template <> struct SignedInteger<__int64> {};

# endif      

  BOOST_concept(UnsignedInteger,(T)) {

    BOOST_CONCEPT_USAGE(UnsignedInteger) { 

      x.error_type_must_be_an_unsigned_integer_type();

    }

   private:

    T x;

  };

  template <> struct UnsignedInteger<unsigned char> {};

  template <> struct UnsignedInteger<unsigned short> {};

  template <> struct UnsignedInteger<unsigned int> {};

  template <> struct UnsignedInteger<unsigned long> {};

# if defined(BOOST_HAS_LONG_LONG)

  template <> struct UnsignedInteger< ::boost::ulong_long_type> {};

# elif defined(BOOST_HAS_MS_INT64)

  template <> struct UnsignedInteger<unsigned __int64> {};

# endif

  //===========================================================================

  // Basic Concepts

  BOOST_concept(DefaultConstructible,(TT))

  {

    BOOST_CONCEPT_USAGE(DefaultConstructible) {

      TT a;               // require default constructor

      ignore_unused_variable_warning(a);

    }

  };

  BOOST_concept(Assignable,(TT))

  {

    BOOST_CONCEPT_USAGE(Assignable) {

#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL

      a = a;             // require assignment operator

#endif

      const_constraints(a);

    }

   private:

    void const_constraints(const TT& b) {

#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL

      a = b;              // const required for argument to assignment

#else

      ignore_unused_variable_warning(b);

#endif

    }

   private:

    TT a;

  };

  BOOST_concept(CopyConstructible,(TT))

  {

    BOOST_CONCEPT_USAGE(CopyConstructible) {

      TT a(b);            // require copy constructor

      TT* ptr = &a;       // require address of operator

      const_constraints(a);

      ignore_unused_variable_warning(ptr);

    }

   private:

    void const_constraints(const TT& a) {

      TT c(a);            // require const copy constructor

      const TT* ptr = &a; // require const address of operator

      ignore_unused_variable_warning(c);

      ignore_unused_variable_warning(ptr);

    }

    TT b;

  };

#if (defined _MSC_VER)

# pragma warning( push )

# pragma warning( disable : 4510 ) // default constructor could not be generated

# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required

#endif

  // The SGI STL version of Assignable requires copy constructor and operator=

  BOOST_concept(SGIAssignable,(TT))

  {

    BOOST_CONCEPT_USAGE(SGIAssignable) {

      TT b(a);

#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL

      a = a;              // require assignment operator

#endif

      const_constraints(a);

      ignore_unused_variable_warning(b);

    }

   private:

    void const_constraints(const TT& b) {

      TT c(b);

#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL

      a = b;              // const required for argument to assignment

#endif

      ignore_unused_variable_warning(c);

    }

    TT a;

  };

#if (defined _MSC_VER)

# pragma warning( pop )

#endif

  BOOST_concept(Convertible,(X)(Y))

  {

    BOOST_CONCEPT_USAGE(Convertible) {

      Y y = x;

      ignore_unused_variable_warning(y);

    }

   private:

    X x;

  };

  // The C++ standard requirements for many concepts talk about return

  // types that must be "convertible to bool".  The problem with this

  // requirement is that it leaves the door open for evil proxies that

  // define things like operator|| with strange return types.  Two

  // possible solutions are:

  // 1) require the return type to be exactly bool

  // 2) stay with convertible to bool, and also

  //    specify stuff about all the logical operators.

  // For now we just test for convertible to bool.

  template <class TT>

  void require_boolean_expr(const TT& t) {

    bool x = t;

    ignore_unused_variable_warning(x);

  }

  BOOST_concept(EqualityComparable,(TT))

  {

    BOOST_CONCEPT_USAGE(EqualityComparable) {

      require_boolean_expr(a == b);

      require_boolean_expr(a != b);

    }

   private:

    TT a, b;

  };

  BOOST_concept(LessThanComparable,(TT))

  {

    BOOST_CONCEPT_USAGE(LessThanComparable) {

      require_boolean_expr(a < b);

    }

   private:

    TT a, b;

  };

  // This is equivalent to SGI STL's LessThanComparable.

  BOOST_concept(Comparable,(TT))

  {

    BOOST_CONCEPT_USAGE(Comparable) {

      require_boolean_expr(a < b);

      require_boolean_expr(a > b);

      require_boolean_expr(a <= b);

      require_boolean_expr(a >= b);

    }

   private:

    TT a, b;

  };

#define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME)    \

  BOOST_concept(NAME, (First)(Second))                          \

  {                                                             \

      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                         \

     private:                                                   \

        bool constraints_() { return a OP b; }                  \

        First a;                                                \

        Second b;                                               \

  }

#define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME)    \

  BOOST_concept(NAME, (Ret)(First)(Second))                 \

  {                                                         \

      BOOST_CONCEPT_USAGE(NAME) { (void)constraints_(); }                     \

  private:                                                  \

      Ret constraints_() { return a OP b; }                 \

      First a;                                              \

      Second b;                                             \

  }

  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOp);

  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOp);

  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOp);

  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOp);

  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOp);

  BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOp);

  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOp);

  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOp);

  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOp);

  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOp);

  BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOp);

  //===========================================================================

  // Function Object Concepts

  BOOST_concept(Generator,(Func)(Return))

  {

      BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }

   private:

      void test(boost::mpl::false_)

      {

          // Do we really want a reference here?

          const Return& r = f();

          ignore_unused_variable_warning(r);

      }

      void test(boost::mpl::true_)

      {

          f();

      }

      Func f;

  };

  BOOST_concept(UnaryFunction,(Func)(Return)(Arg))

  {

      BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }

   private:

      void test(boost::mpl::false_)

      {

          f(arg);               // "priming the pump" this way keeps msvc6 happy (ICE)

          Return r = f(arg);

          ignore_unused_variable_warning(r); 

      }

      void test(boost::mpl::true_)

      {

          f(arg);

      }

      Func f;

      Arg arg;

  };

  BOOST_concept(BinaryFunction,(Func)(Return)(First)(Second))

  {

      BOOST_CONCEPT_USAGE(BinaryFunction) { test(is_void<Return>()); }

   private:

      void test(boost::mpl::false_)

      {

          f(first,second);

          Return r = f(first, second); // require operator()

          (void)r;

      }

      void test(boost::mpl::true_)

      {

          f(first,second);

      }

      Func f;

      First first;

      Second second;

  };

  BOOST_concept(UnaryPredicate,(Func)(Arg))

  {

    BOOST_CONCEPT_USAGE(UnaryPredicate) {

      require_boolean_expr(f(arg)); // require operator() returning bool

    }

   private:

    Func f;

    Arg arg;

  };

  BOOST_concept(BinaryPredicate,(Func)(First)(Second))

  {

    BOOST_CONCEPT_USAGE(BinaryPredicate) {

      require_boolean_expr(f(a, b)); // require operator() returning bool

    }

   private:

    Func f;

    First a;

    Second b;

  };

  // use this when functor is used inside a container class like std::set

  BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))

    : BinaryPredicate<Func, First, Second>

  {

    BOOST_CONCEPT_USAGE(Const_BinaryPredicate) { 

      const_constraints(f);

    }

   private:

    void const_constraints(const Func& fun) {

      // operator() must be a const member function

      require_boolean_expr(fun(a, b));

    }

    Func f;

    First a;

    Second b;

  };

  BOOST_concept(AdaptableGenerator,(Func)(Return))

    : Generator<Func, typename Func::result_type>

  {

      typedef typename Func::result_type result_type;

      BOOST_CONCEPT_USAGE(AdaptableGenerator)

      {

          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));

      }

  };

  BOOST_concept(AdaptableUnaryFunction,(Func)(Return)(Arg))

    : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>

  {

      typedef typename Func::argument_type argument_type;

      typedef typename Func::result_type result_type;

      ~AdaptableUnaryFunction()

      {

          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));

          BOOST_CONCEPT_ASSERT((Convertible<Arg, argument_type>));

      }

  };

  BOOST_concept(AdaptableBinaryFunction,(Func)(Return)(First)(Second))

    : BinaryFunction<

          Func

        , typename Func::result_type

        , typename Func::first_argument_type

        , typename Func::second_argument_type

      >

  {

      typedef typename Func::first_argument_type first_argument_type;

      typedef typename Func::second_argument_type second_argument_type;

      typedef typename Func::result_type result_type;

      ~AdaptableBinaryFunction()

      {

          BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));

          BOOST_CONCEPT_ASSERT((Convertible<First, first_argument_type>));

          BOOST_CONCEPT_ASSERT((Convertible<Second, second_argument_type>));

      }

  };

  BOOST_concept(AdaptablePredicate,(Func)(Arg))

    : UnaryPredicate<Func, Arg>

    , AdaptableUnaryFunction<Func, bool, Arg>

  {

  };

  BOOST_concept(AdaptableBinaryPredicate,(Func)(First)(Second))

    : BinaryPredicate<Func, First, Second>

    , AdaptableBinaryFunction<Func, bool, First, Second>

  {

  };

  //===========================================================================

  // Iterator Concepts

  BOOST_concept(InputIterator,(TT))

    : Assignable<TT>

    , EqualityComparable<TT>

  {

      typedef typename boost::detail::iterator_traits<TT>::value_type value_type;

      typedef typename boost::detail::iterator_traits<TT>::difference_type difference_type;

      typedef typename boost::detail::iterator_traits<TT>::reference reference;

      typedef typename boost::detail::iterator_traits<TT>::pointer pointer;

      typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;

      BOOST_CONCEPT_USAGE(InputIterator)

      {

        BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));

        BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));

        TT j(i);

        (void)*i;           // require dereference operator

        ++j;                // require preincrement operator

        i++;                // require postincrement operator

      }

   private:

    TT i;

  };

  BOOST_concept(OutputIterator,(TT)(ValueT))

    : Assignable<TT>

  {

    BOOST_CONCEPT_USAGE(OutputIterator) {

      ++i;                // require preincrement operator

      i++;                // require postincrement operator

      *i++ = t;           // require postincrement and assignment

    }

   private:

    TT i, j;

    ValueT t;

  };

  BOOST_concept(ForwardIterator,(TT))

    : InputIterator<TT>

  {

      BOOST_CONCEPT_USAGE(ForwardIterator)

      {

          BOOST_CONCEPT_ASSERT((Convertible<

              BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category

            , std::forward_iterator_tag

          >));

          typename InputIterator<TT>::reference r = *i;

          ignore_unused_variable_warning(r);

      }

   private:

      TT i;

  };

  BOOST_concept(Mutable_ForwardIterator,(TT))

    : ForwardIterator<TT>

  {

      BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {

        *i++ = *i;         // require postincrement and assignment

      }

   private:

      TT i;

  };

  BOOST_concept(BidirectionalIterator,(TT))

    : ForwardIterator<TT>

  {

      BOOST_CONCEPT_USAGE(BidirectionalIterator)

      {

          BOOST_CONCEPT_ASSERT((Convertible<

              BOOST_DEDUCED_TYPENAME BidirectionalIterator::iterator_category