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

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

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

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

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

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

@ -17,14 +17,17 @@
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
#include <boost/range/size_type.hpp> #include <boost/range/difference_type.hpp>
#include <boost/assert.hpp>
namespace boost namespace boost
{ {
template< class T > 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 ); 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_iterator<const ForwardRange>::type const_iterator;
typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type difference_type; typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type difference_type;
typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type size_type; typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type size_type;
typedef BOOST_DEDUCED_TYPENAME base::reference reference;
public: public:
sub_range() : base() sub_range() : base()
@ -100,11 +101,11 @@ namespace boost
const_iterator begin() const { return base::begin(); } const_iterator begin() const { return base::begin(); }
iterator end() { return base::end(); } iterator end() { return base::end(); }
const_iterator end() const { 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 public: // convenience
value_type& front() reference front()
{ {
return base::front(); return base::front();
} }
@ -114,7 +115,7 @@ namespace boost
return base::front(); return base::front();
} }
value_type& back() reference back()
{ {
return base::back(); return base::back();
} }
@ -124,12 +125,12 @@ namespace boost
return base::back(); return base::back();
} }
value_type& operator[]( size_type sz ) reference operator[]( difference_type sz )
{ {
return base::operator[](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); return base::operator[](sz);
} }