Boost.Range

Single Pass Range, Forward Range and Bidirectional Range Implementation

Overview

Four types of objects are currently supported by the library:

Even though the behavior of the primary templates are exactly such that standard containers will be supported by default, the requirements are much lower than the standard container requirements. For example, the utility class iterator_range implements the minimal interface required to make the class a Forward Range.

Please also see Range concepts for more details.

Synopsis

namespace boost
{
    //
    // Single Pass Range metafunctions
    //
    
    template< class T >
    struct range_value;
                 
    template< class T >
    struct range_iterator;
    
    template< class T >
    struct range_const_iterator;
    
    //
    // Forward Range metafunctions
    //
    
    template< class T >
    struct range_difference;
    
    template< class T >
    struct range_size;
    
    //
    // Bidirectional Range metafunctions
    //
    
    template< class T >
    struct range_reverse_iterator;

    template< class T >
    struct range_const_reverse_iterator;
    
    //
    // Special metafunctions
    //
    
    template< class T >
    struct range_result_iterator;
                 
    template< class T >
    struct range_reverse_result_iterator;

    //
    // Single Pass Range functions
    //
    
    template< class T >
    typename range_iterator<T>::type
    begin( T& c );
    
    template< class T >
    typename range_const_iterator<T>::type
    begin( const T& c );
        
    template< class T >
    typename range_iterator<T>::type
    end( T& c );
                      
    template< class T >
    typename range_const_iterator<T>::type
    end( const T& c );
    
    template< class T >
    bool
    empty( const T& c );
               
    //
    // Forward Range functions
    //
    
    template< class T >
    typename range_size<T>::type
    size( const T& c );
                            
    //
    // Bidirectional Range functions
    //
                     
    template< class T >
    typename range_reverse_iterator<T>::type
    rbegin( T& c );
    
    template< class T >
    typename range_const_reverse_iterator<T>::type
    rbegin( const T& c );
        
    template< class T >
    typename range_reverse_iterator<T>::type
    rend( T& c );
                      
    template< class T >
    typename range_const_reverse_iterator<T>::type
    rend( const T& c );
    
    //
    // Special const Range functions
    // 
    
    template< class T >
    typename range_const_iterator<T>::type 
    const_begin( const T& r );
    
    template< class T >
    typename range_const_iterator<T>::type 
    const_end( const T& r );
    
    template< class T >
    typename range_const_reverse_iterator<T>::type 
    const_rbegin( const T& r );
    
    template< class T >
    typename range_const_reverse_iterator<T>::type 
    const_rend( const T& r );

} // namespace 'boost'

Semantics

notation

Type Object Describes
X x any type
T t denotes behavior of the primary templates
P p denotes std::pair<iterator,iterator>
A[sz] a denotes an array of type A of size sz
Char* s denotes either char* or wchar_t*

Please notice in tables below that when four lines appear in a cell, the first line will describe the primary template, the second line pairs of iterators, the third line arrays and the last line null-terminated strings.

Metafunctions

Expression Return type Complexity
range_value<X>::type T::value_type
boost::iterator_value<P::first_type>::type
A
Char 		compile time
range_iterator<X>::type T::iterator
P::first_type
A*
Char* 		compile time
range_const_iterator<X>::type T::const_iterator
P::first_type
const A*
const Char* 		compile time
range_difference<X>::type T::difference_type
boost_iterator_difference<P::first_type>::type
std::ptrdiff_t
std::ptrdiff_t
compile time
range_size<X>::type T::size_type
std::size_t
std::size_t
std::size_t
compile time
range_result_iterator<X>::type range_const_iterator<X>::type if X is const
range_iterator<X>::type otherwise 		compile time
range_reverse_iterator<X>::type boost::reverse_iterator< typename range_iterator<T>::type >
compile time
range_const_reverse_iterator<X>::type boost::reverse_iterator< typename range_const_iterator<T>::type >
compile time
range_reverse_result_iterator<X>::type boost::reverse_iterator< typename range_result_iterator<T>::type > compile time

The special metafunctions range_result_iterator and range_reverse_result_iterator are not part of any Range concept, but they are very useful when implementing certain Range classes like sub_range because of their ability to select iterators based on constness.

Functions

Expression Return type Returns Complexity
begin(x) range_result_iterator<X>::type t.begin()
p.first
a
s 		constant time
end(x) range_result_iterator<X>::type t.end()
p.second
a + sz
s + std::char_traits<X>::length( s ) if X is Char*
s + sz - 1 if X is Char[sz]
linear if X is Char*
constant time otherwise
empty(x) bool begin(x) == end( x )
linear if X is Char*
constant time otherwise
size(x) range_size<X>::type t.size()
std::distance(p.first,p.second)
sz
end(s) - s 		linear if X is Char*
or if std::distance() is linear
constant time otherwise
rbegin(x) range_reverse_result_iterator<X>::type range_reverse_result_iterator<X>::type( end(x) )
same as end(x)
rend(x) range_reverse_result_iterator<X>::type range_reverse_result_iterator<X>::type( begin(x) ) same as begin(x)
const_begin(x) range_const_iterator<X>::type range_const_iterator<X>::type( begin(x) )
same as begin(x)
const_end(x) range_const_iterator<X>::type range_const_iterator<X>::type( end(x) ) same as end(x)
const_rbegin(x) range_const_reverse_iterator<X>::type range_const_reverse_iterator<X>::type( rbegin(x) )
same as rbegin(x)
const_rend(x) range_const_reverse_iterator<X>::type range_const_reverse_iterator<X>::type( rend(x) ) same as rend(x)

The special const functions are not part of any Range concept, but are very useful when you want to document clearly that your code is read-only.

Extending the library

The primary templates in this library are implemented such that standard containers will work automatically and so will boost::array. Below is given an overview of which member functions and member types a class must specify to be useable as a certain Range concept.

Member function Related concept
begin() Single Pass Range
end() Single Pass Range
size() Forward Range

Notice that rbegin() and rend() member functions are not needed even though the container can support bidirectional iteration.

The required member types are:

Member type Related concept
value_type Single Pass Range
iterator Single Pass Range
const_iterator Single Pass Range
difference_type Forward Range
size_type Forward Range

Again one should notice that member types reverse_iterator and const_reverse_iterator are not needed.

(C) Copyright Thorsten Ottosen 2003-2004