boostorg/iterator
1
0
Fork 1
mirror of https://github.com/boostorg/iterator.git synced 2025-07-29 20:37:17 +02:00
Code Issues Packages Projects Releases Wiki Activity

CXX11

Browse Source
This commit is contained in:
Georgiy Guminov
2024-06-09 15:20:41 +03:00
committed by Georgy Guminov
parent 4b40364d6d
commit 054c013bba
49 changed files with 329 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -24,7 +24,6 @@ target_link_libraries(boost_iterator
Boost::mpl
Boost::optional
Boost::smart_ptr
Boost::static_assert
Boost::type_traits
Boost::utility
)

18
example/node_iterator2.hpp
View File

@ -6,11 +6,7 @@
# include "node.hpp"
# include <boost/iterator/iterator_facade.hpp>
# ifndef BOOST_NO_SFINAE
# include <boost/type_traits/is_convertible.hpp>
# include <boost/utility/enable_if.hpp>
# endif
# include <type_traits>
template <class Value>
class node_iter
@ -33,21 +29,13 @@ class node_iter
template <class OtherValue>
node_iter(
node_iter<OtherValue> const& other
# ifndef BOOST_NO_SFINAE
, typename boost::enable_if<
boost::is_convertible<OtherValue*,Value*>
, typename std::enable_if<
std::is_convertible<OtherValue*,Value*>::value
, enabler
>::type = enabler()
# endif
)
: m_node(other.m_node) {}
# if !BOOST_WORKAROUND(__GNUC__, == 2)
private: // GCC2 can't grant friendship to template member functions
friend class boost::iterator_core_access;
# endif
template <class OtherValue>
bool equal(node_iter<OtherValue> const& other) const
{

12
example/node_iterator3.hpp
View File

@ -6,11 +6,7 @@
# include "node.hpp"
# include <boost/iterator/iterator_adaptor.hpp>
# ifndef BOOST_NO_SFINAE
# include <boost/type_traits/is_convertible.hpp>
# include <boost/utility/enable_if.hpp>
# endif
# include <type_traits>
template <class Value>
class node_iter
@ -38,12 +34,10 @@ class node_iter
template <class OtherValue>
node_iter(
node_iter<OtherValue> const& other
# ifndef BOOST_NO_SFINAE
, typename boost::enable_if<
boost::is_convertible<OtherValue*,Value*>
, typename std::enable_if<
std::is_convertible<OtherValue*,Value*>::value
, enabler
>::type = enabler()
# endif
)
: super_t(other.base()) {}

1
include/boost/indirect_reference.hpp
View File

@ -13,7 +13,6 @@
# include <boost/detail/is_incrementable.hpp>
# include <boost/iterator/iterator_traits.hpp>
# include <boost/type_traits/remove_cv.hpp>
# include <boost/mpl/eval_if.hpp>
# include <boost/pointee.hpp>

27
include/boost/iterator/counting_iterator.hpp
View File

@ -5,19 +5,14 @@
#ifndef COUNTING_ITERATOR_DWA200348_HPP
# define COUNTING_ITERATOR_DWA200348_HPP
# include <type_traits>
# include <boost/config.hpp>
# include <boost/static_assert.hpp>
# include <boost/detail/workaround.hpp>
# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
# include <limits>
# elif !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
# include <boost/type_traits/is_convertible.hpp>
# else
# include <boost/type_traits/is_arithmetic.hpp>
# endif
# include <boost/type_traits/is_integral.hpp>
# include <boost/type_traits/type_identity.hpp>
# include <boost/type_traits/conditional.hpp>
# include <boost/type_traits/integral_constant.hpp>
# include <boost/detail/numeric_traits.hpp>
# include <boost/iterator/iterator_adaptor.hpp>
@ -39,7 +34,7 @@ namespace detail
struct is_numeric_impl
{
// For a while, this wasn't true, but we rely on it below. This is a regression assert.
BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
static_assert(std::is_integral<char>::value, "");
# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
@ -50,11 +45,11 @@ namespace detail
# if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
BOOST_STATIC_CONSTANT(
bool, value = (
boost::is_convertible<int,T>::value
&& boost::is_convertible<T,int>::value
std::is_convertible<int,T>::value
&& std::is_convertible<T,int>::value
));
# else
BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
BOOST_STATIC_CONSTANT(bool, value = std::is_arithmetic<T>::value);
# endif
# endif
@ -62,7 +57,7 @@ namespace detail
template <class T>
struct is_numeric
: boost::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
: std::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
{};
# if defined(BOOST_HAS_LONG_LONG)
@ -116,7 +111,7 @@ namespace detail
{
typedef typename detail::ia_dflt_help<
CategoryOrTraversal
, typename boost::conditional<
, typename std::conditional<
is_numeric<Incrementable>::value
, boost::type_identity<random_access_traversal_tag>
, iterator_traversal<Incrementable>
@ -125,7 +120,7 @@ namespace detail
typedef typename detail::ia_dflt_help<
Difference
, typename boost::conditional<
, typename std::conditional<
is_numeric<Incrementable>::value
, numeric_difference<Incrementable>
, iterator_difference<Incrementable>
@ -225,7 +220,7 @@ class counting_iterator
difference_type
distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
{
typedef typename boost::conditional<
typedef typename std::conditional<
detail::is_numeric<Incrementable>::value
, detail::number_distance<difference_type, Incrementable, OtherIncrementable>
, detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>

46
include/boost/iterator/detail/config_def.hpp
View File

@ -46,9 +46,7 @@
#endif
#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x5A0)) \
|| (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
|| BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \
#if (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
# define BOOST_NO_LVALUE_RETURN_DETECTION
@ -83,46 +81,4 @@
#endif
#if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
# define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
#endif
#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \
|| BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
# if 0 // test code
#include <boost/type_traits/is_convertible.hpp>
template <class T>
struct foo
{
foo(T);
template <class U>
foo(foo<U> const& other) : p(other.p) { }
T p;
};
bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value;
# endif
#endif
#if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE))
# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
#endif
# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
// operators in convertibility checks, causing premature errors.
//
// Borland's problems are harder to diagnose due to lack of an
// instantiation stack backtrace. They may be due in part to the fact
// that it drops cv-qualification willy-nilly in templates.
# define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
# endif
// no include guard; multiple inclusion intended

4
include/boost/iterator/detail/config_undef.hpp
View File

@ -11,11 +11,7 @@
// 23/02/03 thw
//
#undef BOOST_NO_IS_CONVERTIBLE
#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
#undef BOOST_NO_LVALUE_RETURN_DETECTION
#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
#ifdef BOOST_ITERATOR_CONFIG_DEF
# undef BOOST_ITERATOR_CONFIG_DEF

83
include/boost/iterator/detail/enable_if.hpp
View File

@ -1,83 +0,0 @@
// (C) Copyright David Abrahams 2002.
// (C) Copyright Jeremy Siek 2002.
// (C) Copyright Thomas Witt 2002.
// Distributed under 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)
#ifndef BOOST_ENABLE_IF_23022003THW_HPP
#define BOOST_ENABLE_IF_23022003THW_HPP
#include <boost/config.hpp>
#include <boost/iterator/detail/config_def.hpp>
#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE)
#include <boost/type_traits/type_identity.hpp>
#endif
//
// Boost iterators uses its own enable_if cause we need
// special semantics for deficient compilers.
// 23/02/03 thw
//
namespace boost
{
namespace iterators
{
//
// Base machinery for all kinds of enable if
//
template<bool>
struct enabled
{
template<typename T>
struct base
{
typedef T type;
};
};
//
// For compilers that don't support "Substitution Failure Is Not An Error"
// enable_if falls back to always enabled. See comments
// on operator implementation for consequences.
//
template<>
struct enabled<false>
{
template<typename T>
struct base
{
#ifdef BOOST_NO_SFINAE
typedef T type;
// This way to do it would give a nice error message containing
// invalid overload, but has the big disadvantage that
// there is no reference to user code in the error message.
//
// struct invalid_overload;
// typedef invalid_overload type;
//
#endif
};
};
template <class Cond,
class Return>
struct enable_if
# if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
: enabled<(Cond::value)>::template base<Return>
# else
: boost::type_identity<Return>
# endif
{
};
} // namespace iterators
} // namespace boost
#include <boost/iterator/detail/config_undef.hpp>
#endif // BOOST_ENABLE_IF_23022003THW_HPP

48
include/boost/iterator/detail/facade_iterator_category.hpp
View File

@ -10,16 +10,10 @@
# include <boost/mpl/or.hpp> // used in iterator_tag inheritance logic
# include <boost/mpl/and.hpp>
# include <boost/mpl/if.hpp>
# include <boost/mpl/eval_if.hpp>
# include <boost/mpl/identity.hpp>
# include <boost/static_assert.hpp>
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_const.hpp>
# include <boost/type_traits/is_reference.hpp>
# include <boost/type_traits/is_convertible.hpp>
# include <type_traits>
# include <boost/iterator/detail/config_def.hpp> // try to keep this last
@ -84,24 +78,24 @@ template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
: mpl::eval_if<
mpl::and_<
is_reference<Reference>
, is_convertible<Traversal,forward_traversal_tag>
std::is_reference<Reference>
, std::is_convertible<Traversal,forward_traversal_tag>
>
, mpl::eval_if<
is_convertible<Traversal,random_access_traversal_tag>
std::is_convertible<Traversal,random_access_traversal_tag>
, mpl::identity<std::random_access_iterator_tag>
, mpl::if_<
is_convertible<Traversal,bidirectional_traversal_tag>
std::is_convertible<Traversal,bidirectional_traversal_tag>
, std::bidirectional_iterator_tag
, std::forward_iterator_tag
>
>
, typename mpl::eval_if<
mpl::and_<
is_convertible<Traversal, single_pass_traversal_tag>
std::is_convertible<Traversal, single_pass_traversal_tag>
// check for readability
, is_convertible<Reference, ValueParam>
, std::is_convertible<Reference, ValueParam>
>
, mpl::identity<std::input_iterator_tag>
, mpl::identity<Traversal>
@ -114,15 +108,15 @@ struct iterator_facade_default_category
template <class T>
struct is_iterator_category
: mpl::or_<
is_convertible<T,std::input_iterator_tag>
, is_convertible<T,std::output_iterator_tag>
std::is_convertible<T,std::input_iterator_tag>
, std::is_convertible<T,std::output_iterator_tag>
>
{
};
template <class T>
struct is_iterator_traversal
: is_convertible<T,incrementable_traversal_tag>
: std::is_convertible<T,incrementable_traversal_tag>
{};
//
@ -138,17 +132,17 @@ struct iterator_category_with_traversal
// Make sure this isn't used to build any categories where
// convertibility to Traversal is redundant. Should just use the
// Category element in that case.
BOOST_STATIC_ASSERT((
!is_convertible<
static_assert(
!std::is_convertible<
typename iterator_category_to_traversal<Category>::type
, Traversal
>::value));
>::value, "");
BOOST_STATIC_ASSERT(is_iterator_category<Category>::value);
BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
BOOST_STATIC_ASSERT(!is_iterator_traversal<Category>::value);
static_assert(is_iterator_category<Category>::value, "");
static_assert(!is_iterator_category<Traversal>::value, "");
static_assert(!is_iterator_traversal<Category>::value, "");
# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
BOOST_STATIC_ASSERT(is_iterator_traversal<Traversal>::value);
static_assert(is_iterator_traversal<Traversal>::value, "");
# endif
};
@ -157,17 +151,17 @@ struct iterator_category_with_traversal
template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{
BOOST_STATIC_ASSERT(!is_iterator_category<Traversal>::value);
static_assert(!is_iterator_category<Traversal>::value, "");
typedef typename iterator_facade_default_category<
Traversal,ValueParam,Reference
>::type category;
typedef typename mpl::if_<
is_same<
typedef typename std::conditional<
std::is_same<
Traversal
, typename iterator_category_to_traversal<category>::type
>
>::value
, category
, iterator_category_with_traversal<category,Traversal>
>::type type;

26
include/boost/iterator/filter_iterator.hpp
View File

@ -7,20 +7,14 @@
#ifndef BOOST_FILTER_ITERATOR_23022003THW_HPP
#define BOOST_FILTER_ITERATOR_23022003THW_HPP
#include <type_traits>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/static_assert.hpp>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) static_cast< _type&& >(_value)
#else
#define BOOST_ITERATOR_DETAIL_MOVE(_type, _value) _value
#endif
namespace boost {
namespace iterators {
@ -37,7 +31,7 @@ namespace iterators {
, Iterator
, use_default
, typename mpl::if_<
is_convertible<
std::is_convertible<
typename iterator_traversal<Iterator>::type
, random_access_traversal_tag
>
@ -62,20 +56,20 @@ namespace iterators {
filter_iterator() { }
filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator())
: super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f)), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
: super_t(std::move(x)), m_predicate(std::move(f)), m_end(std::move(end_))
{
satisfy_predicate();
}
filter_iterator(Iterator x, Iterator end_ = Iterator())
: super_t(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x)), m_predicate(), m_end(BOOST_ITERATOR_DETAIL_MOVE(Iterator, end_))
: super_t(std::move(x)), m_predicate(), m_end(std::move(end_))
{
// Pro8 is a little too aggressive about instantiating the
// body of this function.
#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
// Don't allow use of this constructor if Predicate is a
// function pointer type, since it will be 0.
BOOST_STATIC_ASSERT(is_class<Predicate>::value);
static_assert(std::is_class<Predicate>::value, "");
#endif
satisfy_predicate();
}
@ -119,19 +113,19 @@ namespace iterators {
inline filter_iterator<Predicate,Iterator>
make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator())
{
return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Predicate, f), BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
return filter_iterator<Predicate,Iterator>(std::move(f), std::move(x), std::move(end));
}
template <class Predicate, class Iterator>
inline filter_iterator<Predicate,Iterator>
make_filter_iterator(
typename iterators::enable_if<
is_class<Predicate>
typename std::enable_if<
is_class<Predicate>::value
, Iterator
>::type x
, Iterator end = Iterator())
{
return filter_iterator<Predicate,Iterator>(BOOST_ITERATOR_DETAIL_MOVE(Iterator, x), BOOST_ITERATOR_DETAIL_MOVE(Iterator, end));
return filter_iterator<Predicate,Iterator>(std::move(x), std::move(end));
}
} // namespace iterators

18
include/boost/iterator/function_input_iterator.hpp
View File

@ -9,10 +9,10 @@
#ifndef BOOST_FUNCTION_INPUT_ITERATOR
#define BOOST_FUNCTION_INPUT_ITERATOR
#include <type_traits>
#include <memory>
#include <boost/config.hpp>
#include <boost/assert.hpp>
#include <boost/core/addressof.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/function_types/is_function_pointer.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/iterator/iterator_facade.hpp>
@ -20,10 +20,6 @@
#include <boost/optional/optional.hpp>
#include <boost/utility/result_of.hpp>
#ifdef BOOST_RESULT_OF_USE_TR1
#include <boost/type_traits/is_function.hpp>
#endif
namespace boost {
namespace iterators {
@ -41,7 +37,7 @@ namespace iterators {
{
typedef typename result_of<
#ifdef BOOST_RESULT_OF_USE_TR1
typename boost::conditional<is_function<F>::value, F&, F>::type()
typename std::conditional<std::is_function<F>::value, F&, F>::type()
#else
F&()
#endif
@ -60,7 +56,7 @@ namespace iterators {
public:
function_object_input_iterator() {}
function_object_input_iterator(Function & f_, Input state_ = Input())
: f(boost::addressof(f_)), state(state_) {}
: f(std::addressof(f_)), state(state_) {}
void increment() {
if (value)
@ -130,13 +126,13 @@ namespace iterators {
template <class Function, class Input>
class function_input_iterator :
public boost::conditional<
public std::conditional<
function_types::is_function_pointer<Function>::value,
impl::function_pointer_input_iterator<Function,Input>,
impl::function_object_input_iterator<Function,Input>
>::type
{
typedef typename boost::conditional<
typedef typename std::conditional<
function_types::is_function_pointer<Function>::value,
impl::function_pointer_input_iterator<Function,Input>,
impl::function_object_input_iterator<Function,Input>

28
include/boost/iterator/function_output_iterator.hpp
View File

@ -13,13 +13,9 @@
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <boost/config.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_cv.hpp>
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#include <boost/type_traits/remove_reference.hpp>
#endif
namespace boost {
namespace iterators {
@ -31,29 +27,19 @@ namespace iterators {
class output_proxy {
public:
explicit output_proxy(UnaryFunction& f) BOOST_NOEXCEPT : m_f(f) { }
explicit output_proxy(UnaryFunction& f) noexcept : m_f(f) { }
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class T>
typename boost::disable_if_c<
boost::is_same< typename boost::remove_cv< T >::type, output_proxy >::value,
output_proxy const&
>::type operator=(const T& value) const {
m_f(value);
return *this;
}
#else
template <class T>
typename boost::disable_if_c<
boost::is_same< typename boost::remove_cv< typename boost::remove_reference< T >::type >::type, output_proxy >::value,
typename std::enable_if<
!std::is_same< typename std::remove_cv< typename std::remove_reference< T >::type >::type, output_proxy >::value,
output_proxy const&
>::type operator=(T&& value) const {
m_f(static_cast< T&& >(value));
return *this;
}
#endif
BOOST_DEFAULTED_FUNCTION(output_proxy(output_proxy const& that), BOOST_NOEXCEPT : m_f(that.m_f) {})
BOOST_DEFAULTED_FUNCTION(output_proxy(output_proxy const& that), noexcept : m_f(that.m_f) {})
BOOST_DELETED_FUNCTION(output_proxy& operator=(output_proxy const&))
private:

9
include/boost/iterator/indirect_iterator.hpp
View File

@ -14,16 +14,13 @@
#include <boost/detail/indirect_traits.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <iterator>
#include <type_traits>
#ifdef BOOST_MPL_CFG_NO_HAS_XXX
# include <boost/shared_ptr.hpp>
@ -57,9 +54,9 @@ namespace iterators {
, typename ia_dflt_help<
Reference
, mpl::eval_if<
is_same<Value,use_default>
std::is_same<Value,use_default>
, indirect_reference<dereferenceable>
, add_reference<Value>
, std::add_lvalue_reference<Value>
>
>::type
, Difference

15
include/boost/iterator/interoperable.hpp
View File

@ -7,11 +7,11 @@
#ifndef BOOST_INTEROPERABLE_23022003THW_HPP
# define BOOST_INTEROPERABLE_23022003THW_HPP
# include <type_traits>
# include <boost/mpl/bool.hpp>
# include <boost/mpl/or.hpp>
# include <boost/type_traits/is_convertible.hpp>
# include <boost/iterator/detail/config_def.hpp> // must appear last
namespace boost {
@ -33,13 +33,10 @@ namespace iterators {
//
template <typename A, typename B>
struct is_interoperable
# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
: mpl::true_
# else
: mpl::or_<
is_convertible< A, B >
, is_convertible< B, A > >
# endif
: std::integral_constant<
bool
, std::is_convertible< A, B >::value || std::is_convertible< B, A >::value
>
{
};

14
include/boost/iterator/is_iterator.hpp
View File

@ -16,15 +16,13 @@
#include <cstddef>
#include <boost/config.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/negation.hpp>
#include <boost/type_traits/conjunction.hpp>
#include <boost/type_traits/is_complete.hpp>
#include <boost/type_traits/is_function.hpp>
#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
#include <iterator>
#endif
#include <type_traits>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
@ -68,10 +66,10 @@ struct is_iterator_impl :
template< typename T >
struct is_iterator_impl< T* > :
public boost::conjunction<
boost::is_complete< T >,
boost::negation< boost::is_function< T > >
>::type
std::integral_constant<
bool
, boost::is_complete<T>::value && !std::is_function<T>::value
>
{
};

17
include/boost/iterator/is_lvalue_iterator.hpp
View File

@ -6,19 +6,16 @@
#include <boost/detail/workaround.hpp>
#include <boost/type_traits/add_lvalue_reference.hpp>
#include <boost/iterator/detail/any_conversion_eater.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <iterator>
#include <type_traits>
// should be the last #includes
#include <boost/type_traits/integral_constant.hpp>
#include <boost/iterator/detail/config_def.hpp>
#ifndef BOOST_NO_IS_CONVERTIBLE
namespace boost {
namespace iterators {
@ -39,11 +36,11 @@ namespace detail
# define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)
#else
#else // BOOST_NO_LVALUE_RETURN_DETECTION
# define BOOST_LVALUE_PRESERVER(expr) expr
#endif
#endif // BOOST_NO_LVALUE_RETURN_DETECTION
// Guts of is_lvalue_iterator. Value is the iterator's value_type
// and the result is computed in the nested rebind template.
@ -54,7 +51,7 @@ namespace detail
// convertible to Value const&
struct conversion_eater
{
conversion_eater(typename add_lvalue_reference<Value>::type);
conversion_eater(typename std::add_lvalue_reference<Value>::type);
};
static char tester(conversion_eater, int);
@ -137,14 +134,14 @@ namespace detail
} // namespace detail
template< typename T > struct is_lvalue_iterator
: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
: public std::integral_constant<bool,::boost::iterators::detail::is_readable_lvalue_iterator_impl<T>::value>
{
public:
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_lvalue_iterator,(T))
};
template< typename T > struct is_non_const_lvalue_iterator
: public ::boost::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
: public std::integral_constant<bool,::boost::iterators::detail::is_non_const_lvalue_iterator_impl<T>::value>
{
public:
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T))
@ -157,8 +154,6 @@ using iterators::is_non_const_lvalue_iterator;
} // namespace boost
#endif
#include <boost/iterator/detail/config_undef.hpp>
#endif // IS_LVALUE_ITERATOR_DWA2003112_HPP

11
include/boost/iterator/is_readable_iterator.hpp
View File

@ -6,18 +6,15 @@
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/type_traits/add_lvalue_reference.hpp>
#include <boost/iterator/detail/any_conversion_eater.hpp>
#include <iterator>
#include <type_traits>
// should be the last #include
#include <boost/type_traits/integral_constant.hpp>
#include <boost/iterator/detail/config_def.hpp>
#ifndef BOOST_NO_IS_CONVERTIBLE
namespace boost {
namespace iterators {
@ -29,7 +26,7 @@ namespace detail
template <class Value>
struct is_readable_iterator_impl
{
static char tester(typename add_lvalue_reference<Value>::type, int);
static char tester(typename std::add_lvalue_reference<Value>::type, int);
static char (& tester(any_conversion_eater, ...) )[2];
template <class It>
@ -100,7 +97,7 @@ namespace detail
} // namespace detail
template< typename T > struct is_readable_iterator
: public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
: public std::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value>
{
public:
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T))
@ -112,8 +109,6 @@ using iterators::is_readable_iterator;
} // namespace boost
#endif
#include <boost/iterator/detail/config_undef.hpp>
#endif // IS_READABLE_ITERATOR_DWA2003112_HPP

71
include/boost/iterator/iterator_adaptor.hpp
View File

@ -7,28 +7,13 @@
#ifndef BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
#define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
#include <boost/static_assert.hpp>
#include <boost/core/use_default.hpp>
#include <type_traits>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/detail/enable_if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_convertible.hpp>
#ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
# include <boost/type_traits/remove_reference.hpp>
#endif
#include <boost/type_traits/add_reference.hpp>
#include <boost/iterator/detail/config_def.hpp>
#include <boost/iterator/iterator_traits.hpp>
namespace boost {
@ -41,13 +26,6 @@ namespace iterators {
} // namespace iterators
// the incompleteness of use_default causes massive problems for
// is_convertible (naturally). This workaround is fortunately not
// needed for vc6/vc7.
template<class To>
struct is_convertible<use_default,To>
: mpl::false_ {};
namespace iterators {
namespace detail
@ -102,41 +80,14 @@ namespace iterators {
// false positives for user/library defined iterator types. See comments
// on operator implementation for consequences.
//
# if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
template <class From, class To>
struct enable_if_convertible
{
typedef boost::iterators::detail::enable_type type;
};
# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
// For some reason vc7.1 needs us to "cut off" instantiation
// of is_convertible in a few cases.
template<typename From, typename To>
struct enable_if_convertible
: iterators::enable_if<
mpl::or_<
is_same<From,To>
, is_convertible<From, To>
>
, boost::iterators::detail::enable_type
>
{};
# else
template<typename From, typename To>
struct enable_if_convertible
: iterators::enable_if<
is_convertible<From, To>
: std::enable_if<
std::is_convertible<From, To>::value
, boost::iterators::detail::enable_type
>
{};
# endif
//
// Default template argument handling for iterator_adaptor
//
@ -147,7 +98,7 @@ namespace iterators {
template <class T, class DefaultNullaryFn>
struct ia_dflt_help
: mpl::eval_if<
is_same<T, use_default>
std::is_same<T, use_default>
, DefaultNullaryFn
, mpl::identity<T>
>
@ -173,9 +124,9 @@ namespace iterators {
, typename boost::iterators::detail::ia_dflt_help<
Value
, mpl::eval_if<
is_same<Reference,use_default>
std::is_same<Reference,use_default>
, iterator_value<Base>
, remove_reference<Reference>
, std::remove_reference<Reference>
>
>::type
# else
@ -192,9 +143,9 @@ namespace iterators {
, typename boost::iterators::detail::ia_dflt_help<
Reference
, mpl::eval_if<
is_same<Value,use_default>
std::is_same<Value,use_default>
, iterator_reference<Base>
, add_reference<Value>
, std::add_lvalue_reference<Value>
>
>::type
@ -209,7 +160,7 @@ namespace iterators {
template <class Tr1, class Tr2>
inline void iterator_adaptor_assert_traversal ()
{
BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
static_assert(std::is_convertible<Tr1, Tr2>::value, "");
}
}
@ -220,7 +171,7 @@ namespace iterators {
// versions of iterator_adaptor The idea is that when the user needs
// to fiddle with the reference type it is highly likely that the
// iterator category has to be adjusted as well. Any of the
// following four template arguments may be ommitted or explicitly
// following four template arguments may be committed or explicitly
// replaced by use_default.
//
// Value - if supplied, the value_type of the resulting iterator, unless

36
include/boost/iterator/iterator_archetypes.hpp
View File

@ -8,23 +8,17 @@
#include <boost/iterator/iterator_categories.hpp>
#include <boost/operators.hpp>
#include <boost/static_assert.hpp>
#include <boost/iterator/detail/facade_iterator_category.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <type_traits>
#include <boost/concept_archetype.hpp>
#include <boost/mpl/bitand.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/identity.hpp>
#include <cstddef>
@ -119,18 +113,18 @@ namespace detail
template <class Value, class AccessCategory, class TraversalCategory>
struct operator_brackets
: mpl::eval_if<
is_convertible<TraversalCategory, random_access_traversal_tag>
std::is_convertible<TraversalCategory, random_access_traversal_tag>
, mpl::eval_if<
archetypes::has_access<
AccessCategory
, archetypes::writable_iterator_t
>
, mpl::identity<writable_operator_brackets<Value> >
, mpl::if_<
, std::conditional<
archetypes::has_access<
AccessCategory
, archetypes::readable_iterator_t
>
>::value
, readable_operator_brackets<Value>
, no_operator_brackets
>
@ -280,9 +274,9 @@ namespace detail
template <class Value>
struct convertible_type
: mpl::if_< is_const<Value>,
typename remove_const<Value>::type,
bogus_type >
: std::conditional< std::is_const<Value>::value,
typename std::remove_const<Value>::type,
bogus_type >
{};
} // namespace detail
@ -312,9 +306,9 @@ struct iterator_access_archetype_impl<
template <class Value>
struct archetype
{
typedef typename remove_cv<Value>::type value_type;
typedef Value reference;
typedef Value* pointer;
typedef typename std::remove_cv<Value>::type value_type;
typedef Value reference;
typedef Value* pointer;
value_type operator*() const { return static_object<value_type>::get(); }
@ -330,7 +324,7 @@ struct iterator_access_archetype_impl<
template <class Value>
struct archetype
{
BOOST_STATIC_ASSERT(!is_const<Value>::value);
static_assert(!std::is_const<Value>::value, "");
typedef void value_type;
typedef void reference;
typedef void pointer;
@ -381,7 +375,7 @@ struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t>
Value, archetypes::readable_lvalue_iterator_t
>
{
BOOST_STATIC_ASSERT((!is_const<Value>::value));
static_assert(!std::is_const<Value>::value, "");
};
};
@ -392,7 +386,7 @@ struct iterator_archetype;
template <class Value, class AccessCategory, class TraversalCategory>
struct traversal_archetype_base
: detail::operator_brackets<
typename remove_cv<Value>::type
typename std::remove_cv<Value>::type
, AccessCategory
, TraversalCategory
>
@ -419,8 +413,8 @@ namespace detail
archetypes::has_access<
AccessCategory, archetypes::writable_iterator_t
>
, remove_const<Value>
, add_const<Value>
, std::remove_const<Value>
, std::add_const<Value>
>::type
, typename access::reference
>::type iterator_category;

27
include/boost/iterator/iterator_categories.hpp
View File

@ -16,10 +16,7 @@
# include <boost/mpl/placeholders.hpp>
# include <boost/mpl/aux_/lambda_support.hpp>
# include <boost/type_traits/is_convertible.hpp>
# include <boost/static_assert.hpp>
#include <type_traits>
#include <iterator>
namespace boost {
@ -77,19 +74,19 @@ namespace detail
template <class Cat>
struct old_category_to_traversal
: mpl::eval_if<
is_convertible<Cat,std::random_access_iterator_tag>
std::is_convertible<Cat,std::random_access_iterator_tag>
, mpl::identity<random_access_traversal_tag>
, mpl::eval_if<
is_convertible<Cat,std::bidirectional_iterator_tag>
std::is_convertible<Cat,std::bidirectional_iterator_tag>
, mpl::identity<bidirectional_traversal_tag>
, mpl::eval_if<
is_convertible<Cat,std::forward_iterator_tag>
std::is_convertible<Cat,std::forward_iterator_tag>
, mpl::identity<forward_traversal_tag>
, mpl::eval_if<
is_convertible<Cat,std::input_iterator_tag>
std::is_convertible<Cat,std::input_iterator_tag>
, mpl::identity<single_pass_traversal_tag>
, mpl::eval_if<
is_convertible<Cat,std::output_iterator_tag>
std::is_convertible<Cat,std::output_iterator_tag>
, mpl::identity<incrementable_traversal_tag>
, void
>
@ -107,7 +104,7 @@ namespace detail
template <class Cat>
struct iterator_category_to_traversal
: mpl::eval_if< // if already convertible to a traversal tag, we're done.
is_convertible<Cat,incrementable_traversal_tag>
std::is_convertible<Cat,incrementable_traversal_tag>
, mpl::identity<Cat>
, boost::iterators::detail::old_category_to_traversal<Cat>
>
@ -146,19 +143,19 @@ struct iterator_traversal<mpl::_>
template <class Traversal>
struct pure_traversal_tag
: mpl::eval_if<
is_convertible<Traversal,random_access_traversal_tag>
std::is_convertible<Traversal,random_access_traversal_tag>
, mpl::identity<random_access_traversal_tag>
, mpl::eval_if<
is_convertible<Traversal,bidirectional_traversal_tag>
std::is_convertible<Traversal,bidirectional_traversal_tag>
, mpl::identity<bidirectional_traversal_tag>
, mpl::eval_if<
is_convertible<Traversal,forward_traversal_tag>
std::is_convertible<Traversal,forward_traversal_tag>
, mpl::identity<forward_traversal_tag>
, mpl::eval_if<
is_convertible<Traversal,single_pass_traversal_tag>
std::is_convertible<Traversal,single_pass_traversal_tag>
, mpl::identity<single_pass_traversal_tag>
, mpl::eval_if<
is_convertible<Traversal,incrementable_traversal_tag>
std::is_convertible<Traversal,incrementable_traversal_tag>
, mpl::identity<incrementable_traversal_tag>
, void
>

14
include/boost/iterator/iterator_concepts.hpp
View File

@ -9,15 +9,7 @@
#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/or.hpp>
#include <boost/static_assert.hpp>
#include <type_traits>
// Use boost/limits to work around missing limits headers on some compilers
#include <boost/limits.hpp>
@ -144,8 +136,8 @@ namespace boost_concepts
{
typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
BOOST_STATIC_ASSERT(boost::is_integral<difference_type>::value);
BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_signed);
static_assert(std::is_integral<difference_type>::value, "");
static_assert(std::numeric_limits<difference_type>::is_signed, "");
BOOST_CONCEPT_ASSERT((
boost::Convertible<

166
include/boost/iterator/iterator_facade.hpp
View File

@ -13,30 +13,19 @@
#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/detail/facade_iterator_category.hpp>
#include <boost/iterator/detail/enable_if.hpp>
#include <boost/static_assert.hpp>
#include <boost/core/addressof.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_pointer.hpp>
#include <boost/type_traits/add_lvalue_reference.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_pod.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/always.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/if.hpp>
#include <cstddef>
#include <type_traits>
#include <memory>
#include <boost/iterator/detail/config_def.hpp> // this goes last
@ -64,7 +53,7 @@ namespace iterators {
// The type trait checks if the category or traversal is at least as advanced as the specified required traversal
template< typename CategoryOrTraversal, typename Required >
struct is_traversal_at_least :
public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
public std::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
{};
//
@ -76,8 +65,8 @@ namespace iterators {
, class Return
>
struct enable_if_interoperable :
public boost::iterators::enable_if<
is_interoperable< Facade1, Facade2 >
public std::enable_if<
is_interoperable<Facade1, Facade2>::value
, Return
>
{};
@ -91,12 +80,12 @@ namespace iterators {
, class Return
>
struct enable_if_interoperable_and_random_access_traversal :
public boost::iterators::enable_if<
public std::enable_if<
mpl::and_<
is_interoperable< Facade1, Facade2 >
, is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
, is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
>
>::value
, Return
>
{};
@ -117,13 +106,13 @@ namespace iterators {
CategoryOrTraversal, ValueParam, Reference
>::type iterator_category;
typedef typename remove_const<ValueParam>::type value_type;
typedef typename std::remove_const<ValueParam>::type value_type;
// Not the real associated pointer type
typedef typename mpl::eval_if<
boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
, add_pointer<const value_type>
, add_pointer<value_type>
, std::add_pointer<const value_type>
, std::add_pointer<value_type>
>::type pointer;
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
@ -180,7 +169,7 @@ namespace iterators {
// Provides (r++)->foo()
value_type* operator->() const
{
return boost::addressof(stored_value);
return std::addressof(stored_value);
}
private:
@ -240,38 +229,15 @@ namespace iterators {
}
// Provides writability of *r++
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <class T>
typename iterators::enable_if<
is_not_writable_postfix_increment_dereference_proxy< T >,
typename std::enable_if<
is_not_writable_postfix_increment_dereference_proxy<T>::value,
writable_postfix_increment_dereference_proxy const&
>::type operator=(T&& x) const
{
*this->stored_iterator = static_cast< T&& >(x);
return *this;
}
#else
template <class T>
typename iterators::enable_if<
is_not_writable_postfix_increment_dereference_proxy< T >,
writable_postfix_increment_dereference_proxy const&
>::type operator=(T const& x) const
{
*this->stored_iterator = x;
return *this;
}
// This overload just in case only non-const objects are writable
template <class T>
typename iterators::enable_if<
is_not_writable_postfix_increment_dereference_proxy< T >,
writable_postfix_increment_dereference_proxy const&
>::type operator=(T& x) const
{
*this->stored_iterator = x;
return *this;
}
#endif
private:
Iterator stored_iterator;
@ -303,7 +269,7 @@ namespace iterators {
// Provides (r++)->foo()
value_type* operator->() const
{
return boost::addressof(dereference_proxy.stored_value);
return std::addressof(dereference_proxy.stored_value);
}
private:
@ -318,11 +284,11 @@ namespace iterators {
static Reference r;
template <class R>
static typename mpl::if_<
is_convertible<
static typename std::conditional<
std::is_convertible<
R const volatile*
, Value const volatile*
>
>::value
, char[1]
, char[2]
>::type& helper(R const&);
@ -339,8 +305,8 @@ namespace iterators {
# else
template <class Reference, class Value>
struct is_non_proxy_reference
: is_convertible<
typename remove_reference<Reference>::type
: std::is_convertible<
typename std::remove_reference<Reference>::type
const volatile*
, Value const volatile*
>
@ -367,20 +333,20 @@ namespace iterators {
: mpl::eval_if<
mpl::and_<
// A proxy is only needed for readable iterators
is_convertible<
std::is_convertible<
Reference
// Use add_lvalue_reference to form `reference to Value` due to
// some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject
// 'reference-to-reference' in the template which described in CWG
// DR106.
// http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106
, typename add_lvalue_reference<Value const>::type
, typename std::add_lvalue_reference<Value const>::type
>
// No multipass iterator can have values that disappear
// before positions can be re-visited
, mpl::not_<
is_convertible<
std::is_convertible<
typename iterator_category_to_traversal<CategoryOrTraversal>::type
, forward_traversal_tag
>
@ -405,10 +371,10 @@ namespace iterators {
struct proxy
{
explicit proxy(Reference const & x) : m_ref(x) {}
Reference* operator->() { return boost::addressof(m_ref); }
Reference* operator->() { return std::addressof(m_ref); }
// This function is needed for MWCW and BCC, which won't call
// operator-> again automatically per 13.3.1.2 para 8
operator Reference*() { return boost::addressof(m_ref); }
operator Reference*() { return std::addressof(m_ref); }
Reference m_ref;
};
typedef proxy result_type;
@ -424,7 +390,7 @@ namespace iterators {
typedef Pointer result_type;
static result_type apply(T& x)
{
return boost::addressof(x);
return std::addressof(x);
}
};
@ -467,7 +433,8 @@ namespace iterators {
mpl::and_<
// Really we want an is_copy_constructible trait here,
// but is_POD will have to suffice in the meantime.
boost::is_POD<ValueType>
std::is_standard_layout<ValueType>
, std::is_trivial<ValueType>
, iterator_writability_disabled<ValueType,Reference>
>
>
@ -476,8 +443,8 @@ namespace iterators {
template <class Iterator, class Value, class Reference>
struct operator_brackets_result
{
typedef typename mpl::if_<
use_operator_brackets_proxy<Value,Reference>
typedef typename std::conditional<
use_operator_brackets_proxy<Value,Reference>::value
, operator_brackets_proxy<Iterator>
, Value
>::type type;
@ -498,19 +465,12 @@ namespace iterators {
struct choose_difference_type
{
template <class I1, class I2>
struct apply
:
# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
iterator_difference<I1>
# else
mpl::eval_if<
is_convertible<I2,I1>
, iterator_difference<I1>
, iterator_difference<I2>
>
# endif
struct apply : mpl::eval_if<
std::is_convertible<I2,I1>
, iterator_difference<I1>
, iterator_difference<I2>
>
{};
};
template <
@ -528,17 +488,6 @@ namespace iterators {
// Macros which describe the declarations of binary operators
# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \
template < \
class Derived1, class V1, class TC1, class Reference1, class Difference1 \
, class Derived2, class V2, class TC2, class Reference2, class Difference2 \
> \
prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \
operator op( \
iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \
, iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
# else
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \
template < \
class Derived1, class V1, class TC1, class Reference1, class Difference1 \
@ -551,7 +500,6 @@ namespace iterators {
operator op( \
iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \
, iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
# endif
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \
BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
@ -561,9 +509,12 @@ namespace iterators {
# define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \
template <class Derived, class V, class TC, class R, class D> \
prefix typename boost::iterators::enable_if< \
boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, \
Derived \
prefix typename std::enable_if< \
boost::iterators::detail::is_traversal_at_least< \
TC \
, boost::iterators::random_access_traversal_tag \
>::value \
, Derived \
>::type operator+ args
//
@ -644,13 +595,13 @@ namespace iterators {
}
template <class Facade1, class Facade2>
static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
static bool equal(Facade1 const& f1, Facade2 const& f2, std::true_type)
{
return f1.equal(f2);
}
template <class Facade1, class Facade2>
static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
static bool equal(Facade1 const& f1, Facade2 const& f2, std::false_type)
{
return f2.equal(f1);
}
@ -663,14 +614,14 @@ namespace iterators {
template <class Facade1, class Facade2>
static typename Facade1::difference_type distance_from(
Facade1 const& f1, Facade2 const& f2, mpl::true_)
Facade1 const& f1, Facade2 const& f2, std::true_type)
{
return -f1.distance_to(f2);
}
template <class Facade1, class Facade2>
static typename Facade2::difference_type distance_from(
Facade1 const& f1, Facade2 const& f2, mpl::false_)
Facade1 const& f1, Facade2 const& f2, std::false_type)
{
return f2.distance_to(f1);
}
@ -950,19 +901,13 @@ namespace iterators {
// ----------------
//
# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
# define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
# else
# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
# endif
# define BOOST_ITERATOR_CONVERTIBLE(a,b) std::is_convertible<a,b>()
# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) \
{ \
/* For those compilers that do not support enable_if */ \
BOOST_STATIC_ASSERT(( \
is_interoperable< Derived1, Derived2 >::value \
)); \
static_assert(is_interoperable<Derived1, Derived2>::value, ""); \
return_prefix iterator_core_access::base_op( \
*static_cast<Derived1 const*>(&lhs) \
, *static_cast<Derived2 const*>(&rhs) \
@ -973,7 +918,7 @@ namespace iterators {
# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
BOOST_ITERATOR_FACADE_INTEROP( \
op \
, boost::iterators::detail::always_bool2 \
, boost::iterators::detail::always_bool2 \
, return_prefix \
, base_op \
)
@ -988,11 +933,12 @@ namespace iterators {
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) \
{ \
/* For those compilers that do not support enable_if */ \
BOOST_STATIC_ASSERT(( \
static_assert( \
is_interoperable< Derived1, Derived2 >::value && \
boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \
boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \
)); \
boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value, \
"" \
); \
return_prefix iterator_core_access::base_op( \
*static_cast<Derived1 const*>(&lhs) \
, *static_cast<Derived2 const*>(&rhs) \
@ -1002,10 +948,10 @@ namespace iterators {
# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( \
op \
, boost::iterators::detail::always_bool2 \
, return_prefix \
, base_op \
op \
, boost::iterators::detail::always_bool2 \
, return_prefix \
, base_op \
)
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)

10
include/boost/iterator/minimum_category.hpp
View File

@ -4,9 +4,7 @@
#ifndef BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
# define BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
# include <boost/static_assert.hpp>
# include <boost/type_traits/is_convertible.hpp>
# include <boost/type_traits/is_same.hpp>
# include <type_traits>
# include <boost/mpl/placeholders.hpp>
# include <boost/mpl/aux_/lambda_support.hpp>
@ -44,7 +42,7 @@ struct minimum_category_impl<true,true>
{
template <class T1, class T2> struct apply
{
BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
static_assert(std::is_same<T1,T2>::value, "");
typedef T1 type;
};
};
@ -68,8 +66,8 @@ template <class T1 = mpl::_1, class T2 = mpl::_2>
struct minimum_category
{
typedef boost::iterators::detail::minimum_category_impl<
::boost::is_convertible<T1,T2>::value
, ::boost::is_convertible<T2,T1>::value
std::is_convertible<T1,T2>::value
, std::is_convertible<T2,T1>::value
> outer;
typedef typename outer::template apply<T1,T2> inner;

20
include/boost/iterator/new_iterator_tests.hpp
View File

@ -29,13 +29,11 @@
// (David Abrahams)
# include <iterator>
# include <boost/static_assert.hpp>
# include <type_traits>
# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
# include <boost/pending/iterator_tests.hpp>
# include <boost/iterator/is_readable_iterator.hpp>
# include <boost/iterator/is_lvalue_iterator.hpp>
# include <boost/type_traits/is_same.hpp>
# include <boost/mpl/bool.hpp>
# include <boost/mpl/and.hpp>
# include <boost/iterator/detail/config_def.hpp>
@ -90,7 +88,7 @@ void readable_iterator_test(const Iterator i1, T v)
// I think we don't really need this as it checks the same things as
// the above code.
BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
static_assert(is_readable_iterator<Iterator>::value, "");
# endif
}
@ -125,12 +123,12 @@ void constant_lvalue_iterator_test(Iterator i, T v1)
Iterator i2(i);
typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference;
BOOST_STATIC_ASSERT((is_same<const value_type&, reference>::value));
static_assert(std::is_same<const value_type&, reference>::value, "");
const T& v2 = *i2;
BOOST_TEST(v1 == v2);
# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
BOOST_STATIC_ASSERT(!is_non_const_lvalue_iterator<Iterator>::value);
static_assert(is_lvalue_iterator<Iterator>::value, "");
static_assert(!is_non_const_lvalue_iterator<Iterator>::value, "");
# endif
}
@ -140,19 +138,19 @@ void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
Iterator i2(i);
typedef typename std::iterator_traits<Iterator>::value_type value_type;
typedef typename std::iterator_traits<Iterator>::reference reference;
BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
static_assert(std::is_same<value_type&, reference>::value, "");
T& v3 = *i2;
BOOST_TEST(v1 == v3);
// A non-const lvalue iterator is not neccessarily writable, but we
// A non-const lvalue iterator is not necessarily writable, but we
// are assuming the value_type is assignable here
*i = v2;
T& v4 = *i2;
BOOST_TEST(v2 == v4);
# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
static_assert(is_lvalue_iterator<Iterator>::value, "");
static_assert(is_non_const_lvalue_iterator<Iterator>::value, "");
# endif
}

23
include/boost/iterator/transform_iterator.hpp
View File

@ -9,28 +9,13 @@
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <boost/iterator/detail/enable_if.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_categories.hpp>
#include <boost/type_traits/function_traits.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility/result_of.hpp>
#include <type_traits>
#include <iterator>
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#include <boost/type_traits/is_base_and_derived.hpp>
#endif
#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
#include <boost/static_assert.hpp>
#endif
#include <boost/iterator/detail/config_def.hpp>
@ -103,7 +88,7 @@ namespace iterators {
#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
// don't provide this constructor if UnaryFunc is a
// function pointer type, since it will be 0. Too dangerous.
BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
static_assert(std::is_class<UnaryFunc>::value, "");
#endif
}
@ -149,8 +134,8 @@ namespace iterators {
// function pointer in the iterator be 0, leading to a runtime
// crash.
template <class UnaryFunc, class Iterator>
inline typename iterators::enable_if<
is_class<UnaryFunc> // We should probably find a cheaper test than is_class<>
inline typename std::enable_if<
std::is_class<UnaryFunc>::value // We should probably find a cheaper test than is_class<>
, transform_iterator<UnaryFunc, Iterator>
>::type
make_transform_iterator(Iterator it)

6
include/boost/iterator/zip_iterator.hpp
View File

@ -8,7 +8,6 @@
#ifndef BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
# define BOOST_ZIP_ITERATOR_TMB_07_13_2003_HPP_
#include <stddef.h>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/iterator/iterator_adaptor.hpp> // for enable_if_convertible
@ -19,9 +18,6 @@
#include <utility> // for std::pair
#include <boost/fusion/adapted/boost_tuple.hpp> // for backward compatibility
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/transform.hpp>
@ -83,7 +79,7 @@ namespace iterators {
struct result<This(Iterator)>
{
typedef typename
remove_cv<typename remove_reference<Iterator>::type>::type
std::remove_cv<typename std::remove_reference<Iterator>::type>::type
iterator;
typedef typename iterator_reference<iterator>::type type;

14
include/boost/pending/iterator_tests.hpp
View File

@ -20,13 +20,10 @@
// (David Abrahams)
# include <iterator>
# include <boost/static_assert.hpp>
# include <type_traits>
# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
# include <boost/core/ignore_unused.hpp>
# include <boost/core/lightweight_test.hpp>
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_pointer.hpp>
# include <boost/type_traits/is_reference.hpp>
namespace boost {
@ -143,10 +140,9 @@ template <bool is_pointer> struct lvalue_test
typedef typename Iterator::reference reference;
typedef typename Iterator::value_type value_type;
# endif
BOOST_STATIC_ASSERT(boost::is_reference<reference>::value);
BOOST_STATIC_ASSERT((boost::is_same<reference,value_type&>::value
|| boost::is_same<reference,const value_type&>::value
));
static_assert(std::is_reference<reference>::value, "");
static_assert(std::is_same<reference,value_type&>::value
|| std::is_same<reference,const value_type&>::value, "");
}
};
@ -180,7 +176,7 @@ void forward_iterator_test(Iterator i, T v1, T v2)
// borland doesn't allow non-type template parameters
# if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);
lvalue_test<std::is_pointer<Iterator>::value>::check(i);
#endif
}

8
include/boost/pointee.hpp
View File

@ -15,12 +15,10 @@
# include <boost/detail/is_incrementable.hpp>
# include <boost/iterator/iterator_traits.hpp>
# include <boost/type_traits/add_const.hpp>
# include <boost/type_traits/remove_cv.hpp>
# include <boost/mpl/if.hpp>
# include <boost/mpl/eval_if.hpp>
#include <iterator>
#include <type_traits>
namespace boost {
@ -49,13 +47,13 @@ namespace detail
BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1);
typedef typename mpl::if_c<
typedef typename std::conditional<
# if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
::boost::detail::iterator_pointee<Iterator>::is_constant
# else
is_constant
# endif
, typename add_const<value_type>::type
, typename std::add_const<value_type>::type
, value_type
>::type type;
};

5
test/counting_iterator_test.cpp
View File

@ -30,13 +30,12 @@
#include <boost/iterator/new_iterator_tests.hpp>
#include <boost/next_prior.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/limits.hpp>
#include <algorithm>
#include <climits>
#include <iterator>
#include <type_traits>
#include <stdlib.h>
#ifndef BOOST_BORLANDC
# include <boost/tuple/tuple.hpp>
@ -68,7 +67,7 @@ struct unsigned_assert_nonnegative
template <class T>
struct assert_nonnegative
: boost::conditional<
: std::conditional<
std::numeric_limits<T>::is_signed
, signed_assert_nonnegative<T>
, unsigned_assert_nonnegative<T>

1
test/detail/zip_iterator_test.ipp
View File

@ -8,6 +8,7 @@
#include <boost/core/lightweight_test.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/iterator/zip_iterator.hpp>

11
test/filter_iterator_test.cpp
View File

@ -7,15 +7,14 @@
#include <boost/iterator/filter_iterator.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/iterator/new_iterator_tests.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/concept_check.hpp>
#include <boost/concept_archetype.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/iterator/iterator_archetypes.hpp>
#include <boost/cstdlib.hpp>
#include <type_traits>
#include <deque>
#include <iostream>
using boost::dummyT;
@ -229,12 +228,12 @@ int main()
filter_iter(one_or_four(), array, array+N)
, dummyT(1), dummyT(4));
BOOST_STATIC_ASSERT(
(!boost::is_convertible<
static_assert(
!std::is_convertible<
boost::iterator_traversal<filter_iter>::type
, boost::random_access_traversal_tag
>::value
));
>::value,
"");
//# endif

5
test/function_input_iterator_test.cpp
View File

@ -11,14 +11,12 @@
#include <boost/config.hpp>
#if !defined(BOOST_NO_CXX11_DECLTYPE)
// Force boost::result_of use decltype, even on compilers that don't support N3276.
// This enables this test to also verify if the iterator works with lambdas
// on such compilers with this config macro. Note that without the macro result_of
// (and consequently the iterator) is guaranteed to _not_ work, so this case is not
// worth testing anyway.
#define BOOST_RESULT_OF_USE_DECLTYPE
#endif
#include <boost/core/lightweight_test.hpp>
#include <boost/iterator/function_input_iterator.hpp>
@ -108,8 +106,6 @@ int main()
BOOST_TEST_EQ(*it3, 54);
}
#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
&& defined(BOOST_RESULT_OF_USE_DECLTYPE)
// test the iterator with lambda expressions
int num = 42;
auto lambda_generator = [&num] { return num++; };
@ -123,7 +119,6 @@ int main()
BOOST_TEST_EQ(generated.size(), 10u);
for(std::size_t i = 0; i != 10; ++i)
BOOST_TEST_EQ(generated[i], static_cast<int>(42 + i));
#endif // BOOST_NO_CXX11_LAMBDAS
return boost::report_errors();
}

2
test/function_output_iterator_test.cpp
View File

@ -44,7 +44,6 @@ int main()
BOOST_TEST_EQ(n, 6);
}
#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
{
int n = 0;
auto it = boost::iterators::make_function_output_iterator([&n](int x) { n -= x; });
@ -57,7 +56,6 @@ int main()
BOOST_TEST_EQ(n, -6);
}
#endif
#if defined(__cpp_lib_concepts) && ( __cpp_lib_concepts >= 202002L )
{

24
test/indirect_iter_member_types.cpp
View File

@ -9,12 +9,10 @@
#include <boost/config.hpp>
#include <iostream>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/static_assert.hpp>
#include "static_assert_same.hpp"
#include <boost/type_traits/same_traits.hpp>
#include <type_traits>
struct zow { };
@ -40,10 +38,12 @@ int main()
STATIC_ASSERT_SAME(Iter::pointer, int*);
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
std::random_access_iterator_tag>::value));
BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
boost::random_access_traversal_tag>::value));
static_assert(std::is_convertible<Iter::iterator_category,
std::random_access_iterator_tag>::value,
"");
static_assert(std::is_convertible<boost::iterator_traversal<Iter>::type,
boost::random_access_traversal_tag>::value,
"");
}
{
typedef boost::indirect_iterator<int const**> Iter;
@ -71,10 +71,12 @@ int main()
STATIC_ASSERT_SAME(Iter::difference_type, std::ptrdiff_t);
BOOST_STATIC_ASSERT((boost::is_convertible<Iter::iterator_category,
std::random_access_iterator_tag>::value));
BOOST_STATIC_ASSERT((boost::is_convertible<boost::iterator_traversal<Iter>::type,
boost::random_access_traversal_tag>::value));
static_assert(std::is_convertible<Iter::iterator_category,
std::random_access_iterator_tag>::value,
"");
static_assert(std::is_convertible<boost::iterator_traversal<Iter>::type,
boost::random_access_traversal_tag>::value,
"");
}
{
typedef boost::indirect_iterator<char**, int, std::random_access_iterator_tag, long&, short> Iter;

3
test/is_convertible_fail.cpp
View File

@ -8,12 +8,13 @@
//
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/cstdlib.hpp>
#include <type_traits>
int main()
{
typedef boost::reverse_iterator<int*> rev_iter1;
typedef boost::reverse_iterator<char*> rev_iter2;
return boost::is_convertible<rev_iter1, rev_iter2>::value
return std::is_convertible<rev_iter1, rev_iter2>::value
? boost::exit_failure : boost::exit_success;
}

74
test/is_lvalue_iterator.cpp
View File

@ -4,9 +4,7 @@
#include <deque>
#include <iterator>
#include <iostream>
#include <cstddef> // std::ptrdiff_t
#include <boost/static_assert.hpp>
#include <boost/noncopyable.hpp>
#include <boost/iterator/is_lvalue_iterator.hpp>
@ -91,58 +89,58 @@ struct constant_lvalue_iterator
int main()
{
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<v*>::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<v const*>::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<std::deque<v>::iterator>::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value);
BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value);
BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<std::ostream_iterator<v> >::value);
BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<proxy_iterator<v> >::value);
BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<proxy_iterator<int> >::value);
static_assert(boost::is_lvalue_iterator<v*>::value, "");
static_assert(boost::is_lvalue_iterator<v const*>::value, "");
static_assert(boost::is_lvalue_iterator<std::deque<v>::iterator>::value, "");
static_assert(boost::is_lvalue_iterator<std::deque<v>::const_iterator>::value, "");
static_assert(!boost::is_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value, "");
static_assert(!boost::is_lvalue_iterator<std::ostream_iterator<v> >::value, "");
static_assert(!boost::is_lvalue_iterator<proxy_iterator<v> >::value, "");
static_assert(!boost::is_lvalue_iterator<proxy_iterator<int> >::value, "");
#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(!boost::is_lvalue_iterator<value_iterator>::value);
static_assert(!boost::is_lvalue_iterator<value_iterator>::value, "");
#endif
// Make sure inaccessible copy constructor doesn't prevent
// reference binding
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<noncopyable_iterator>::value);
static_assert(boost::is_lvalue_iterator<noncopyable_iterator>::value, "");
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<v> >::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<int> >::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<lvalue_iterator<float> >::value);
static_assert(boost::is_lvalue_iterator<lvalue_iterator<v> >::value, "");
static_assert(boost::is_lvalue_iterator<lvalue_iterator<int> >::value, "");
static_assert(boost::is_lvalue_iterator<lvalue_iterator<char*> >::value, "");
static_assert(boost::is_lvalue_iterator<lvalue_iterator<float> >::value, "");
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value);
static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<v> >::value, "");
static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<int> >::value, "");
static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<char*> >::value, "");
static_assert(boost::is_lvalue_iterator<constant_lvalue_iterator<float> >::value, "");
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<v*>::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<v const*>::value);
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<std::ostream_iterator<v> >::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<proxy_iterator<v> >::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<proxy_iterator<int> >::value);
static_assert(boost::is_non_const_lvalue_iterator<v*>::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<v const*>::value, "");
static_assert(boost::is_non_const_lvalue_iterator<std::deque<v>::iterator>::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<std::deque<v>::const_iterator>::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<std::back_insert_iterator<std::deque<v> > >::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<std::ostream_iterator<v> >::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<proxy_iterator<v> >::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<proxy_iterator<int> >::value, "");
#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<value_iterator>::value);
static_assert(!boost::is_non_const_lvalue_iterator<value_iterator>::value, "");
#endif
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value);
static_assert(!boost::is_non_const_lvalue_iterator<noncopyable_iterator>::value, "");
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value);
static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<v> >::value, "");
#if !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value);
static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<int> >::value, "");
#endif
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value);
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value);
static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<char*> >::value, "");
static_assert(boost::is_non_const_lvalue_iterator<lvalue_iterator<float> >::value, "");
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value);
BOOST_STATIC_ASSERT(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value);
static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<v> >::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<int> >::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<char*> >::value, "");
static_assert(!boost::is_non_const_lvalue_iterator<constant_lvalue_iterator<float> >::value, "");
return 0;
}

22
test/is_readable_iterator.cpp
View File

@ -4,9 +4,7 @@
#include <deque>
#include <iterator>
#include <iostream>
#include <cstddef> // std::ptrdiff_t
#include <boost/static_assert.hpp>
#include <boost/noncopyable.hpp>
#include <boost/iterator/is_readable_iterator.hpp>
@ -78,19 +76,19 @@ struct proxy_iterator2
int main()
{
BOOST_STATIC_ASSERT(boost::is_readable_iterator<v*>::value);
BOOST_STATIC_ASSERT(boost::is_readable_iterator<v const*>::value);
BOOST_STATIC_ASSERT(boost::is_readable_iterator<std::deque<v>::iterator>::value);
BOOST_STATIC_ASSERT(boost::is_readable_iterator<std::deque<v>::const_iterator>::value);
BOOST_STATIC_ASSERT(!boost::is_readable_iterator<std::back_insert_iterator<std::deque<v> > >::value);
BOOST_STATIC_ASSERT(!boost::is_readable_iterator<std::ostream_iterator<v> >::value);
BOOST_STATIC_ASSERT(boost::is_readable_iterator<proxy_iterator>::value);
BOOST_STATIC_ASSERT(!boost::is_readable_iterator<proxy_iterator2>::value);
BOOST_STATIC_ASSERT(boost::is_readable_iterator<value_iterator>::value);
static_assert(boost::is_readable_iterator<v*>::value, "");
static_assert(boost::is_readable_iterator<v const*>::value, "");
static_assert(boost::is_readable_iterator<std::deque<v>::iterator>::value, "");
static_assert(boost::is_readable_iterator<std::deque<v>::const_iterator>::value, "");
static_assert(!boost::is_readable_iterator<std::back_insert_iterator<std::deque<v> > >::value, "");
static_assert(!boost::is_readable_iterator<std::ostream_iterator<v> >::value, "");
static_assert(boost::is_readable_iterator<proxy_iterator>::value, "");
static_assert(!boost::is_readable_iterator<proxy_iterator2>::value, "");
static_assert(boost::is_readable_iterator<value_iterator>::value, "");
// Make sure inaccessible copy constructor doesn't prevent
// readability
BOOST_STATIC_ASSERT(boost::is_readable_iterator<noncopyable_iterator>::value);
static_assert(boost::is_readable_iterator<noncopyable_iterator>::value, "");
return 0;
}

2
test/iterator_adaptor_cc.cpp
View File

@ -27,7 +27,7 @@ int main()
#if defined(__SGI_STL_PORT) \
|| !BOOST_WORKAROUND(__GNUC__, <= 2) \
&& !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1)) \
&& !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) \
&& !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) \
&& !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29)) \
&& !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)
{

10
test/iterator_adaptor_test.cpp
View File

@ -209,7 +209,7 @@ main()
test = static_assert_same<Iter1::pointer, int*>::value;
test = static_assert_same<Iter1::difference_type, std::ptrdiff_t>::value;
#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
BOOST_STATIC_ASSERT((boost::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value));
static_assert(std::is_convertible<Iter1::iterator_category, std::random_access_iterator_tag>::value, "");
#endif
}
@ -220,9 +220,9 @@ main()
test = static_assert_same<Iter1::reference, const int&>::value;
#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
BOOST_STATIC_ASSERT(boost::is_readable_iterator<Iter1>::value);
static_assert(boost::is_readable_iterator<Iter1>::value, "");
# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter1>::value);
static_assert(boost::is_lvalue_iterator<Iter1>::value, "");
# endif
#endif
@ -243,8 +243,8 @@ main()
#endif
#ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(boost::is_non_const_lvalue_iterator<BaseIter>::value);
BOOST_STATIC_ASSERT(boost::is_lvalue_iterator<Iter>::value);
static_assert(boost::is_non_const_lvalue_iterator<BaseIter>::value, "");
static_assert(boost::is_lvalue_iterator<Iter>::value, "");
#endif
typedef modify_traversal<BaseIter, boost::incrementable_traversal_tag> IncrementableIter;

7
test/iterator_facade.cpp
View File

@ -8,8 +8,7 @@
#include <boost/iterator/new_iterator_tests.hpp>
#include <boost/call_traits.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/core/enable_if.hpp>
#include <type_traits>
// This is a really, really limited test so far. All we're doing
// right now is checking that the postfix++ proxy for single-pass
@ -120,7 +119,7 @@ struct wrapper
{ }
template <class U>
wrapper(const wrapper<U>& other,
typename boost::enable_if< boost::is_convertible<U,T> >::type* = 0)
typename std::enable_if< std::is_convertible<U,T>::value >::type* = 0)
: m_x(other.m_x)
{ }
};
@ -146,7 +145,7 @@ struct iterator_with_proxy_reference
template <class T, class U>
void same_type(U const&)
{ BOOST_STATIC_ASSERT((boost::is_same<T,U>::value)); }
{ static_assert(std::is_same<T,U>::value, ""); }
template <class I, class A>
struct abstract_iterator

6
test/iterator_traits_test.cpp
View File

@ -20,15 +20,13 @@
// reference type from operator* (David Abrahams)
// 19 Jan 2001 Initial version with iterator operators (David Abrahams)
#include <boost/type_traits/is_same.hpp>
#include <boost/operators.hpp>
#include <boost/static_assert.hpp>
#include <boost/config.hpp>
#include <iterator>
#include <vector>
#include <list>
#include <boost/core/lightweight_test.hpp>
#include <iostream>
#include <type_traits>
// A UDT for which we can specialize std::iterator_traits<element*> on
// compilers which don't support partial specialization. There's no
@ -98,7 +96,7 @@ template <> struct assertion<true>
template <class T, class U>
struct assert_same
: assertion<(::boost::is_same<T,U>::value)>
: assertion<(std::is_same<T,U>::value)>
{
};

4
test/minimum_category.cpp
View File

@ -6,10 +6,10 @@
#include <boost/iterator/minimum_category.hpp>
#include <boost/core/lightweight_test_trait.hpp>
#include <boost/type_traits/is_same.hpp>
#include <iterator>
#include <type_traits>
using boost::is_same;
using std::is_same;
using boost::iterators::minimum_category;
int main(int, char*[])

3
test/permutation_iterator_test.cpp
View File

@ -8,7 +8,6 @@
#include <boost/core/lightweight_test.hpp>
#include <boost/iterator/permutation_iterator.hpp>
#include <boost/static_assert.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/concept/assert.hpp>
@ -44,7 +43,7 @@ void permutation_test()
const int element_range_size = 10;
const int index_size = 7;
BOOST_STATIC_ASSERT(index_size <= element_range_size);
static_assert(index_size <= element_range_size, "");
element_range_type elements( element_range_size );
for( element_range_type::iterator el_it = elements.begin(); el_it != elements.end(); ++el_it )
{ *el_it = std::distance(elements.begin(), el_it); }

4
test/pointee.cpp
View File

@ -3,10 +3,10 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <boost/pointee.hpp>
#include <boost/type_traits/add_const.hpp>
#include "static_assert_same.hpp"
#include <memory>
#include <list>
#include <type_traits>
template <class T, class Ref>
struct proxy_ptr
@ -27,7 +27,7 @@ struct proxy_ref_ptr : proxy_ptr<T,T&>
template <class T>
struct proxy_value_ptr : proxy_ptr<T,T>
{
typedef typename boost::add_const<T>::type element_type;
typedef typename std::add_const<T>::type element_type;
};
struct X {

1
test/range_distance_compat_test.cpp
View File

@ -5,6 +5,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/range/distance.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/iterator/distance.hpp>

2
test/reverse_iterator_test.cpp
View File

@ -161,7 +161,7 @@ int main()
#if defined(__SGI_STL_PORT) \
|| !BOOST_WORKAROUND(__GNUC__, <= 2) \
&& !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 1)) \
&& !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) \
&& !BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) \
&& !BOOST_WORKAROUND(__LIBCOMO_VERSION__, BOOST_TESTED_AT(29)) \
&& !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 1)

5
test/static_assert_same.hpp
View File

@ -5,10 +5,9 @@
#ifndef STATIC_ASSERT_SAME_DWA2003530_HPP
# define STATIC_ASSERT_SAME_DWA2003530_HPP
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
#define STATIC_ASSERT_SAME( T1,T2 ) BOOST_STATIC_ASSERT((::boost::is_same< T1, T2 >::value))
#define STATIC_ASSERT_SAME( T1,T2 ) static_assert(std::is_same<T1, T2>::value, "")
template <class T1, class T2>
struct static_assert_same

12
test/transform_iterator_test.cpp
View File

@ -172,20 +172,20 @@ main()
{
{
typedef boost::transform_iterator<adaptable_mult_functor, int*, float> iter_t;
BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference, float>::value));
BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, float>::value));
static_assert(boost::is_same<iter_t::reference, float>::value, "");
static_assert(boost::is_same<iter_t::value_type, float>::value, "");
}
{
typedef boost::transform_iterator<adaptable_mult_functor, int*, boost::use_default, float> iter_t;
BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference, int>::value));
BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, float>::value));
static_assert(boost::is_same<iter_t::reference, int>::value, "");
static_assert(boost::is_same<iter_t::value_type, float>::value, "");
}
{
typedef boost::transform_iterator<adaptable_mult_functor, int*, float, double> iter_t;
BOOST_STATIC_ASSERT((boost::is_same<iter_t::reference, float>::value));
BOOST_STATIC_ASSERT((boost::is_same<iter_t::value_type, double>::value));
static_assert(boost::is_same<iter_t::reference, float>::value, "");
static_assert(boost::is_same<iter_t::value_type, double>::value, "");
}
}

39
test/unit_tests.cpp
View File

@ -3,10 +3,10 @@
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/static_assert.hpp>
#include "static_assert_same.hpp"
#include <type_traits>
#include <boost/iterator/minimum_category.hpp>
struct X { int a; };
@ -38,32 +38,41 @@ void category_test()
using namespace boost::iterators;
using namespace boost::iterators::detail;
BOOST_STATIC_ASSERT((
!boost::is_convertible<
static_assert(
!std::is_convertible<
std::input_iterator_tag
, input_output_iterator_tag>::value));
, input_output_iterator_tag>::value,
"");
BOOST_STATIC_ASSERT((
!boost::is_convertible<
static_assert(
!std::is_convertible<
std::output_iterator_tag
, input_output_iterator_tag>::value));
, input_output_iterator_tag
>::value,
"");
BOOST_STATIC_ASSERT((
boost::is_convertible<
static_assert(
std::is_convertible<
input_output_iterator_tag
, std::input_iterator_tag>::value));
, std::input_iterator_tag
>::value,
"");
BOOST_STATIC_ASSERT((
boost::is_convertible<
static_assert(
std::is_convertible<
input_output_iterator_tag
, std::output_iterator_tag>::value));
, std::output_iterator_tag
>::value,
"");
#if 0 // This seems wrong; we're not advertising
// input_output_iterator_tag are we?
BOOST_STATIC_ASSERT((
static_assert(
boost::is_convertible<
std::forward_iterator_tag
, input_output_iterator_tag>::value));
, input_output_iterator_tag
>::value,
"");
#endif
int test = static_assert_min_cat<