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

Merge branch 'develop'

Browse Source
This commit is contained in:
Neil Groves
2014-03-09 07:33:34 +00:00
parent 6c6be971ed 4ebbbba82b
commit 2f71c4b69b
40 changed files with 1514 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
doc/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
*.html

10
doc/reference/algorithm_ext/insert.qbk
View File

@ -11,10 +11,18 @@
template<
class Container,
class SinglePassRange
>
>
Container& insert(Container& target,
typename Container::iterator before,
const SinglePassRange& from);
// This overload is for target containers that do not require an insertion
// position e.g. set/map
template<
class Container,
class SinglePassRange
>
Container& insert(Container& target, const SinglePassRange& from);
``
[heading Description]

4
doc/reference/algorithms.qbk
View File

@ -37,7 +37,9 @@ boost::copy(boost::unique(boost::sort(vec)),
std::ostream_iterator<int>(std::cout));
``
Algorithms like `boost::unique` usually return the same range: `[boost::begin(rng), found)`. However, this behaviour may be changed by supplying the algorithms with a template argument:
Algorithms like `boost::unique` usually return the range: `[boost::begin(rng), found)`.
However, this behaviour may be changed by supplying a `range_return_value`
as a template parameter to the algorithm:
[table
[[Expression] [Return]]

86
doc/reference/utilities.qbk
View File

@ -9,6 +9,7 @@ Having an abstraction that encapsulates a pair of iterators is very useful. The
* Class `iterator_range`
* Class `sub_range`
* Function `combine`
* Function `join`
The `iterator_range` class is templated on an __forward_traversal_iterator__ and should be used whenever fairly general code is needed. The `sub_range` class is templated on an __forward_range__ and it is less general, but a bit easier to use since its template argument is easier to specify. The biggest difference is, however, that a `sub_range` can propagate constness because it knows what a corresponding `const_iterator` is.
@ -26,6 +27,14 @@ Recall that many default constructed iterators are [*/singular/] and hence can o
[h4 Synopsis]
The core functionality is in the header file
`<boost/range/iterator_range_core.hpp>` this includes all of the functionality
except the `boost::hash_value` and `std::iostream` support.
The `std::iostream` support is in the header `<boost/range/iterator_core.hpp>`
while the `boost::hash_value` support is in
`<boost/range/iterator_range_hash.hpp>`
``
namespace boost
{
@ -273,6 +282,83 @@ sub_range<std::string> sub = find_first( str, "ll" );
[endsect]
[section:combine Function combine]
The `combine` function is used to make one range from multiple ranges. The
`combine` function returns a `combined_range` which is an `iterator_range` of
a `zip_iterator` from the Boost.Iterator library.
[h4 Synopsis]
``
namespace boost
{
namespace range
{
template<typename IterTuple>
class combined_range
: public iterator_range<zip_iterator<IterTuple> >
{
public:
combined_range(IterTuple first, IterTuple last);
};
template<typename... Ranges>
auto combine(Ranges&&... rngs) ->
combined_range<decltype(boost::make_tuple(boost::begin(rngs)...))>
} // namespace range
} // namespace boost
``
* [*Precondition:] For each type `r` in `Ranges`, `r` is a model of
__single_pass_range__ or better.
* [*Return Type:] `combined_range<tuple<typename range_iterator<Ranges>::type...> >`
* [*Returned Range Category:] The minimum of the range category of every range
`r` in `Ranges`.
[h4 Example]
``
#include <boost/range/combine.hpp>
#include <boost/foreach.hpp>
#include <iostream>
#include <vector>
#include <list>
int main(int, const char*[])
{
std::vector<int> v;
std::list<char> l;
for (int i = 0; i < 5; ++i)
{
v.push_back(i);
l.push_back(static_cast<char>(i) + 'a');
}
int ti;
char tc;
BOOST_FOREACH(boost::tie(ti, tc), boost::combine(v, l))
{
std::cout << '(' << ti << ',' << tv << ')' << '\n';
}
return 0;
}
``
This produces the output:
``
(0,a)
(1,b)
(2,c)
(3,d)
(4,e)
``
[endsect]
[section:join Function join]
The intention of the `join` function is to join two ranges into one longer range.

2
doc/upgrade.qbk
View File

@ -16,6 +16,8 @@ been noted that some calling code was relying on member functions such as
due to `iterator_reference<Iter>::type` not being a reference. The suggested
refactoring is to use `boost::size(rng)`.
[endsect]
[section:upgrade_from_1_49 Upgrade from version 1.49]
# __size__ now returns the type Rng::size_type if the range has size_type;

10
include/boost/range/algorithm_ext/insert.hpp
View File

@ -29,12 +29,18 @@ inline Container& insert( Container& on,
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
BOOST_ASSERT( (void*)&on != (void*)&from &&
"cannot copy from a container to itself" );
on.insert( before, boost::begin(from), boost::end(from) );
return on;
}
template< class Container, class Range >
inline Container& insert( Container& on, const Range& from )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
on.insert(boost::begin(from), boost::end(from));
}
} // namespace range
using range::insert;
} // namespace boost

4
include/boost/range/any_range.hpp
View File

@ -75,8 +75,8 @@ namespace boost
template<
class Value
, class Traversal
, class Reference
, class Difference
, class Reference = Value&
, class Difference = std::ptrdiff_t
, class Buffer = use_default
>
class any_range

307
include/boost/range/combine.hpp
View File

@ -9,296 +9,37 @@
#ifndef BOOST_RANGE_COMBINE_HPP
#define BOOST_RANGE_COMBINE_HPP
#include <boost/iterator/zip_iterator.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/arithmetic.hpp>
#include <boost/config.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/iterator/zip_iterator.hpp>
namespace boost
{
namespace range_detail
namespace range
{
template<typename IterTuple>
class combined_range
: public iterator_range<zip_iterator<IterTuple> >
{
typedef iterator_range<zip_iterator<IterTuple> > base;
public:
combined_range(IterTuple first, IterTuple last)
: base(first, last)
{
struct void_ { typedef void_ type; };
}
template<> struct range_iterator< ::boost::range_detail::void_ >
{
typedef ::boost::tuples::null_type type;
};
namespace range_detail
{
inline ::boost::tuples::null_type range_begin( ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
inline ::boost::tuples::null_type range_begin( const ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
inline ::boost::tuples::null_type range_end( ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
inline ::boost::tuples::null_type range_end( const ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
template< class T >
struct tuple_iter
{
typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::eval_if_c<
::boost::is_same<T, ::boost::range_detail::void_ >::value,
::boost::mpl::identity< ::boost::tuples::null_type >,
::boost::range_iterator<T>
>::type type;
};
template< class Rng1, class Rng2 >
struct tuple_range
{
typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::eval_if_c<
::boost::is_same<Rng1, ::boost::range_detail::void_ >::value,
::boost::range_detail::void_,
::boost::mpl::identity<Rng1>
>::type type;
};
template
<
class R1,
class R2,
class R3,
class R4,
class R5,
class R6
>
struct generate_tuple
{
typedef ::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME tuple_iter<R1>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R2>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R3>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R4>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R5>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R6>::type
> type;
static type begin( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
{
return ::boost::tuples::make_tuple( ::boost::begin(r1),
::boost::begin(r2),
::boost::begin(r3),
::boost::begin(r4),
::boost::begin(r5),
::boost::begin(r6) );
}
static type end( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
{
return ::boost::tuples::make_tuple( ::boost::end(r1),
::boost::end(r2),
::boost::end(r3),
::boost::end(r4),
::boost::end(r5),
::boost::end(r6) );
}
};
template
<
class R1,
class R2 = void_,
class R3 = void_,
class R4 = void_,
class R5 = void_,
class R6 = void_
>
struct zip_rng
: iterator_range<
zip_iterator<
BOOST_DEDUCED_TYPENAME generate_tuple<R1,R2,R3,R4,R5,R6>::type
>
>
{
private:
typedef generate_tuple<R1,R2,R3,R4,R5,R6> generator_t;
typedef BOOST_DEDUCED_TYPENAME generator_t::type tuple_t;
typedef zip_iterator<tuple_t> zip_iter_t;
typedef iterator_range<zip_iter_t> base_t;
public:
zip_rng( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
: base_t( zip_iter_t( generator_t::begin(r1,r2,r3,r4,r5,r6) ),
zip_iter_t( generator_t::end(r1,r2,r3,r4,r5,r6) ) )
{
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r4));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r5));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r6));
}
template< class Zip, class Rng >
zip_rng( Zip& z, Rng& r )
: base_t( zip_iter_t( generator_t::begin( z, r ) ),
zip_iter_t( generator_t::end( z, r ) ) )
{
// @todo: tuple::begin( should be overloaded for this situation
}
struct tuple_length : ::boost::tuples::length<tuple_t>
{ };
template< unsigned N >
struct get
{
template< class Z, class R >
static BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type begin( Z& z, R& )
{
return get<N>( z.begin().get_iterator_tuple() );
}
template< class Z, class R >
static BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type end( Z& z, R& r )
{
return get<N>( z.end().get_iterator_tuple() );
}
};
};
template< class Rng1, class Rng2 >
struct zip_range
: iterator_range<
zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type
>
>
>
{
private:
typedef zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type
>
> zip_iter_t;
typedef iterator_range<zip_iter_t> base_t;
public:
zip_range( Rng1& r1, Rng2& r2 )
: base_t( zip_iter_t( ::boost::tuples::make_tuple(::boost::begin(r1),
::boost::begin(r2)) ),
zip_iter_t( ::boost::tuples::make_tuple(::boost::end(r1),
::boost::end(r2)) ) )
{
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
}
};
template< class Rng1, class Rng2, class Rng3 >
struct zip_range3
: iterator_range<
zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng3>::type
>
>
>
{
private:
typedef zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng3>::type
>
> zip_iter_t;
typedef iterator_range<zip_iter_t> base_t;
public:
zip_range3( Rng1& r1, Rng2& r2, Rng3& r3 )
: base_t( zip_iter_t( ::boost::tuples::make_tuple(::boost::begin(r1),
::boost::begin(r2),
::boost::begin(r3)) ),
zip_iter_t( ::boost::tuples::make_tuple(::boost::end(r1),
::boost::end(r2),
::boost::end(r3)) )
)
{
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3));
}
};
struct combine_tag {};
template< class Rng >
inline zip_rng<Rng>
operator&( combine_tag, Rng& r )
{
return zip_rng<Rng>(r);
}
template< class Rng >
inline iterator_range<const Rng>
operator&( combine_tag, const Rng& r )
{
return iterator_range<const Rng>(r);
}
template
<
class R1,
class R2,
class R3,
class R4,
class R5,
class Rng
>
inline BOOST_DEDUCED_TYPENAME zip_rng<R1,R2,R3,R4,R5>::next
operator&( const zip_rng<R1,R2,R3,R4,R5>& zip,
Rng& r )
{
return zip_rng<R1,R2,R3,R4,R5>::next( zip, r );
}
} // namespace range_detail
template< class Rng1, class Rng2 >
inline ::boost::range_detail::zip_range<Rng1, Rng2> combine( Rng1& r1, Rng2& r2 )
{
return ::boost::range_detail::zip_range<Rng1, Rng2>(r1, r2);
}
template< class Rng1, class Rng2 >
inline ::boost::range_detail::zip_range<const Rng1, Rng2> combine( const Rng1& r1, Rng2& r2 )
{
return ::boost::range_detail::zip_range<const Rng1, Rng2>(r1, r2);
}
template< class Rng1, class Rng2 >
inline ::boost::range_detail::zip_range<Rng1, const Rng2> combine( Rng1& r1, const Rng2& r2 )
{
return ::boost::range_detail::zip_range<Rng1, const Rng2>(r1, r2);
}
template< class Rng1, class Rng2 >
inline ::boost::range_detail::zip_range<const Rng1, const Rng2> combine( const Rng1& r1, const Rng2& r2 )
{
return ::boost::range_detail::zip_range<const Rng1, const Rng2>(r1, r2);
}
};
} // namespace range
} // namespace boost
#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) || \
defined(BOOST_NO_CXX11_DECLTYPE) || \
defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
# include <boost/range/detail/combine_cxx03.hpp>
#else
# include <boost/range/detail/combine_cxx11.hpp>
#endif
#endif

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

@ -72,6 +72,13 @@ namespace boost {
#endif
#endif
#ifdef __GCCXML__
// GCC XML, unsurprisingly, has the same issues
#if __GCCXML_GNUC__ == 4 && __GCCXML_GNUC_MINOR__ == 2
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#endif
#endif
#ifdef __BORLANDC__
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#endif

61
include/boost/range/const_iterator.hpp
View File

@ -20,6 +20,7 @@
#include <boost/range/detail/extract_optional_type.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <cstddef>
#include <utility>
@ -29,33 +30,45 @@ namespace boost
// default
//////////////////////////////////////////////////////////////////////////
namespace range_detail {
BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
}
template< typename C >
struct range_const_iterator : range_detail::extract_const_iterator<C>
{};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_const_iterator< std::pair<Iterator,Iterator> >
namespace range_detail
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
template< typename T, std::size_t sz >
struct range_const_iterator< T[sz] >
{
typedef const T* type;
};
template< typename C >
struct range_const_iterator
: extract_const_iterator<C>
{};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_const_iterator<std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_const_iterator< T[sz] >
{
typedef const T* type;
};
} // namespace range_detail
template<typename C>
struct range_const_iterator
: range_detail::range_const_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type
>
{
};
} // namespace boost

5
include/boost/range/const_reverse_iterator.hpp
View File

@ -16,6 +16,7 @@
#endif
#include <boost/range/reverse_iterator.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace boost
{
@ -24,7 +25,9 @@ namespace boost
//
template< typename C >
struct range_const_reverse_iterator : range_reverse_iterator<const C>
struct range_const_reverse_iterator
: range_reverse_iterator<
const BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
{ };
} // namespace boost

131
include/boost/range/detail/combine_cxx03.hpp Normal file
View File

@ -0,0 +1,131 @@
// 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/
//
#ifndef BOOST_RANGE_DETAIL_COMBINE_CXX03_HPP
#define BOOST_RANGE_DETAIL_COMBINE_CXX03_HPP
#ifndef BOOST_RANGE_MIN_COMBINE_ARGS
#define BOOST_RANGE_MIN_COMBINE_ARGS 2
#endif
#ifndef BOOST_RANGE_MAX_COMBINE_ARGS
#define BOOST_RANGE_MAX_COMBINE_ARGS 5
#endif
#include <boost/config.hpp>
#include <boost/iterator/zip_iterator.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/arithmetic/div.hpp>
#include <boost/preprocessor/arithmetic/mul.hpp>
#include <boost/preprocessor/control.hpp>
#include <boost/preprocessor/control/while.hpp>
#include <boost/preprocessor/facilities/empty.hpp>
#include <boost/preprocessor/facilities/identity.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/preprocessor/repetition.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/utility/result_of.hpp>
#include <vector>
#include <list>
namespace boost
{
namespace range_detail
{
template<typename F, typename T, int SIZE>
struct combined_result_impl;
template<typename F, typename T>
struct combined_result
: combined_result_impl<F, T, tuples::length<T>::value>
{
};
#define BOOST_RANGE_combined_element(z, n, data) \
typename tuples::element<n, T>::type
#define BOOST_RANGE_combined_result(z, n, data) \
template<typename F, typename T> \
struct combined_result_impl <F,T,n> \
: result_of<F(BOOST_PP_ENUM(n, BOOST_RANGE_combined_element, ~))> \
{ \
};
#define BOOST_PP_LOCAL_MACRO(n) BOOST_RANGE_combined_result(~,n,~)
#define BOOST_PP_LOCAL_LIMITS (BOOST_RANGE_MIN_COMBINE_ARGS, \
BOOST_RANGE_MAX_COMBINE_ARGS)
#include BOOST_PP_LOCAL_ITERATE()
#define BOOST_RANGE_combined_get(z, n, data) get<n>(tuple)
#define BOOST_RANGE_combined_unpack(z, n, data) \
template<typename F, typename T> inline \
typename combined_result<F,T>::type \
unpack_(mpl::int_<n>, F f, const T& tuple) \
{ \
return f(BOOST_PP_ENUM(n, BOOST_RANGE_combined_get, ~)); \
}
#define BOOST_PP_LOCAL_MACRO(n) BOOST_RANGE_combined_unpack(~,n,~)
#define BOOST_PP_LOCAL_LIMITS (BOOST_RANGE_MIN_COMBINE_ARGS, \
BOOST_RANGE_MAX_COMBINE_ARGS)
#include BOOST_PP_LOCAL_ITERATE()
} // namespace range_detail
namespace range
{
#define BOOST_RANGE_combined_seq(z, n, data) boost::data(BOOST_PP_CAT(r,n))
#ifdef BOOST_NO_RVALUE_REFERENCES
#include <boost/range/detail/combine_no_rvalue.hpp>
#else // by using rvalue references we avoid requiring 2^n overloads.
#include <boost/range/detail/combine_rvalue.hpp>
#endif
#define BOOST_PP_LOCAL_MACRO(n) BOOST_RANGE_combine(~,n,~)
#define BOOST_PP_LOCAL_LIMITS (BOOST_RANGE_MIN_COMBINE_ARGS, \
BOOST_RANGE_MAX_COMBINE_ARGS)
#include BOOST_PP_LOCAL_ITERATE()
} // namespace range
using boost::range::combine;
} // namespace boost
#endif // include guard
#undef BOOST_RANGE_combined_element
#undef BOOST_RANGE_combined_result
#undef BOOST_RANGE_combined_get
#undef BOOST_RANGE_combined_unpack
#undef BOOST_RANGE_combined_seq
#undef BOOST_RANGE_combined_exp_pred
#undef BOOST_RANGE_combined_exp_op
#undef BOOST_RANGE_combined_exp
#undef BOOST_RANGE_combined_bitset_pred
#undef BOOST_RANGE_combined_bitset_op
#undef BOOST_RANGE_combined_bitset
#undef BOOST_RANGE_combined_range_iterator
#undef BOOST_RANGE_combined_args
#undef BOOST_RANGE_combine_impl
#undef BOOST_RANGE_combine

40
include/boost/range/detail/combine_cxx11.hpp Normal file
View File

@ -0,0 +1,40 @@
// 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/
//
#ifndef BOOST_RANGE_DETAIL_COMBINE_CXX11_HPP
#define BOOST_RANGE_DETAIL_COMBINE_CXX11_HPP
#include <boost/range/iterator_range_core.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/iterator/zip_iterator.hpp>
#include <fstream>
namespace boost
{
namespace range
{
template<typename... Ranges>
auto combine(Ranges&&... rngs) ->
combined_range<decltype(boost::make_tuple(boost::begin(rngs)...))>
{
return combined_range<decltype(boost::make_tuple(boost::begin(rngs)...))>(
boost::make_tuple(boost::begin(rngs)...),
boost::make_tuple(boost::end(rngs)...));
}
} // namespace range
using range::combine;
} // namespace boost
#endif // include guard

73
include/boost/range/detail/combine_no_rvalue.hpp Normal file
View File

@ -0,0 +1,73 @@
// 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/
//
#define BOOST_RANGE_combined_exp_pred(d, data) BOOST_PP_TUPLE_ELEM(3, 0, data)
#define BOOST_RANGE_combined_exp_op(d, data) \
( \
BOOST_PP_DEC( \
BOOST_PP_TUPLE_ELEM(3, 0, data) \
), \
BOOST_PP_TUPLE_ELEM(3, 1, data), \
BOOST_PP_MUL_D( \
d, \
BOOST_PP_TUPLE_ELEM(3, 2, data), \
BOOST_PP_TUPLE_ELEM(3, 1, data) \
) \
)
#define BOOST_RANGE_combined_exp(x, n) \
BOOST_PP_TUPLE_ELEM(3, 2, \
BOOST_PP_WHILE(BOOST_RANGE_combined_exp_pred, \
BOOST_RANGE_combined_exp_op, (n, x, 1)))
#define BOOST_RANGE_combined_bitset_pred(n, state) \
BOOST_PP_TUPLE_ELEM(2,1,state)
#define BOOST_RANGE_combined_bitset_op(d, state) \
(BOOST_PP_DIV_D(d, BOOST_PP_TUPLE_ELEM(2,0,state), 2), \
BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,state)))
#define BOOST_RANGE_combined_bitset(i, n) \
BOOST_PP_MOD(BOOST_PP_TUPLE_ELEM(2, 0, \
BOOST_PP_WHILE(BOOST_RANGE_combined_bitset_pred, \
BOOST_RANGE_combined_bitset_op, (i,n))), 2)
#define BOOST_RANGE_combined_range_iterator(z, n, i) \
typename range_iterator< \
BOOST_PP_CAT(R,n) \
BOOST_PP_IF( \
BOOST_RANGE_combined_bitset(i,n), \
BOOST_PP_IDENTITY(const), \
BOOST_PP_EMPTY)() \
>::type
#define BOOST_RANGE_combined_args(z, n, i) \
BOOST_PP_CAT(R, n) \
BOOST_PP_IF(BOOST_RANGE_combined_bitset(i,n), const&, &) \
BOOST_PP_CAT(r, n)
#define BOOST_RANGE_combine_impl(z, i, n)\
template<BOOST_PP_ENUM_PARAMS(n, typename R)> \
inline range::combined_range< \
boost::tuple<BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, i)> \
> \
combine(BOOST_PP_ENUM(n, BOOST_RANGE_combined_args, i)) \
{ \
typedef tuple< \
BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, i) \
> rng_tuple_t; \
return range::combined_range<rng_tuple_t>( \
rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, begin)), \
rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, end))); \
}
#define BOOST_RANGE_combine(z, n, data) \
BOOST_PP_REPEAT(BOOST_RANGE_combined_exp(2,n), BOOST_RANGE_combine_impl, n)

32
include/boost/range/detail/combine_rvalue.hpp Normal file
View File

@ -0,0 +1,32 @@
// 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/
//
#define BOOST_RANGE_combined_args(z, n, i) \
BOOST_PP_CAT(R, n)&& BOOST_PP_CAT(r, n)
#define BOOST_RANGE_combined_range_iterator(z, n, i) \
typename range_iterator< \
typename remove_reference<BOOST_PP_CAT(R,n)>::type \
>::type
#define BOOST_RANGE_combine(z, n, data) \
template <BOOST_PP_ENUM_PARAMS(n, typename R)> \
inline range::combined_range< \
tuple<BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, ~)> \
> \
combine(BOOST_PP_ENUM(n, BOOST_RANGE_combined_args, ~)) \
{ \
typedef tuple< \
BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, ~) \
> rng_tuple_t; \
return range::combined_range<rng_tuple_t>( \
rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, begin)), \
rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, end))); \
}

8
include/boost/range/difference_type.hpp
View File

@ -18,11 +18,17 @@
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace boost
{
template< class T >
struct range_difference : iterator_difference< typename range_iterator<T>::type >
struct range_difference
: iterator_difference<
BOOST_DEDUCED_TYPENAME range_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<T>::type
>::type
>
{ };
}

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

@ -17,6 +17,7 @@
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/range/iterator.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost
@ -67,12 +68,14 @@ namespace boost
template<class T>
struct has_range_iterator
: range_detail::has_range_iterator_impl<T>
: range_detail::has_range_iterator_impl<
BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
{};
template<class T>
struct has_range_const_iterator
: range_detail::has_range_const_iterator_impl<T>
: range_detail::has_range_const_iterator_impl<
BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
{};
} // namespace boost

13
include/boost/range/iterator.hpp
View File

@ -57,10 +57,15 @@ namespace boost
#else
typedef BOOST_RANGE_DEDUCED_TYPENAME
mpl::eval_if_c< is_const<C>::value,
range_const_iterator< typename remove_const<C>::type >,
range_mutable_iterator<C> >::type type;
private:
typedef typename remove_reference<C>::type param_t;
public:
typedef typename mpl::eval_if_c<
is_const<param_t>::value,
range_const_iterator<typename remove_const<param_t>::type>,
range_mutable_iterator<param_t>
>::type type;
#endif
};

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

@ -7,6 +7,10 @@
//
// For more information, see http://www.boost.org/libs/range/
//
// Credits:
// 'michel' reported Trac 9072 which included a patch for allowing references
// to function types.
//
#ifndef BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
#define BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
@ -25,6 +29,7 @@
#include <boost/type_traits/is_abstract.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/range/functions.hpp>
@ -300,6 +305,9 @@ public:
>,
boost::is_array<
BOOST_DEDUCED_TYPENAME base_type::value_type
>,
boost::is_function<
BOOST_DEDUCED_TYPENAME base_type::value_type
>
>,
BOOST_DEDUCED_TYPENAME base_type::reference,

22
include/boost/range/iterator_range_hash.hpp Normal file
View File

@ -0,0 +1,22 @@
// 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/functional/hash.hpp>
namespace boost
{
template<class T>
std::size_t hash_value(const iterator_range<T>& rng)
{
return boost::hash_range(rng.begin(), rng.end());
}
} // namespace boost

6
include/boost/range/mutable_iterator.hpp
View File

@ -19,12 +19,14 @@
#include <boost/range/detail/extract_optional_type.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <cstddef>
#include <utility>
namespace boost
{
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
@ -34,7 +36,9 @@ namespace boost
}
template< typename C >
struct range_mutable_iterator : range_detail::extract_iterator<C>
struct range_mutable_iterator
: range_detail::extract_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
{};
//////////////////////////////////////////////////////////////////////////

3
include/boost/range/pointer.hpp
View File

@ -22,7 +22,8 @@
namespace boost
{
template< class T >
struct range_pointer : iterator_pointer< typename range_iterator<T>::type >
struct range_pointer
: iterator_pointer< BOOST_DEDUCED_TYPENAME range_iterator<T>::type >
{ };
}

4
include/boost/range/reverse_iterator.hpp
View File

@ -17,6 +17,7 @@
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/iterator/reverse_iterator.hpp>
@ -30,7 +31,8 @@ namespace boost
struct range_reverse_iterator
{
typedef reverse_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type;
BOOST_DEDUCED_TYPENAME range_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type>::type > type;
};

14
test/Jamfile.v2
View File

@ -147,26 +147,39 @@ test-suite range :
[ range-test array ]
# [ range-test atl : <include>$(VC71_ROOT)/atlmfc/include ]
[ range-test begin ]
[ range-test category ]
[ range-test combine ]
[ range-test compat2 ]
[ range-test compat3 ]
[ range-test const_iterator ]
[ range-test const_ranges ]
[ range-test const_reverse_iterator ]
[ range-test counting_range ]
[ range-test difference_type ]
[ range-test end ]
[ range-test extension_mechanism ]
[ range-test extension_size ]
[ range-test has_range_iterator ]
[ range-test irange ]
[ range-test istream_range ]
[ range-test iterator ]
[ range-test iterator_pair ]
[ range-test iterator_range ]
[ range-test iterator_range_drop ]
[ range-test iterator_range_hash ]
[ range-test iterator_range_variant ]
# [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ]
[ range-test join ]
[ range-test mutable_iterator ]
[ range-test partial_workaround ]
[ range-test pointer ]
[ range-test pointer_as_iterator ]
[ range-test reference ]
[ range-test result_iterator ]
[ range-test reverse_iterator ]
[ range-test reverse_result_iterator ]
[ range-test reversible_range ]
[ range-test size_type ]
[ range-test std_container ]
[ range-test string ]
[ range-test sub_range ]
@ -177,5 +190,6 @@ test-suite range :
[ range-test ticket_5811_indirected_optional ]
[ range-test ticket_6715_iterator_range_equality ]
[ range-test ticket_6944 ]
[ range-test value_type ]
;

61
test/category.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/category.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_category()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
boost::iterator_category<cont::const_iterator>::type,
boost::range_category<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
boost::iterator_category<cont::const_iterator>::type,
boost::range_category<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
boost::iterator_category<cont::const_iterator>::type,
boost::range_category<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_category meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_category));
return test;
}

151
test/combine.cpp
View File

@ -1,5 +1,7 @@
// Boost.Range library
//
// Copyright Neil Groves 2014
//
// Copyright Thorsten Ottosen 2006. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -7,65 +9,152 @@
//
// For more information, see http://www.boost.org/libs/range/
//
#include <boost/range/combine.hpp>
#include <boost/range/algorithm_ext/push_back.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/foreach.hpp>
#include <vector>
struct add
namespace boost_range_test
{
template< class T >
int operator()( const T& tuple ) const
namespace
{
return boost::get<0>(tuple) + boost::get<1>(tuple);
}
};
template< class CombinedRng >
void apply( const CombinedRng& r )
template<typename ContRef1, typename ContRef2>
void test_combine2()
{
std::vector<int> v;
typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<const CombinedRng>::type iterator_t;
std::list<int> l;
iterator_t e = boost::end(r);
for (iterator_t i = boost::begin(r); i != e; ++i)
for (int i = 0; i < 10; ++i)
{
v.push_back(i);
l.push_back(i * 2);
}
ContRef1& in1 = v;
ContRef2& in2 = l;
std::vector<boost::tuple<int,int> > output;
boost::push_back(output, boost::combine(in1, in2));
int index = 0;
int i1, i2;
BOOST_FOREACH(boost::tie(i1,i2), output)
{
BOOST_CHECK_EQUAL(i1, index);
BOOST_CHECK_EQUAL(i2, index * 2);
++index;
}
}
void test_combine()
template<typename ContRef1, typename ContRef2, typename ContRef3>
void test_combine3()
{
std::vector<int> v1, v2, v3;
for (int i = 1; i <= 4; ++i)
std::vector<int> v1;
std::vector<int> v2;
std::vector<int> v3;
for (int i = 0; i < 10; ++i)
{
v1.push_back(i);
v2.push_back(i);
v2.push_back(i * 2);
v3.push_back(i * 3);
}
int i1, i2;
BOOST_FOREACH( boost::tie( i1, i2 ), boost::combine(v1,v2) )
ContRef1& in1 = v1;
ContRef2& in2 = v2;
ContRef3& in3 = v3;
std::vector<boost::tuple<int,int,int> > output;
boost::push_back(output, boost::combine(in1, in2, in3));
int index = 0;
int i1, i2, i3;
BOOST_FOREACH(boost::tie(i1,i2,i3), output)
{
v3.push_back( i1 + i2 );
BOOST_CHECK_EQUAL(i1, index);
BOOST_CHECK_EQUAL(i2, index * 2);
BOOST_CHECK_EQUAL(i3, index * 3);
++index;
}
BOOST_CHECK_EQUAL( v3.size(), v1.size() );
}
} // anonymous namespace
} // namespace boost_range_test
using boost::unit_test::test_suite;
test_suite* init_unit_test_suite( int argc, char* argv[] )
boost::unit_test::test_suite* init_unit_test_suite(int, char*[] )
{
test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE( "Boost.Range combine() test suite" );
test->add( BOOST_TEST_CASE( &test_combine ) );
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine2<
const std::vector<int>, const std::list<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine2<
const std::vector<int>, std::list<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine2<
std::vector<int>, const std::list<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine2<
std::vector<int>, std::list<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
std::vector<int>,
std::vector<int>,
std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
std::vector<int>,
std::vector<int>,
const std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
std::vector<int>,
const std::vector<int>,
std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
std::vector<int>,
const std::vector<int>,
const std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
const std::vector<int>,
std::vector<int>,
std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
const std::vector<int>,
std::vector<int>,
const std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
const std::vector<int>,
const std::vector<int>,
std::vector<int> >)));
test->add(BOOST_TEST_CASE((
&boost_range_test::test_combine3<
const std::vector<int>,
const std::vector<int>,
const std::vector<int> >)));
return test;
}

61
test/const_iterator.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/const_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_const_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_iterator,
boost::range_const_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_iterator,
boost::range_const_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_iterator,
boost::range_const_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_const_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_const_iterator));
return test;
}

62
test/const_reverse_iterator.cpp Normal file
View File

@ -0,0 +1,62 @@
// 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/const_reverse_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_const_reverse_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::const_iterator>,
boost::range_const_reverse_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::const_iterator>,
boost::range_const_reverse_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::const_iterator>,
boost::range_const_reverse_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE(
"Boost.Range range_const_reverse_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_const_reverse_iterator));
return test;
}

61
test/difference_type.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/difference_type.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_difference()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::difference_type,
boost::range_difference<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::difference_type,
boost::range_difference<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::difference_type,
boost::range_difference<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_difference meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_difference));
return test;
}

11
test/has_range_iterator.cpp
View File

@ -9,6 +9,7 @@
// For more information, see http://www.boost.org/libs/range/
//
#include <boost/range/has_range_iterator.hpp>
#include <boost/config.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
@ -35,12 +36,22 @@ namespace
{
test_has_range_iterator_impl< std::vector<int> >(true);
test_has_range_iterator_impl< MockClassWithoutIterators >(false);
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
test_has_range_iterator_impl<std::vector<int>&&>(true);
test_has_range_iterator_impl<MockClassWithoutIterators&&>(false);
#endif
}
void test_has_range_const_iterator()
{
test_has_range_const_iterator_impl< std::vector<int> >(true);
test_has_range_const_iterator_impl< MockClassWithoutIterators >(false);
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
test_has_range_const_iterator_impl<std::vector<int>&&>(true);
test_has_range_const_iterator_impl<MockClassWithoutIterators&&>(false);
#endif
}
}

61
test/iterator.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_iterator,
boost::range_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_iterator));
return test;
}

52
test/iterator_range_hash.cpp Normal file
View File

@ -0,0 +1,52 @@
// 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_hash.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_iterator_range_hash()
{
std::vector<boost::int32_t> v;
for (boost::int32_t i = 0; i < 10; ++i)
{
v.push_back(i);
}
std::size_t ref_output = boost::hash_range(v.begin(), v.end());
boost::iterator_range<std::vector<boost::int32_t>::iterator> rng(v);
std::size_t test_output = boost::hash_value(rng);
BOOST_CHECK_EQUAL(ref_output, test_output);
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range iterator_range hash function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_iterator_range_hash));
return test;
}

61
test/mutable_iterator.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/mutable_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_mutable_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_mutable_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_mutable_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_mutable_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_mutable_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_mutable_iterator));
return test;
}

61
test/pointer.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/pointer.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_pointer()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::pointer,
boost::range_pointer<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_pointer,
boost::range_pointer<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::pointer,
boost::range_pointer<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_pointer meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_pointer));
return test;
}

61
test/reference.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/reference.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_reference()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::reference,
boost::range_reference<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_reference,
boost::range_reference<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::reference,
boost::range_reference<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_reference meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_reference));
return test;
}

61
test/result_iterator.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/result_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_result_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_result_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::const_iterator,
boost::range_result_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::iterator,
boost::range_result_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_result_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_result_iterator));
return test;
}

61
test/reverse_iterator.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/reverse_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_reverse_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::iterator>,
boost::range_reverse_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::const_iterator>,
boost::range_reverse_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::iterator>,
boost::range_reverse_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_reverse_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_reverse_iterator));
return test;
}

62
test/reverse_result_iterator.cpp Normal file
View File

@ -0,0 +1,62 @@
// 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/reverse_result_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_reverse_result_iterator()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::iterator>,
boost::range_reverse_result_iterator<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::const_iterator>,
boost::range_reverse_result_iterator<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
boost::reverse_iterator<cont::iterator>,
boost::range_reverse_result_iterator<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE(
"Boost.Range range_reverse_result_iterator meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_reverse_result_iterator));
return test;
}

61
test/size_type.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/size_type.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_size()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::size_type,
boost::range_size<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::size_type,
boost::range_size<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::size_type,
boost::range_size<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_size meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_size));
return test;
}

61
test/value_type.cpp Normal file
View File

@ -0,0 +1,61 @@
// 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/value_type.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test.hpp>
#include <vector>
namespace boost_range_test
{
namespace
{
void test_value_type()
{
typedef std::vector<int> cont;
BOOST_STATIC_ASSERT((
boost::is_same<
cont::value_type,
boost::range_value<cont>::type
>::value));
BOOST_STATIC_ASSERT((
boost::is_same<
cont::value_type,
boost::range_value<const cont>::type
>::value));
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_STATIC_ASSERT((
boost::is_same<
cont::value_type,
boost::range_value<cont&&>::type
>::value));
#endif
}
} // anonymous namespace
} // namespace boost_range_test
boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
{
boost::unit_test::test_suite* test =
BOOST_TEST_SUITE("Boost.Range range_value meta-function");
test->add(BOOST_TEST_CASE(&boost_range_test::test_value_type));
return test;
}