141 lines
4.0 KiB
C++
141 lines
4.0 KiB
C++
// 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
|