From: nesotto_at_[hidden]
Date: 2007-11-09 08:30:58
Author: nesotto
Date: 2007-11-09 08:30:57 EST (Fri, 09 Nov 2007)
New Revision: 40965
URL: http://svn.boost.org/trac/boost/changeset/40965
Log:
update of new concepts, and replacement of range_size<T>::type with range_difference<T>::type throughut the library
Text files modified:
trunk/boost/range/concepts.hpp | 47 +++++++++++++--------------------------
trunk/boost/range/iterator_range.hpp | 27 +++++-----------------
trunk/boost/range/size.hpp | 7 ++++-
trunk/boost/range/sub_range.hpp | 11 +++++----
4 files changed, 34 insertions(+), 58 deletions(-)
Modified: trunk/boost/range/concepts.hpp
==============================================================================
--- trunk/boost/range/concepts.hpp (original)
+++ trunk/boost/range/concepts.hpp 2007-11-09 08:30:57 EST (Fri, 09 Nov 2007)
@@ -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 @@
//! Check if a type T models the SinglePassRange range concept.
template<typename T>
- struct SinglePassRangeConcept {
- typedef typename range_value<T>::type range_value;
- typedef typename range_iterator<T>::type range_iterator;
- //typedef typename range_iterator<const T>::type range_const_iterator;
+ struct SinglePassRangeConcept
+ {
+ typedef typename range_iterator<T const>::type range_const_iterator;
+ typedef typename range_iterator<T>::type range_iterator;
void constraints()
{
@@ -71,23 +71,24 @@
>();
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 @@
//! 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 @@
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 @@
typename range_iterator<T>::type
>
>();
-
- s = boost::size(a);
}
-
- T a;
- range_size s;
};
} // namespace boost
Modified: trunk/boost/range/iterator_range.hpp
==============================================================================
--- trunk/boost/range/iterator_range.hpp (original)
+++ trunk/boost/range/iterator_range.hpp 2007-11-09 08:30:57 EST (Fri, 09 Nov 2007)
@@ -73,7 +73,7 @@
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 @@
, 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 @@
return m_End;
}
- size_type size() const
+ difference_type size() const
{
BOOST_ASSERT( !is_singular() );
return m_End - m_Begin;
@@ -351,9 +338,9 @@
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 @@
// 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];
}
Modified: trunk/boost/range/size.hpp
==============================================================================
--- trunk/boost/range/size.hpp (original)
+++ trunk/boost/range/size.hpp 2007-11-09 08:30:57 EST (Fri, 09 Nov 2007)
@@ -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 );
}
Modified: trunk/boost/range/sub_range.hpp
==============================================================================
--- trunk/boost/range/sub_range.hpp (original)
+++ trunk/boost/range/sub_range.hpp 2007-11-09 08:30:57 EST (Fri, 09 Nov 2007)
@@ -38,6 +38,7 @@
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 @@
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 @@
return base::front();
}
- value_type& back()
+ reference back()
{
return base::back();
}
@@ -124,12 +125,12 @@
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);
}