// Boost.Range library concept checks

//

//  Copyright Daniel Walker 2006. Use, modification and distribution

//  are subject to 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)

//

// For more information, see http://www.boost.org/libs/range/

//

#ifndef BOOST_RANGE_CONCEPTS_HPP

#define BOOST_RANGE_CONCEPTS_HPP

#include <boost/concept_check.hpp>

#include <boost/iterator/iterator_concepts.hpp>

#include <boost/range/functions.hpp>

#include <boost/range/metafunctions.hpp>

/*!

 * \file

 * \brief Concept checks for the Boost Range library.

 *

 * The structures in this file may be used in conjunction with the

 * Boost Concept Check library to insure that the type of a function

 * parameter is compatible with a range concept. If not, a meaningful

 * compile time error is generated. Checks are provided for the range

 * concepts related to iterator traversal categories. For example, the

 * following line checks that the type T models the ForwardRange

 * concept.

 *

 * \code

 * function_requires<ForwardRangeConcept<T> >();

 * \endcode

 *

 * An additional concept check is required for the value access

 * property of the range. For example to check for a

 * ForwardReadableRange, the following code is required.

 *

 * \code

 * function_requires<ForwardRangeConcept<T> >();

 * function_requires<

 *     ReadableIteratorConcept<

 *         typename range_iterator<T>::type

 *     >

 * >();

 * \endcode

 *

 * \see http://www.boost.org/libs/range/doc/range.html for details

 * about range concepts.

 * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html

 * for details about iterator concepts.

 * \see http://www.boost.org/libs/concept_check/concept_check.htm for

 * details about concept checks.

 */

namespace boost {

    //! Check if a type T models the SinglePassRange range concept.

    template<typename T>

    struct SinglePassRangeConcept {

        typedef typename range_value<T>::type range_value;

        typedef typename range_iterator<T>::type range_iterator;

        typedef typename range_const_iterator<T>::type range_const_iterator;

        void constraints()

        {

            function_requires<

                boost_concepts::SinglePassIteratorConcept<

                    range_iterator

                >

            >();

            i = boost::begin(a);

            i = boost::end(a);

            b = boost::empty(a);

            const_constraints(a);

        }

        void const_constraints(const T& a)

        {

            ci = boost::begin(a);

            ci = boost::end(a);

        }

        T a;

        range_iterator i;

        range_const_iterator ci;

        bool b;

    };

    //! Check if a type T models the ForwardRange range concept.

    template<typename T>

    struct ForwardRangeConcept {

        typedef typename range_difference<T>::type range_difference;

        typedef typename range_size<T>::type range_size;

        void constraints()

        {

            function_requires<

                SinglePassRangeConcept<T>

            >();        

            function_requires<

                boost_concepts::ForwardTraversalConcept<

                    typename range_iterator<T>::type

                >

            >();

            s = boost::size(a);

        }

        T a;

        range_size s;

    };

    //! Check if a type T models the BidirectionalRange range concept.

    template<typename T>

    struct BidirectionalRangeConcept {

        typedef typename range_reverse_iterator<T>::type range_reverse_iterator;

        typedef typename range_const_reverse_iterator<T>::type range_const_reverse_iterator;

        void constraints()

        {

            function_requires<

                    ForwardRangeConcept<T>

            >();        

            function_requires<

                boost_concepts::BidirectionalTraversalConcept<

                    typename range_iterator<T>::type

                >

            >();

            i = boost::rbegin(a);

            i = boost::rend(a);

            const_constraints(a);

            }

        void const_constraints(const T& a)

        {

            ci = boost::rbegin(a);

            ci = boost::rend(a);

        }

        T a;

        range_reverse_iterator i;

        range_const_reverse_iterator ci;

    };

    //! Check if a type T models the RandomAccessRange range concept.

    template<typename T>

    struct RandomAccessRangeConcept {

        void constraints()

        {

            function_requires<

                BidirectionalRangeConcept<T>

            >();        

            function_requires<

                boost_concepts::RandomAccessTraversalConcept<

                    typename range_iterator<T>::type

                >

            >();

            }

    };

} // namespace boost

#endif // BOOST_RANGE_CONCEPTS_HPP