feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

update of new concepts, and replacement of range_size<T>::type with range_difference<T>::type throughut the library

Browse Source 
[SVN r40965]
This commit is contained in:
Thorsten Jørgen Ottosen
2007-11-09 13:30:57 +00:00
parent 1509d5603b
commit 2605b9ee45
4 changed files with 34 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
include/boost/range/concepts.hpp
View File

@ -13,8 +13,8 @@
#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/range/functions.hpp>
#include <boost/range/metafunctions.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
/*!
* \file
@ -57,10 +57,10 @@ 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;
struct SinglePassRangeConcept
{
typedef typename range_iterator<T const>::type range_const_iterator;
typedef typename range_iterator<T>::type range_iterator;
//typedef typename range_iterator<const T>::type range_const_iterator;
void constraints()
{
@ -71,23 +71,24 @@ namespace boost {
>();
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);
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;
struct ForwardRangeConcept
{
void constraints()
{
function_requires<
@ -103,8 +104,8 @@ namespace boost {
//! 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;
struct BidirectionalRangeConcept
{
void constraints()
{
function_requires<
@ -115,24 +116,13 @@ namespace boost {
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;
};
//! Check if a type T models the RandomAccessRange range concept.
template<typename T>
struct RandomAccessRangeConcept {
typedef typename range_size<T>::type range_size;
struct RandomAccessRangeConcept
{
void constraints()
{
function_requires<
@ -143,12 +133,7 @@ namespace boost {
typename range_iterator<T>::type
>
>();
s = boost::size(a);
}
T a;
range_size s;
};
} // namespace boost

25
include/boost/range/iterator_range.hpp
View File

@ -73,7 +73,7 @@ namespace boost
template< class Left, class Right >
inline bool equal( const Left& l, const Right& r )
{
typedef BOOST_DEDUCED_TYPENAME boost::range_size<Left>::type sz_type;
typedef BOOST_DEDUCED_TYPENAME boost::range_difference<Left>::type sz_type;
sz_type l_size = boost::size( l ),
r_size = boost::size( r );
@ -166,20 +166,7 @@ namespace boost
, singular( true )
#endif
{ }
/*
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
iterator_range( this_type r ) :
: m_Begin(r.begin()), m_End(r.end())
{ }
this_type& operator=( this_type r )
{
m_Begin = r.begin();
m_End = r.end();
return *this;
}
#endif
*/
//! Constructor from a pair of iterators
template< class Iterator >
iterator_range( Iterator Begin, Iterator End ) :
@ -283,7 +270,7 @@ namespace boost
return m_End;
}
size_type size() const
difference_type size() const
{
BOOST_ASSERT( !is_singular() );
return m_End - m_Begin;
@ -351,9 +338,9 @@ namespace boost
return *--last;
}
reference operator[]( size_type at ) const
reference operator[]( difference_type at ) const
{
BOOST_ASSERT( at < size() );
BOOST_ASSERT( at >= 0 && at < size() );
return m_Begin[at];
}
@ -362,9 +349,9 @@ namespace boost
// fails because it returns by reference. Therefore
// operator()() is provided for these cases.
//
value_type operator()( size_type at ) const
value_type operator()( difference_type at ) const
{
BOOST_ASSERT( at < size() );
BOOST_ASSERT( at >= 0 && at < size() );
return m_Begin[at];
}

7
include/boost/range/size.hpp
View File

@ -17,14 +17,17 @@
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/difference_type.hpp>
#include <boost/assert.hpp>
namespace boost
{
template< class T >
inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
inline BOOST_DEDUCED_TYPENAME range_difference<T>::type size( const T& r )
{
BOOST_ASSERT( (boost::end( r ) - boost::begin( r )) >= 0 &&
"reachability invariant broken!" );
return boost::end( r ) - boost::begin( r );
}

11
include/boost/range/sub_range.hpp
View File

@ -38,6 +38,7 @@ namespace boost
typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type const_iterator;
typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type difference_type;
typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type size_type;
typedef BOOST_DEDUCED_TYPENAME base::reference reference;
public:
sub_range() : base()
@ -100,11 +101,11 @@ namespace boost
const_iterator begin() const { return base::begin(); }
iterator end() { return base::end(); }
const_iterator end() const { return base::end(); }
size_type size() const { return base::size(); }
difference_type size() const { return base::size(); }
public: // convenience
value_type& front()
reference front()
{
return base::front();
}
@ -114,7 +115,7 @@ namespace boost
return base::front();
}
value_type& back()
reference back()
{
return base::back();
}
@ -124,12 +125,12 @@ namespace boost
return base::back();
}
value_type& operator[]( size_type sz )
reference operator[]( difference_type sz )
{
return base::operator[](sz);
}
const value_type& operator[]( size_type sz ) const
const value_type& operator[]( difference_type sz ) const
{
return base::operator[](sz);
}