boostorg/range
1
0
Fork 1
mirror of https://github.com/boostorg/range.git synced 2025-07-30 04:47:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'hotfix/ticket_6715_iterator_range_equality' into develop

Browse Source
This commit is contained in:
Neil Groves
2014-02-24 14:46:12 +00:00
parent d70210e6f2 1d91272a55
commit b07224c752
3 changed files with 175 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
include/boost/range/iterator_range_core.hpp
View File

@ -24,6 +24,7 @@
#include <boost/mpl/or.hpp> #include <boost/mpl/or.hpp>
#include <boost/type_traits/is_abstract.hpp> #include <boost/type_traits/is_abstract.hpp>
#include <boost/type_traits/is_array.hpp> #include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_pointer.hpp> #include <boost/type_traits/is_pointer.hpp>
#include <boost/range/functions.hpp> #include <boost/range/functions.hpp>
#include <boost/range/iterator.hpp> #include <boost/range/iterator.hpp>
@ -77,7 +78,7 @@ namespace boost
template< class Left, class Right > template< class Left, class Right >
inline bool greater_than( const Left& l, const Right& r ) inline bool greater_than( const Left& l, const Right& r )
{ {
return less_than(r,l); return iterator_range_detail::less_than(r,l);
} }
template< class Left, class Right > template< class Left, class Right >
@ -102,6 +103,8 @@ namespace boost
struct range_tag { }; struct range_tag { };
struct const_range_tag { }; struct const_range_tag { };
struct iterator_range_tag { };
} }
// iterator range template class -----------------------------------------// // iterator range template class -----------------------------------------//
@ -125,6 +128,7 @@ namespace boost
*/ */
template<class IteratorT> template<class IteratorT>
class iterator_range class iterator_range
: public iterator_range_detail::iterator_range_tag
{ {
typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t; typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t;
protected: // Used by sub_range protected: // Used by sub_range
@ -268,46 +272,11 @@ namespace boost
return empty(); return empty();
} }
bool equal( const iterator_range& r ) const bool equal(const iterator_range& r) const
{ {
return m_Begin == r.m_Begin && m_End == r.m_End; return m_Begin == r.m_Begin && m_End == r.m_End;
} }
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
bool operator==( const iterator_range& r ) const
{
return boost::equal( *this, r );
}
bool operator!=( const iterator_range& r ) const
{
return !operator==(r);
}
bool operator<( const iterator_range& r ) const
{
return iterator_range_detail::less_than( *this, r );
}
bool operator>( const iterator_range& r ) const
{
return iterator_range_detail::greater_than( *this, r );
}
bool operator<=( const iterator_range& r ) const
{
return iterator_range_detail::less_or_equal_than( *this, r );
}
bool operator>=( const iterator_range& r ) const
{
return iterator_range_detail::greater_or_equal_than( *this, r );
}
#endif
public: // convenience public: // convenience
reference front() const reference front() const
{ {
@ -383,138 +352,143 @@ namespace boost
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
// comparison operators // comparison operators
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
template<class SinglePassRange1, class SinglePassRange2>
template< class IteratorT, class ForwardRange > inline BOOST_DEDUCED_TYPENAME enable_if<
inline bool operator==( const ForwardRange& l, mpl::or_<
const iterator_range<IteratorT>& r ) is_convertible<
const SinglePassRange1&,
const iterator_range_detail::iterator_range_tag&
>,
is_convertible<
const SinglePassRange2&,
const iterator_range_detail::iterator_range_tag&
>
>,
bool
>::type
operator==(const SinglePassRange1& l, const SinglePassRange2& r)
{ {
return boost::equal( l, r ); BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange2>));
return boost::equal(l, r);
}
template<class SinglePassRange1, class SinglePassRange2>
inline BOOST_DEDUCED_TYPENAME enable_if<
mpl::or_<
is_convertible<
const SinglePassRange1&,
const iterator_range_detail::iterator_range_tag&
>,
is_convertible<
const SinglePassRange2&,
const iterator_range_detail::iterator_range_tag&
>
>,
bool
>::type
operator!=(const SinglePassRange1& l, const SinglePassRange2& r)
{
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange2>));
return !boost::equal(l, r);
} }
template< class IteratorT, class ForwardRange > template<class SinglePassRange1, class SinglePassRange2>
inline bool operator!=( const ForwardRange& l, inline BOOST_DEDUCED_TYPENAME enable_if<
const iterator_range<IteratorT>& r ) mpl::or_<
is_convertible<
const SinglePassRange1&,
const iterator_range_detail::iterator_range_tag&
>,
is_convertible<
const SinglePassRange2&,
const iterator_range_detail::iterator_range_tag&
>
>,
bool
>::type
operator<(const SinglePassRange1& l, const SinglePassRange2& r)
{ {
return !boost::equal( l, r ); BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange2>));
return iterator_range_detail::less_than(l, r);
} }
template< class IteratorT, class ForwardRange > template<class SinglePassRange1, class SinglePassRange2>
inline bool operator<( const ForwardRange& l, inline BOOST_DEDUCED_TYPENAME enable_if<
const iterator_range<IteratorT>& r ) mpl::or_<
is_convertible<
const SinglePassRange1&,
const iterator_range_detail::iterator_range_tag&
>,
is_convertible<
const SinglePassRange2&,
const iterator_range_detail::iterator_range_tag&
>
>,
bool
>::type
operator<=(const SinglePassRange1& l, const SinglePassRange2& r)
{ {
return iterator_range_detail::less_than( l, r ); BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange2>));
return iterator_range_detail::less_or_equal_than(l, r);
} }
template< class IteratorT, class ForwardRange > template<class SinglePassRange1, class SinglePassRange2>
inline bool operator<=( const ForwardRange& l, inline BOOST_DEDUCED_TYPENAME enable_if<
const iterator_range<IteratorT>& r ) mpl::or_<
is_convertible<
const SinglePassRange1&,
const iterator_range_detail::iterator_range_tag&
>,
is_convertible<
const SinglePassRange2&,
const iterator_range_detail::iterator_range_tag&
>
>,
bool
>::type
operator>(const SinglePassRange1& l, const SinglePassRange2& r)
{ {
return iterator_range_detail::less_or_equal_than( l, r ); BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange2>));
return iterator_range_detail::greater_than(l, r);
} }
template< class IteratorT, class ForwardRange > template<class SinglePassRange1, class SinglePassRange2>
inline bool operator>( const ForwardRange& l, inline BOOST_DEDUCED_TYPENAME enable_if<
const iterator_range<IteratorT>& r ) mpl::or_<
is_convertible<
const SinglePassRange1&,
const iterator_range_detail::iterator_range_tag&
>,
is_convertible<
const SinglePassRange2&,
const iterator_range_detail::iterator_range_tag&
>
>,
bool
>::type
operator>=(const SinglePassRange1& l, const SinglePassRange2& r)
{ {
return iterator_range_detail::greater_than( l, r ); BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((
boost::SinglePassRangeConcept<const SinglePassRange2>));
return iterator_range_detail::greater_or_equal_than(l, r);
} }
template< class IteratorT, class ForwardRange >
inline bool operator>=( const ForwardRange& l,
const iterator_range<IteratorT>& r )
{
return iterator_range_detail::greater_or_equal_than( l, r );
}
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#else
template< class Iterator1T, class Iterator2T >
inline bool operator==( const iterator_range<Iterator1T>& l,
const iterator_range<Iterator2T>& r )
{
return boost::equal( l, r );
}
template< class IteratorT, class ForwardRange >
inline bool operator==( const iterator_range<IteratorT>& l,
const ForwardRange& r )
{
return boost::equal( l, r );
}
template< class Iterator1T, class Iterator2T >
inline bool operator!=( const iterator_range<Iterator1T>& l,
const iterator_range<Iterator2T>& r )
{
return !boost::equal( l, r );
}
template< class IteratorT, class ForwardRange >
inline bool operator!=( const iterator_range<IteratorT>& l,
const ForwardRange& r )
{
return !boost::equal( l, r );
}
template< class Iterator1T, class Iterator2T >
inline bool operator<( const iterator_range<Iterator1T>& l,
const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::less_than( l, r );
}
template< class IteratorT, class ForwardRange >
inline bool operator<( const iterator_range<IteratorT>& l,
const ForwardRange& r )
{
return iterator_range_detail::less_than( l, r );
}
template< class Iterator1T, class Iterator2T >
inline bool operator<=( const iterator_range<Iterator1T>& l,
const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::less_or_equal_than( l, r );
}
template< class IteratorT, class ForwardRange >
inline bool operator<=( const iterator_range<IteratorT>& l,
const ForwardRange& r )
{
return iterator_range_detail::less_or_equal_than( l, r );
}
template< class Iterator1T, class Iterator2T >
inline bool operator>( const iterator_range<Iterator1T>& l,
const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::greater_than( l, r );
}
template< class IteratorT, class ForwardRange >
inline bool operator>( const iterator_range<IteratorT>& l,
const ForwardRange& r )
{
return iterator_range_detail::greater_than( l, r );
}
template< class Iterator1T, class Iterator2T >
inline bool operator>=( const iterator_range<Iterator1T>& l,
const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::greater_or_equal_than( l, r );
}
template< class IteratorT, class ForwardRange >
inline bool operator>=( const iterator_range<IteratorT>& l,
const ForwardRange& r )
{
return iterator_range_detail::greater_or_equal_than( l, r );
}
#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
// iterator range utilities -----------------------------------------// // iterator range utilities -----------------------------------------//

1
test/Jamfile.v2
View File

@ -162,6 +162,7 @@ test-suite range :
[ range-test ticket_5547 ] [ range-test ticket_5547 ]
[ range-test ticket_5556_is_sorted_namespace ] [ range-test ticket_5556_is_sorted_namespace ]
[ range-test ticket_5811_indirected_optional ] [ range-test ticket_5811_indirected_optional ]
[ range-test ticket_6715_iterator_range_equality ]
[ range-test ticket_6944 ] [ range-test ticket_6944 ]
; ;

44
test/ticket_6715_iterator_range_equality.cpp Normal file
View File

@ -0,0 +1,44 @@
// Boost.Range library
//
// Copyright Neil Groves 2014. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
//
// For more information, see http://www.boost.org/libs/range/
//
#include <boost/range/iterator_range_core.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
namespace boost
{
namespace
{
class str_ref : public boost::iterator_range<const char*>
{
};
void test_ticket_6715_iterator_range_equality()
{
str_ref a;
str_ref b;
BOOST_CHECK(a == b);
}
}
}
boost::unit_test::test_suite*
init_unit_test_suite(int argc, char* argv[])
{
boost::unit_test::test_suite* test
= BOOST_TEST_SUITE(
"RangeTestSuite.ticket_6715_iterator_range_equality");
test->add(BOOST_TEST_CASE(
&boost::test_ticket_6715_iterator_range_equality));
return test;
}