Parallel-parsing "noexport" flag.
// 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/begin.hpp>
#include <boost/range/end.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_iterator<T const>::type range_const_iterator;
typedef typename range_iterator<T>::type range_iterator;
void constraints()
{
function_requires<
boost_concepts::SinglePassIteratorConcept<
range_iterator
>
>();
i = boost::begin(a);
i = boost::end(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;
};
//! Check if a type T models the ForwardRange range concept.
template<typename T>
struct ForwardRangeConcept
{
void constraints()
{
function_requires<
SinglePassRangeConcept<T>
>();
function_requires<
boost_concepts::ForwardTraversalConcept<
typename range_iterator<T>::type
>
>();
}
};
//! Check if a type T models the BidirectionalRange range concept.
template<typename T>
struct BidirectionalRangeConcept
{
void constraints()
{
function_requires<
ForwardRangeConcept<T>
>();
function_requires<
boost_concepts::BidirectionalTraversalConcept<
typename range_iterator<T>::type
>
>();
}
};
//! 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