From b3d4845ba6ca165a741dc1aef1184ed950512d65 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thorsten=20J=C3=B8rgen=20Ottosen?= Date: Wed, 5 Jan 2005 18:19:31 +0000 Subject: [PATCH] *** empty log message *** [SVN r26630] --- include/boost/range/begin.hpp | 2 +- include/boost/range/const_iterator.hpp | 24 ++++++++ include/boost/range/difference_type.hpp | 24 ++++++++ include/boost/range/end.hpp | 2 +- include/boost/range/iterator.hpp | 24 ++++++++ include/boost/range/iterator_range.hpp | 80 +++++++++++++++++-------- include/boost/range/size.hpp | 2 +- include/boost/range/size_type.hpp | 24 ++++++++ include/boost/range/sub_range.hpp | 68 +++++++++++++++++++++ include/boost/range/value_type.hpp | 24 ++++++++ 10 files changed, 247 insertions(+), 27 deletions(-) diff --git a/include/boost/range/begin.hpp b/include/boost/range/begin.hpp index 162a29d..f3822f4 100755 --- a/include/boost/range/begin.hpp +++ b/include/boost/range/begin.hpp @@ -142,7 +142,7 @@ inline BOOST_DEDUCED_TYPENAME range_const_iterator::type begin( const T& r ) return range_detail::begin( r ); } -#if BOOST_WORKAROUND(__MWERKS__, <= 3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // BCB and CW are not able to overload pointer when class overloads are also available. template<> inline range_const_iterator::type begin( const char*& r ) diff --git a/include/boost/range/const_iterator.hpp b/include/boost/range/const_iterator.hpp index 81bd401..4ba41b2 100755 --- a/include/boost/range/const_iterator.hpp +++ b/include/boost/range/const_iterator.hpp @@ -96,6 +96,30 @@ namespace boost typedef const wchar_t* type; }; + template<> + struct range_const_iterator< char* const > + { + typedef const char* type; + }; + + template<> + struct range_const_iterator< wchar_t* const > + { + typedef const wchar_t* type; + }; + + template<> + struct range_const_iterator< const char* const > + { + typedef const char* type; + }; + + template<> + struct range_const_iterator< const wchar_t* const > + { + typedef const wchar_t* type; + }; + } // namespace boost #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION diff --git a/include/boost/range/difference_type.hpp b/include/boost/range/difference_type.hpp index 27f71d3..1aa3246 100755 --- a/include/boost/range/difference_type.hpp +++ b/include/boost/range/difference_type.hpp @@ -100,6 +100,30 @@ namespace boost typedef std::ptrdiff_t type; }; + template<> + struct range_difference< char* const > + { + typedef std::ptrdiff_t type; + }; + + template<> + struct range_difference< wchar_t* const > + { + typedef std::ptrdiff_t type; + }; + + template<> + struct range_difference< const char* const > + { + typedef std::ptrdiff_t type; + }; + + template<> + struct range_difference< const wchar_t* const > + { + typedef std::ptrdiff_t type; + }; + } // namespace boost #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION diff --git a/include/boost/range/end.hpp b/include/boost/range/end.hpp index 5acd61c..78c6f18 100755 --- a/include/boost/range/end.hpp +++ b/include/boost/range/end.hpp @@ -143,7 +143,7 @@ inline BOOST_DEDUCED_TYPENAME range_const_iterator::type end( const T& r ) -#if BOOST_WORKAROUND(__MWERKS__, <= 3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // BCB and CW are not able to overload pointer when class overloads are also available. template<> inline range_const_iterator::type end( const char*& r ) diff --git a/include/boost/range/iterator.hpp b/include/boost/range/iterator.hpp index 67b5948..0225495 100755 --- a/include/boost/range/iterator.hpp +++ b/include/boost/range/iterator.hpp @@ -97,6 +97,30 @@ namespace boost typedef const wchar_t* type; }; + template<> + struct range_iterator< char* const > + { + typedef char* type; + }; + + template<> + struct range_iterator< wchar_t* const > + { + typedef wchar_t* type; + }; + + template<> + struct range_iterator< const char* const > + { + typedef const char* type; + }; + + template<> + struct range_iterator< const wchar_t* const > + { + typedef const wchar_t* type; + }; + } // namespace boost #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION diff --git a/include/boost/range/iterator_range.hpp b/include/boost/range/iterator_range.hpp index 6216e3e..147aeb9 100755 --- a/include/boost/range/iterator_range.hpp +++ b/include/boost/range/iterator_range.hpp @@ -152,28 +152,16 @@ namespace boost { return *this; } - //! begin access - /*! - Retrieve the begin iterator - */ IteratorT begin() const { return m_Begin; } - //! end access - /*! - Retrieve the end iterator - */ IteratorT end() const { return m_End; } - //! Size of the range - /*! - Retrieve the size of the range - */ size_type size() const { if( singular ) @@ -190,18 +178,6 @@ namespace boost { return m_Begin == m_End; } - //! Safe bool conversion - /*! - Check whenever the range is empty. - Allows to use construction like this: - \code - iterator_range r; - if (!r) - { - ... - } - \endcode - */ typedef iterator (iterator_range::*unspecified_bool_type) () const; operator unspecified_bool_type() const { @@ -213,6 +189,7 @@ namespace boost { return singular == r.singular && m_Begin == r.m_Begin && m_End == r.m_End; } + #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING bool operator==( const iterator_range& r ) const @@ -231,6 +208,61 @@ namespace boost { } #endif + + public: // convenience + value_type& front() const + { + BOOST_ASSERT( !empty() ); + return *m_Begin; + } + + value_type& back() const + { + BOOST_ASSERT( !empty() ); + return *--m_End; + } + + value_type& operator[]( size_type sz ) const + { + //BOOST_STATIC_ASSERT( is_random_access ); + BOOST_ASSERT( sz < size() ); + return m_Begin[sz]; + } + + value_type& at( size_type sz ) const + { + //BOOST_STATIC_ASSERT( is_random_access ); + if( sz < size() ) + throw "foo"; + return m_Begin[sz]; + } + + void advance( size_type sz ) + { + BOOST_ASSERT( sz <= size() ); + std::advance( m_Begin, sz ); + } + + void narrow( size_type left, size_type right ) + { + BOOST_ASSERT( left + right <= size() ); + std::advance( m_Begin, left ); + std::advance( m_End, -right ); + } + + public: // iterable + iterator_range& operator++() + { + BOOST_ASSERT( !empty() ); + ++m_End; + return *this; + } + + value_type& operator*() const + { + BOOST_ASSERT( !empty() ); + return front(); + } private: template< class ForwardRange > diff --git a/include/boost/range/size.hpp b/include/boost/range/size.hpp index 90ab308..f377153 100755 --- a/include/boost/range/size.hpp +++ b/include/boost/range/size.hpp @@ -92,7 +92,7 @@ inline BOOST_DEDUCED_TYPENAME range_size::type size( const T& r ) } -#if BOOST_WORKAROUND(__MWERKS__, <= 3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) // BCB and CW are not able to overload pointer when class overloads are also available. inline range_size::type size( const char* r ) { return range_detail::str_size( r ); diff --git a/include/boost/range/size_type.hpp b/include/boost/range/size_type.hpp index cbc7b83..3143dff 100755 --- a/include/boost/range/size_type.hpp +++ b/include/boost/range/size_type.hpp @@ -96,6 +96,30 @@ namespace boost typedef std::size_t type; }; + template<> + struct range_size< char* const > + { + typedef std::size_t type; + }; + + template<> + struct range_size< wchar_t* const > + { + typedef std::size_t type; + }; + + template<> + struct range_size< const char* const > + { + typedef std::size_t type; + }; + + template<> + struct range_size< const wchar_t* const > + { + typedef std::size_t type; + }; + } // namespace boost #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION diff --git a/include/boost/range/sub_range.hpp b/include/boost/range/sub_range.hpp index 53c245c..ce505a5 100755 --- a/include/boost/range/sub_range.hpp +++ b/include/boost/range/sub_range.hpp @@ -85,6 +85,74 @@ namespace boost const_iterator end() const { return base::end(); } size_type size() const { return base::size(); } + + public: // convenience + value_type& front() + { + BOOST_ASSERT( !empty() ); + return *m_Begin; + } + + const value_type& front() const + { + BOOST_ASSERT( !empty() ); + return *m_Begin; + } + + value_type& back() + { + BOOST_ASSERT( !empty() ); + return *--m_End; + } + + const value_type& back() const + { + BOOST_ASSERT( !empty() ); + return *--m_End; + } + + value_type& operator[]( size_type sz ) + { + //BOOST_STATIC_ASSERT( is_random_access ); + BOOST_ASSERT( sz < size() ); + return m_Begin[sz]; + } + + const value_type& operator[]( size_type sz ) const + { + //BOOST_STATIC_ASSERT( is_random_access ); + BOOST_ASSERT( sz < size() ); + return m_Begin[sz]; + } + + value_type& at( size_type sz ) + { + //BOOST_STATIC_ASSERT( is_random_access ); + if( sz < size() ) + throw "foo"; + return m_Begin[sz]; + } + + const value_type& at( size_type sz ) const + { + //BOOST_STATIC_ASSERT( is_random_access ); + if( sz < size() ) + throw "foo"; + return m_Begin[sz]; + } + + public: // iterable + value_type& operator*() + { + BOOST_ASSERT( !empty() ); + return front(); + } + + const value_type& operator*() const + { + BOOST_ASSERT( !empty() ); + return front(); + } }; template< class ForwardRange, class ForwardRange2 > diff --git a/include/boost/range/value_type.hpp b/include/boost/range/value_type.hpp index 137b410..7275173 100755 --- a/include/boost/range/value_type.hpp +++ b/include/boost/range/value_type.hpp @@ -101,6 +101,30 @@ namespace boost typedef const wchar_t type; }; + template<> + struct range_value< char* const > + { + typedef char type; + }; + + template<> + struct range_value< wchar_t* const > + { + typedef wchar_t type; + }; + + template<> + struct range_value< const char* const > + { + typedef const char type; + }; + + template<> + struct range_value< const wchar_t* const > + { + typedef const wchar_t type; + }; + } // namespace boost #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION