?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/iterator.zip
???????
PK h!\ܧE$L L distance.hppnu �[��� // Copyright (C) 2017 Michel Morin. // // 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_ITERATOR_DISTANCE_HPP #define BOOST_ITERATOR_DISTANCE_HPP #include <boost/config.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/iterator/iterator_traits.hpp> namespace boost { namespace iterators { namespace detail { template <typename SinglePassIterator> inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type distance_impl( SinglePassIterator first , SinglePassIterator last , single_pass_traversal_tag ) { typename iterator_difference<SinglePassIterator>::type n = 0; while (first != last) { ++first; ++n; } return n; } template <typename RandomAccessIterator> inline BOOST_CXX14_CONSTEXPR typename iterator_difference<RandomAccessIterator>::type distance_impl( RandomAccessIterator first , RandomAccessIterator last , random_access_traversal_tag ) { return last - first; } } namespace distance_adl_barrier { template <typename SinglePassIterator> inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type distance(SinglePassIterator first, SinglePassIterator last) { return detail::distance_impl( first, last, typename iterator_traversal<SinglePassIterator>::type() ); } } using namespace distance_adl_barrier; } // namespace iterators using namespace iterators::distance_adl_barrier; } // namespace boost #endif PK h!\�mI�� � function_input_iterator.hppnu �[��� // Copyright 2009 (C) Dean Michael Berris <me@deanberris.com> // Copyright 2012 (C) Google, Inc. // Copyright 2012 (C) Jeffrey Lee Hellrung, Jr. // 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_FUNCTION_INPUT_ITERATOR #define BOOST_FUNCTION_INPUT_ITERATOR #include <boost/config.hpp> #include <boost/assert.hpp> #include <boost/core/addressof.hpp> #include <boost/mpl/if.hpp> #include <boost/function_types/is_function_pointer.hpp> #include <boost/function_types/result_type.hpp> #include <boost/iterator/iterator_facade.hpp> #include <boost/none.hpp> #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 { namespace impl { // Computes the return type of an lvalue-call with an empty argument, // i.e. decltype(declval<F&>()()). F should be a nullary lvalue-callable // or function. template <class F> struct result_of_nullary_lvalue_call { typedef typename result_of< #ifdef BOOST_RESULT_OF_USE_TR1 typename mpl::if_<is_function<F>, F&, F>::type() #else F&() #endif >::type type; }; template <class Function, class Input> class function_input_iterator : public iterator_facade< function_input_iterator<Function, Input>, typename result_of_nullary_lvalue_call<Function>::type, single_pass_traversal_tag, typename result_of_nullary_lvalue_call<Function>::type const & > { public: function_input_iterator() {} function_input_iterator(Function & f_, Input state_ = Input()) : f(boost::addressof(f_)), state(state_) {} void increment() { if(value) value = none; else (*f)(); ++state; } typename result_of_nullary_lvalue_call<Function>::type const & dereference() const { return (value ? value : value = (*f)()).get(); } bool equal(function_input_iterator const & other) const { return f == other.f && state == other.state; } private: Function * f; Input state; mutable optional<typename result_of_nullary_lvalue_call<Function>::type> value; }; template <class Function, class Input> class function_pointer_input_iterator : public iterator_facade< function_pointer_input_iterator<Function, Input>, typename function_types::result_type<Function>::type, single_pass_traversal_tag, typename function_types::result_type<Function>::type const & > { public: function_pointer_input_iterator() {} function_pointer_input_iterator(Function &f_, Input state_ = Input()) : f(f_), state(state_) {} void increment() { if(value) value = none; else (*f)(); ++state; } typename function_types::result_type<Function>::type const & dereference() const { return (value ? value : value = (*f)()).get(); } bool equal(function_pointer_input_iterator const & other) const { return f == other.f && state == other.state; } private: Function f; Input state; mutable optional<typename function_types::result_type<Function>::type> value; }; } // namespace impl template <class Function, class Input> class function_input_iterator : public mpl::if_< function_types::is_function_pointer<Function>, impl::function_pointer_input_iterator<Function,Input>, impl::function_input_iterator<Function,Input> >::type { typedef typename mpl::if_< function_types::is_function_pointer<Function>, impl::function_pointer_input_iterator<Function,Input>, impl::function_input_iterator<Function,Input> >::type base_type; public: function_input_iterator(Function & f, Input i) : base_type(f, i) {} }; template <class Function, class Input> inline function_input_iterator<Function, Input> make_function_input_iterator(Function & f, Input state) { typedef function_input_iterator<Function, Input> result_t; return result_t(f, state); } template <class Function, class Input> inline function_input_iterator<Function*, Input> make_function_input_iterator(Function * f, Input state) { typedef function_input_iterator<Function*, Input> result_t; return result_t(f, state); } struct infinite { infinite & operator++() { return *this; } infinite & operator++(int) { return *this; } bool operator==(infinite &) const { return false; }; bool operator==(infinite const &) const { return false; }; }; } // namespace iterators using iterators::function_input_iterator; using iterators::make_function_input_iterator; using iterators::infinite; } // namespace boost #endif PK h!\U�� � minimum_category.hppnu �[��� // Copyright David Abrahams 2003. 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) #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 <boost/mpl/placeholders.hpp> # include <boost/mpl/aux_/lambda_support.hpp> namespace boost { namespace iterators { namespace detail { template <bool GreaterEqual, bool LessEqual> struct minimum_category_impl; template <class T1, class T2> struct error_not_related_by_convertibility; template <> struct minimum_category_impl<true,false> { template <class T1, class T2> struct apply { typedef T2 type; }; }; template <> struct minimum_category_impl<false,true> { template <class T1, class T2> struct apply { typedef T1 type; }; }; template <> struct minimum_category_impl<true,true> { template <class T1, class T2> struct apply { BOOST_STATIC_ASSERT((is_same<T1,T2>::value)); typedef T1 type; }; }; template <> struct minimum_category_impl<false,false> { template <class T1, class T2> struct apply : error_not_related_by_convertibility<T1,T2> { }; }; } // namespace detail // // Returns the minimum category type or fails to compile // if T1 and T2 are unrelated. // 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 > outer; typedef typename outer::template apply<T1,T2> inner; typedef typename inner::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2)) }; template <> struct minimum_category<mpl::_1,mpl::_2> { template <class T1, class T2> struct apply : minimum_category<T1,T2> {}; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2)) }; } // namespace iterators } // namespace boost #endif // BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_ PK h!\}[fu! ! transform_iterator.hppnu �[��� // (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_TRANSFORM_ITERATOR_23022003THW_HPP #define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP #include <boost/iterator/detail/enable_if.hpp> #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/mpl/not.hpp> #include <boost/mpl/bool.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 <iterator> #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) # include <boost/type_traits/is_base_and_derived.hpp> #endif #include <boost/iterator/detail/config_def.hpp> namespace boost { namespace iterators { template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default> class transform_iterator; namespace detail { // Compute the iterator_adaptor instantiation to be used for transform_iterator template <class UnaryFunc, class Iterator, class Reference, class Value> struct transform_iterator_base { private: // By default, dereferencing the iterator yields the same as // the function. typedef typename ia_dflt_help< Reference #ifdef BOOST_RESULT_OF_USE_TR1 , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)> #else , result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)> #endif >::type reference; // To get the default for Value: remove any reference on the // result type, but retain any constness to signal // non-writability. Note that if we adopt Thomas' suggestion // to key non-writability *only* on the Reference argument, // we'd need to strip constness here as well. typedef typename ia_dflt_help< Value , remove_reference<reference> >::type cv_value_type; public: typedef iterator_adaptor< transform_iterator<UnaryFunc, Iterator, Reference, Value> , Iterator , cv_value_type , use_default // Leave the traversal category alone , reference > type; }; } template <class UnaryFunc, class Iterator, class Reference, class Value> class transform_iterator : public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type { typedef typename boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type super_t; friend class iterator_core_access; public: transform_iterator() { } transform_iterator(Iterator const& x, UnaryFunc f) : super_t(x), m_f(f) { } explicit transform_iterator(Iterator const& x) : super_t(x) { // Pro8 is a little too aggressive about instantiating the // body of this function. #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); #endif } template < class OtherUnaryFunction , class OtherIterator , class OtherReference , class OtherValue> transform_iterator( transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310) , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0 #endif ) : super_t(t.base()), m_f(t.functor()) {} UnaryFunc functor() const { return m_f; } private: typename super_t::reference dereference() const { return m_f(*this->base()); } // Probably should be the initial base class so it can be // optimized away via EBO if it is an empty class. UnaryFunc m_f; }; template <class UnaryFunc, class Iterator> inline transform_iterator<UnaryFunc, Iterator> make_transform_iterator(Iterator it, UnaryFunc fun) { return transform_iterator<UnaryFunc, Iterator>(it, fun); } // Version which allows explicit specification of the UnaryFunc // type. // // This generator is not provided if UnaryFunc is a function // pointer type, because it's too dangerous: the default-constructed // 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<> , transform_iterator<UnaryFunc, Iterator> >::type make_transform_iterator(Iterator it) { return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc()); } #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) template <class Return, class Argument, class Iterator> inline transform_iterator< Return (*)(Argument), Iterator, Return> make_transform_iterator(Iterator it, Return (*fun)(Argument)) { return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun); } #endif } // namespace iterators using iterators::transform_iterator; using iterators::make_transform_iterator; } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP PK h!\���� � iterator_traits.hppnu �[��� // Copyright David Abrahams 2003. // 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 ITERATOR_TRAITS_DWA200347_HPP # define ITERATOR_TRAITS_DWA200347_HPP # include <boost/detail/workaround.hpp> #include <iterator> namespace boost { namespace iterators { // Macro for supporting old compilers, no longer needed but kept // for backwards compatibility (it was documented). #define BOOST_ITERATOR_CATEGORY iterator_category template <class Iterator> struct iterator_value { typedef typename std::iterator_traits<Iterator>::value_type type; }; template <class Iterator> struct iterator_reference { typedef typename std::iterator_traits<Iterator>::reference type; }; template <class Iterator> struct iterator_pointer { typedef typename std::iterator_traits<Iterator>::pointer type; }; template <class Iterator> struct iterator_difference { typedef typename std::iterator_traits<Iterator>::difference_type type; }; template <class Iterator> struct iterator_category { typedef typename std::iterator_traits<Iterator>::iterator_category type; }; } // namespace iterators using iterators::iterator_value; using iterators::iterator_reference; using iterators::iterator_pointer; using iterators::iterator_difference; using iterators::iterator_category; } // namespace boost #endif // ITERATOR_TRAITS_DWA200347_HPP PK h!\y�ޡ< �< iterator_archetypes.hppnu �[��� // (C) Copyright Jeremy Siek 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_ITERATOR_ARCHETYPES_HPP #define BOOST_ITERATOR_ARCHETYPES_HPP #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 <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> namespace boost { namespace iterators { template <class Value, class AccessCategory> struct access_archetype; template <class Derived, class Value, class AccessCategory, class TraversalCategory> struct traversal_archetype; namespace archetypes { enum { readable_iterator_bit = 1 , writable_iterator_bit = 2 , swappable_iterator_bit = 4 , lvalue_iterator_bit = 8 }; // Not quite tags, since dispatching wouldn't work. typedef mpl::int_<readable_iterator_bit>::type readable_iterator_t; typedef mpl::int_<writable_iterator_bit>::type writable_iterator_t; typedef mpl::int_< (readable_iterator_bit|writable_iterator_bit) >::type readable_writable_iterator_t; typedef mpl::int_< (readable_iterator_bit|lvalue_iterator_bit) >::type readable_lvalue_iterator_t; typedef mpl::int_< (lvalue_iterator_bit|writable_iterator_bit) >::type writable_lvalue_iterator_t; typedef mpl::int_<swappable_iterator_bit>::type swappable_iterator_t; typedef mpl::int_<lvalue_iterator_bit>::type lvalue_iterator_t; template <class Derived, class Base> struct has_access : mpl::equal_to< mpl::bitand_<Derived,Base> , Base > {}; } namespace detail { template <class T> struct assign_proxy { assign_proxy& operator=(T) { return *this; } }; template <class T> struct read_proxy { operator T() { return static_object<T>::get(); } }; template <class T> struct read_write_proxy : read_proxy<T> // Use to inherit from assign_proxy, but that doesn't work. -JGS { read_write_proxy& operator=(T) { return *this; } }; template <class T> struct arrow_proxy { T const* operator->() const { return 0; } }; struct no_operator_brackets {}; template <class ValueType> struct readable_operator_brackets { read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); } }; template <class ValueType> struct writable_operator_brackets { read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); } }; template <class Value, class AccessCategory, class TraversalCategory> struct operator_brackets : mpl::eval_if< 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_< archetypes::has_access< AccessCategory , archetypes::readable_iterator_t > , readable_operator_brackets<Value> , no_operator_brackets > > , mpl::identity<no_operator_brackets> >::type {}; template <class TraversalCategory> struct traversal_archetype_impl { template <class Derived,class Value> struct archetype; }; // Constructor argument for those iterators that // are not default constructible struct ctor_arg {}; template <class Derived, class Value, class TraversalCategory> struct traversal_archetype_ : traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value> { typedef typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value> base; traversal_archetype_() {} traversal_archetype_(ctor_arg arg) : base(arg) {} }; template <> struct traversal_archetype_impl<incrementable_traversal_tag> { template<class Derived, class Value> struct archetype { explicit archetype(ctor_arg) {} struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS typedef bogus difference_type; Derived& operator++() { return (Derived&)static_object<Derived>::get(); } Derived operator++(int) const { return (Derived&)static_object<Derived>::get(); } }; }; template <> struct traversal_archetype_impl<single_pass_traversal_tag> { template<class Derived, class Value> struct archetype : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >, public traversal_archetype_<Derived, Value, incrementable_traversal_tag> { explicit archetype(ctor_arg arg) : traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg) {} typedef std::ptrdiff_t difference_type; }; }; template <class Derived, class Value> bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&, traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; } template <> struct traversal_archetype_impl<forward_traversal_tag> { template<class Derived, class Value> struct archetype : public traversal_archetype_<Derived, Value, single_pass_traversal_tag> { archetype() : traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg()) {} }; }; template <> struct traversal_archetype_impl<bidirectional_traversal_tag> { template<class Derived, class Value> struct archetype : public traversal_archetype_<Derived, Value, forward_traversal_tag> { Derived& operator--() { return static_object<Derived>::get(); } Derived operator--(int) const { return static_object<Derived>::get(); } }; }; template <> struct traversal_archetype_impl<random_access_traversal_tag> { template<class Derived, class Value> struct archetype : public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> { Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); } Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); } }; }; template <class Derived, class Value> Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, std::ptrdiff_t) { return static_object<Derived>::get(); } template <class Derived, class Value> Derived& operator+(std::ptrdiff_t, traversal_archetype_<Derived, Value, random_access_traversal_tag> const&) { return static_object<Derived>::get(); } template <class Derived, class Value> Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, std::ptrdiff_t) { return static_object<Derived>::get(); } template <class Derived, class Value> std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, traversal_archetype_<Derived, Value, random_access_traversal_tag> const&) { return 0; } template <class Derived, class Value> bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, traversal_archetype_<Derived, Value, random_access_traversal_tag> const&) { return true; } template <class Derived, class Value> bool operator>(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, traversal_archetype_<Derived, Value, random_access_traversal_tag> const&) { return true; } template <class Derived, class Value> bool operator<=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, traversal_archetype_<Derived, Value, random_access_traversal_tag> const&) { return true; } template <class Derived, class Value> bool operator>=(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, traversal_archetype_<Derived, Value, random_access_traversal_tag> const&) { return true; } struct bogus_type; template <class Value> struct convertible_type : mpl::if_< is_const<Value>, typename remove_const<Value>::type, bogus_type > {}; } // namespace detail template <class> struct undefined; template <class AccessCategory> struct iterator_access_archetype_impl { template <class Value> struct archetype; }; template <class Value, class AccessCategory> struct iterator_access_archetype : iterator_access_archetype_impl< AccessCategory >::template archetype<Value> { }; template <> struct iterator_access_archetype_impl< archetypes::readable_iterator_t > { template <class Value> struct archetype { typedef typename remove_cv<Value>::type value_type; typedef Value reference; typedef Value* pointer; value_type operator*() const { return static_object<value_type>::get(); } detail::arrow_proxy<Value> operator->() const { return detail::arrow_proxy<Value>(); } }; }; template <> struct iterator_access_archetype_impl< archetypes::writable_iterator_t > { template <class Value> struct archetype { BOOST_STATIC_ASSERT(!is_const<Value>::value); typedef void value_type; typedef void reference; typedef void pointer; detail::assign_proxy<Value> operator*() const { return detail::assign_proxy<Value>(); } }; }; template <> struct iterator_access_archetype_impl< archetypes::readable_writable_iterator_t > { template <class Value> struct archetype : public virtual iterator_access_archetype< Value, archetypes::readable_iterator_t > { typedef detail::read_write_proxy<Value> reference; detail::read_write_proxy<Value> operator*() const { return detail::read_write_proxy<Value>(); } }; }; template <> struct iterator_access_archetype_impl<archetypes::readable_lvalue_iterator_t> { template <class Value> struct archetype : public virtual iterator_access_archetype< Value, archetypes::readable_iterator_t > { typedef Value& reference; Value& operator*() const { return static_object<Value>::get(); } Value* operator->() const { return 0; } }; }; template <> struct iterator_access_archetype_impl<archetypes::writable_lvalue_iterator_t> { template <class Value> struct archetype : public virtual iterator_access_archetype< Value, archetypes::readable_lvalue_iterator_t > { BOOST_STATIC_ASSERT((!is_const<Value>::value)); }; }; template <class Value, class AccessCategory, class TraversalCategory> struct iterator_archetype; template <class Value, class AccessCategory, class TraversalCategory> struct traversal_archetype_base : detail::operator_brackets< typename remove_cv<Value>::type , AccessCategory , TraversalCategory > , detail::traversal_archetype_< iterator_archetype<Value, AccessCategory, TraversalCategory> , Value , TraversalCategory > { }; namespace detail { template <class Value, class AccessCategory, class TraversalCategory> struct iterator_archetype_base : iterator_access_archetype<Value, AccessCategory> , traversal_archetype_base<Value, AccessCategory, TraversalCategory> { typedef iterator_access_archetype<Value, AccessCategory> access; typedef typename detail::facade_iterator_category< TraversalCategory , typename mpl::eval_if< archetypes::has_access< AccessCategory, archetypes::writable_iterator_t > , remove_const<Value> , add_const<Value> >::type , typename access::reference >::type iterator_category; // Needed for some broken libraries (see below) struct workaround_iterator_base { typedef typename iterator_archetype_base::iterator_category iterator_category; typedef Value value_type; typedef typename traversal_archetype_base< Value, AccessCategory, TraversalCategory >::difference_type difference_type; typedef typename access::pointer pointer; typedef typename access::reference reference; }; }; } template <class Value, class AccessCategory, class TraversalCategory> struct iterator_archetype : public detail::iterator_archetype_base<Value, AccessCategory, TraversalCategory> // These broken libraries require derivation from std::iterator // (or related magic) in order to handle iter_swap and other // iterator operations # if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \ || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101)) , public detail::iterator_archetype_base< Value, AccessCategory, TraversalCategory >::workaround_iterator_base # endif { // Derivation from std::iterator above caused references to nested // types to be ambiguous, so now we have to redeclare them all // here. # if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, < 310) \ || BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(0x20101)) typedef detail::iterator_archetype_base< Value,AccessCategory,TraversalCategory > base; typedef typename base::value_type value_type; typedef typename base::reference reference; typedef typename base::pointer pointer; typedef typename base::difference_type difference_type; typedef typename base::iterator_category iterator_category; # endif iterator_archetype() { } iterator_archetype(iterator_archetype const& x) : detail::iterator_archetype_base< Value , AccessCategory , TraversalCategory >(x) {} iterator_archetype& operator=(iterator_archetype const&) { return *this; } # if 0 // Optional conversion from mutable iterator_archetype( iterator_archetype< typename detail::convertible_type<Value>::type , AccessCategory , TraversalCategory> const& ); # endif }; } // namespace iterators // Backward compatibility names namespace iterator_archetypes = iterators::archetypes; using iterators::access_archetype; using iterators::traversal_archetype; using iterators::iterator_archetype; using iterators::undefined; using iterators::iterator_access_archetype_impl; using iterators::traversal_archetype_base; } // namespace boost #endif // BOOST_ITERATOR_ARCHETYPES_HPP PK h!\�É� � iterator_concepts.hppnu �[��� // (C) Copyright Jeremy Siek 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_ITERATOR_CONCEPTS_HPP #define BOOST_ITERATOR_CONCEPTS_HPP #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> // Use boost/limits to work around missing limits headers on some compilers #include <boost/limits.hpp> #include <boost/config.hpp> #include <algorithm> #include <iterator> #include <boost/concept/detail/concept_def.hpp> namespace boost_concepts { // Used a different namespace here (instead of "boost") so that the // concept descriptions do not take for granted the names in // namespace boost. //=========================================================================== // Iterator Access Concepts BOOST_concept(ReadableIterator,(Iterator)) : boost::Assignable<Iterator> , boost::CopyConstructible<Iterator> { typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type value_type; typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference reference; BOOST_CONCEPT_USAGE(ReadableIterator) { value_type v = *i; boost::ignore_unused_variable_warning(v); } private: Iterator i; }; template < typename Iterator , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type > struct WritableIterator : boost::CopyConstructible<Iterator> { BOOST_CONCEPT_USAGE(WritableIterator) { *i = v; } private: ValueType v; Iterator i; }; template < typename Iterator , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type > struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {}; BOOST_concept(SwappableIterator,(Iterator)) { BOOST_CONCEPT_USAGE(SwappableIterator) { std::iter_swap(i1, i2); } private: Iterator i1; Iterator i2; }; BOOST_concept(LvalueIterator,(Iterator)) { typedef typename std::iterator_traits<Iterator>::value_type value_type; BOOST_CONCEPT_USAGE(LvalueIterator) { value_type& r = const_cast<value_type&>(*i); boost::ignore_unused_variable_warning(r); } private: Iterator i; }; //=========================================================================== // Iterator Traversal Concepts BOOST_concept(IncrementableIterator,(Iterator)) : boost::Assignable<Iterator> , boost::CopyConstructible<Iterator> { typedef typename boost::iterator_traversal<Iterator>::type traversal_category; BOOST_CONCEPT_ASSERT(( boost::Convertible< traversal_category , boost::incrementable_traversal_tag >)); BOOST_CONCEPT_USAGE(IncrementableIterator) { ++i; (void)i++; } private: Iterator i; }; BOOST_concept(SinglePassIterator,(Iterator)) : IncrementableIterator<Iterator> , boost::EqualityComparable<Iterator> { BOOST_CONCEPT_ASSERT(( boost::Convertible< BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category , boost::single_pass_traversal_tag > )); }; BOOST_concept(ForwardTraversal,(Iterator)) : SinglePassIterator<Iterator> , boost::DefaultConstructible<Iterator> { typedef typename std::iterator_traits<Iterator>::difference_type difference_type; BOOST_MPL_ASSERT((boost::is_integral<difference_type>)); BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true); BOOST_CONCEPT_ASSERT(( boost::Convertible< BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category , boost::forward_traversal_tag > )); }; BOOST_concept(BidirectionalTraversal,(Iterator)) : ForwardTraversal<Iterator> { BOOST_CONCEPT_ASSERT(( boost::Convertible< BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category , boost::bidirectional_traversal_tag > )); BOOST_CONCEPT_USAGE(BidirectionalTraversal) { --i; (void)i--; } private: Iterator i; }; BOOST_concept(RandomAccessTraversal,(Iterator)) : BidirectionalTraversal<Iterator> { BOOST_CONCEPT_ASSERT(( boost::Convertible< BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category , boost::random_access_traversal_tag > )); BOOST_CONCEPT_USAGE(RandomAccessTraversal) { i += n; i = i + n; i = n + i; i -= n; i = i - n; n = i - j; } private: typename BidirectionalTraversal<Iterator>::difference_type n; Iterator i, j; }; //=========================================================================== // Iterator Interoperability namespace detail { template <typename Iterator1, typename Iterator2> void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2) { bool b; b = i1 == i2; b = i1 != i2; b = i2 == i1; b = i2 != i1; boost::ignore_unused_variable_warning(b); } template <typename Iterator1, typename Iterator2> void interop_rand_access_constraints( Iterator1 const& i1, Iterator2 const& i2, boost::random_access_traversal_tag, boost::random_access_traversal_tag) { bool b; typename std::iterator_traits<Iterator2>::difference_type n; b = i1 < i2; b = i1 <= i2; b = i1 > i2; b = i1 >= i2; n = i1 - i2; b = i2 < i1; b = i2 <= i1; b = i2 > i1; b = i2 >= i1; n = i2 - i1; boost::ignore_unused_variable_warning(b); boost::ignore_unused_variable_warning(n); } template <typename Iterator1, typename Iterator2> void interop_rand_access_constraints( Iterator1 const&, Iterator2 const&, boost::single_pass_traversal_tag, boost::single_pass_traversal_tag) { } } // namespace detail BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator)) { private: typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category; typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category; public: BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>)); BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>)); BOOST_CONCEPT_USAGE(InteroperableIterator) { detail::interop_single_pass_constraints(i, ci); detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category()); ci = i; } private: Iterator i; ConstIterator ci; }; } // namespace boost_concepts #include <boost/concept/detail/concept_undef.hpp> #endif // BOOST_ITERATOR_CONCEPTS_HPP PK h!\ ��ү� �� iterator_facade.hppnu �[��� // (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_ITERATOR_FACADE_23022003THW_HPP #define BOOST_ITERATOR_FACADE_23022003THW_HPP #include <boost/config.hpp> #include <boost/iterator/interoperable.hpp> #include <boost/iterator/iterator_traits.hpp> #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 <cstddef> #include <boost/iterator/detail/config_def.hpp> // this goes last namespace boost { namespace iterators { // This forward declaration is required for the friend declaration // in iterator_core_access template <class I, class V, class TC, class R, class D> class iterator_facade; namespace detail { // A binary metafunction class that always returns bool. VC6 // ICEs on mpl::always<bool>, probably because of the default // parameters. struct always_bool2 { template <class T, class U> struct apply { typedef bool type; }; }; // 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 > {}; // // enable if for use in operator implementation. // template < class Facade1 , class Facade2 , class Return > struct enable_if_interoperable : public boost::iterators::enable_if< is_interoperable< Facade1, Facade2 > , Return > {}; // // enable if for use in implementation of operators specific for random access traversal. // template < class Facade1 , class Facade2 , class Return > struct enable_if_interoperable_and_random_access_traversal : public boost::iterators::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 > > , Return > {}; // // Generates associated types for an iterator_facade with the // given parameters. // template < class ValueParam , class CategoryOrTraversal , class Reference , class Difference > struct iterator_facade_types { typedef typename facade_iterator_category< CategoryOrTraversal, ValueParam, Reference >::type iterator_category; typedef typename 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> >::type pointer; # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \ || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \ || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)) \ || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310) // To interoperate with some broken library/compiler // combinations, user-defined iterators must be derived from // std::iterator. It is possible to implement a standard // library for broken compilers without this limitation. # define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1 typedef iterator<iterator_category, value_type, Difference, pointer, Reference> base; # endif }; // iterators whose dereference operators reference the same value // for all iterators into the same sequence (like many input // iterators) need help with their postfix ++: the referenced // value must be read and stored away before the increment occurs // so that *a++ yields the originally referenced element and not // the next one. template <class Iterator> class postfix_increment_proxy { typedef typename iterator_value<Iterator>::type value_type; public: explicit postfix_increment_proxy(Iterator const& x) : stored_value(*x) {} // Returning a mutable reference allows nonsense like // (*r++).mutate(), but it imposes fewer assumptions about the // behavior of the value_type. In particular, recall that // (*r).mutate() is legal if operator* returns by value. value_type& operator*() const { return this->stored_value; } private: mutable value_type stored_value; }; // // In general, we can't determine that such an iterator isn't // writable -- we also need to store a copy of the old iterator so // that it can be written into. template <class Iterator> class writable_postfix_increment_proxy { typedef typename iterator_value<Iterator>::type value_type; public: explicit writable_postfix_increment_proxy(Iterator const& x) : stored_value(*x) , stored_iterator(x) {} // Dereferencing must return a proxy so that both *r++ = o and // value_type(*r++) can work. In this case, *r is the same as // *r++, and the conversion operator below is used to ensure // readability. writable_postfix_increment_proxy const& operator*() const { return *this; } // Provides readability of *r++ operator value_type&() const { return stored_value; } // Provides writability of *r++ template <class T> T const& operator=(T const& x) const { *this->stored_iterator = x; return x; } // This overload just in case only non-const objects are writable template <class T> T& operator=(T& x) const { *this->stored_iterator = x; return x; } // Provides X(r++) operator Iterator const&() const { return stored_iterator; } private: mutable value_type stored_value; Iterator stored_iterator; }; # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <class Reference, class Value> struct is_non_proxy_reference_impl { static Reference r; template <class R> static typename mpl::if_< is_convertible< R const volatile* , Value const volatile* > , char[1] , char[2] >::type& helper(R const&); BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1); }; template <class Reference, class Value> struct is_non_proxy_reference : mpl::bool_< is_non_proxy_reference_impl<Reference, Value>::value > {}; # else template <class Reference, class Value> struct is_non_proxy_reference : is_convertible< typename remove_reference<Reference>::type const volatile* , Value const volatile* > {}; # endif // A metafunction to choose the result type of postfix ++ // // Because the C++98 input iterator requirements say that *r++ has // type T (value_type), implementations of some standard // algorithms like lexicographical_compare may use constructions // like: // // *r++ < *s++ // // If *r++ returns a proxy (as required if r is writable but not // multipass), this sort of expression will fail unless the proxy // supports the operator<. Since there are any number of such // operations, we're not going to try to support them. Therefore, // even if r++ returns a proxy, *r++ will only return a proxy if // *r also returns a proxy. template <class Iterator, class Value, class Reference, class CategoryOrTraversal> struct postfix_increment_result : mpl::eval_if< mpl::and_< // A proxy is only needed for readable iterators 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 > // No multipass iterator can have values that disappear // before positions can be re-visited , mpl::not_< is_convertible< typename iterator_category_to_traversal<CategoryOrTraversal>::type , forward_traversal_tag > > > , mpl::if_< is_non_proxy_reference<Reference,Value> , postfix_increment_proxy<Iterator> , writable_postfix_increment_proxy<Iterator> > , mpl::identity<Iterator> > {}; // operator->() needs special support for input iterators to strictly meet the // standard's requirements. If *i is not a reference type, we must still // produce an lvalue to which a pointer can be formed. We do that by // returning a proxy object containing an instance of the reference object. template <class Reference, class Pointer> struct operator_arrow_dispatch // proxy references { struct proxy { explicit proxy(Reference const & x) : m_ref(x) {} Reference* operator->() { return boost::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); } Reference m_ref; }; typedef proxy result_type; static result_type apply(Reference const & x) { return result_type(x); } }; template <class T, class Pointer> struct operator_arrow_dispatch<T&, Pointer> // "real" references { typedef Pointer result_type; static result_type apply(T& x) { return boost::addressof(x); } }; // A proxy return type for operator[], needed to deal with // iterators that may invalidate referents upon destruction. // Consider the temporary iterator in *(a + n) template <class Iterator> class operator_brackets_proxy { // Iterator is actually an iterator_facade, so we do not have to // go through iterator_traits to access the traits. typedef typename Iterator::reference reference; typedef typename Iterator::value_type value_type; public: operator_brackets_proxy(Iterator const& iter) : m_iter(iter) {} operator reference() const { return *m_iter; } operator_brackets_proxy& operator=(value_type const& val) { *m_iter = val; return *this; } private: Iterator m_iter; }; // A metafunction that determines whether operator[] must return a // proxy, or whether it can simply return a copy of the value_type. template <class ValueType, class Reference> struct use_operator_brackets_proxy : mpl::not_< 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> , iterator_writability_disabled<ValueType,Reference> > > {}; template <class Iterator, class Value, class Reference> struct operator_brackets_result { typedef typename mpl::if_< use_operator_brackets_proxy<Value,Reference> , operator_brackets_proxy<Iterator> , Value >::type type; }; template <class Iterator> operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_) { return operator_brackets_proxy<Iterator>(iter); } template <class Iterator> typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_) { return *iter; } 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 {}; }; template < class Derived , class Value , class CategoryOrTraversal , class Reference , class Difference , bool IsBidirectionalTraversal , bool IsRandomAccessTraversal > class iterator_facade_base; } // namespace detail // 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 \ , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ > \ prefix typename enabler< \ Derived1, Derived2 \ , typename mpl::apply2<result_type,Derived1,Derived2>::type \ >::type \ 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) # define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type) \ BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal) # 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 \ >::type operator+ args // // Helper class for granting access to the iterator core interface. // // The simple core interface is used by iterator_facade. The core // interface of a user/library defined iterator type should not be made public // so that it does not clutter the public interface. Instead iterator_core_access // should be made friend so that iterator_facade can access the core // interface through iterator_core_access. // class iterator_core_access { # if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) // Tasteless as this may seem, making all members public allows member templates // to work in the absence of member template friends. public: # else template <class I, class V, class TC, class R, class D> friend class iterator_facade; template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal> friend class detail::iterator_facade_base; # define BOOST_ITERATOR_FACADE_RELATION(op) \ BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2); BOOST_ITERATOR_FACADE_RELATION(==) BOOST_ITERATOR_FACADE_RELATION(!=) # undef BOOST_ITERATOR_FACADE_RELATION # define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op) \ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2); BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=) # undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD( friend, -, boost::iterators::detail::choose_difference_type) ; BOOST_ITERATOR_FACADE_PLUS_HEAD( friend inline , (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type) ) ; BOOST_ITERATOR_FACADE_PLUS_HEAD( friend inline , (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&) ) ; # endif template <class Facade> static typename Facade::reference dereference(Facade const& f) { return f.dereference(); } template <class Facade> static void increment(Facade& f) { f.increment(); } template <class Facade> static void decrement(Facade& f) { f.decrement(); } template <class Facade1, class Facade2> static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_) { return f1.equal(f2); } template <class Facade1, class Facade2> static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_) { return f2.equal(f1); } template <class Facade> static void advance(Facade& f, typename Facade::difference_type n) { f.advance(n); } template <class Facade1, class Facade2> static typename Facade1::difference_type distance_from( Facade1 const& f1, Facade2 const& f2, mpl::true_) { 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_) { return f2.distance_to(f1); } // // Curiously Recurring Template interface. // template <class I, class V, class TC, class R, class D> static I& derived(iterator_facade<I,V,TC,R,D>& facade) { return *static_cast<I*>(&facade); } template <class I, class V, class TC, class R, class D> static I const& derived(iterator_facade<I,V,TC,R,D> const& facade) { return *static_cast<I const*>(&facade); } // objects of this class are useless BOOST_DELETED_FUNCTION(iterator_core_access()) }; namespace detail { // Implementation for forward traversal iterators template < class Derived , class Value , class CategoryOrTraversal , class Reference , class Difference > class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false > # ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE : public boost::iterators::detail::iterator_facade_types< Value, CategoryOrTraversal, Reference, Difference >::base # undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE # endif { private: typedef boost::iterators::detail::iterator_facade_types< Value, CategoryOrTraversal, Reference, Difference > associated_types; typedef boost::iterators::detail::operator_arrow_dispatch< Reference , typename associated_types::pointer > operator_arrow_dispatch_; public: typedef typename associated_types::value_type value_type; typedef Reference reference; typedef Difference difference_type; typedef typename operator_arrow_dispatch_::result_type pointer; typedef typename associated_types::iterator_category iterator_category; public: reference operator*() const { return iterator_core_access::dereference(this->derived()); } pointer operator->() const { return operator_arrow_dispatch_::apply(*this->derived()); } Derived& operator++() { iterator_core_access::increment(this->derived()); return this->derived(); } protected: // // Curiously Recurring Template interface. // Derived& derived() { return *static_cast<Derived*>(this); } Derived const& derived() const { return *static_cast<Derived const*>(this); } }; // Implementation for bidirectional traversal iterators template < class Derived , class Value , class CategoryOrTraversal , class Reference , class Difference > class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > : public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false > { public: Derived& operator--() { iterator_core_access::decrement(this->derived()); return this->derived(); } Derived operator--(int) { Derived tmp(this->derived()); --*this; return tmp; } }; // Implementation for random access traversal iterators template < class Derived , class Value , class CategoryOrTraversal , class Reference , class Difference > class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > : public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > { private: typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type; public: typedef typename base_type::reference reference; typedef typename base_type::difference_type difference_type; public: typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type operator[](difference_type n) const { typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy; return boost::iterators::detail::make_operator_brackets_result<Derived>( this->derived() + n , use_proxy() ); } Derived& operator+=(difference_type n) { iterator_core_access::advance(this->derived(), n); return this->derived(); } Derived& operator-=(difference_type n) { iterator_core_access::advance(this->derived(), -n); return this->derived(); } Derived operator-(difference_type x) const { Derived result(this->derived()); return result -= x; } }; } // namespace detail // // iterator_facade - use as a public base class for defining new // standard-conforming iterators. // template < class Derived // The derived iterator type being constructed , class Value , class CategoryOrTraversal , class Reference = Value& , class Difference = std::ptrdiff_t > class iterator_facade : public detail::iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value, detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value > { protected: // For use by derived classes typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_; }; template <class I, class V, class TC, class R, class D> inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type operator++( iterator_facade<I,V,TC,R,D>& i , int ) { typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type tmp(*static_cast<I*>(&i)); ++i; return tmp; } // // Comparison operator implementation. The library supplied operators // enables the user to provide fully interoperable constant/mutable // iterator types. I.e. the library provides all operators // for all mutable/constant iterator combinations. // // Note though that this kind of interoperability for constant/mutable // iterators is not required by the standard for container iterators. // All the standard asks for is a conversion mutable -> constant. // Most standard library implementations nowadays provide fully interoperable // iterator implementations, but there are still heavily used implementations // that do not provide them. (Actually it's even worse, they do not provide // them for only a few iterators.) // // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should // enable the user to turn off mixed type operators // // The library takes care to provide only the right operator overloads. // I.e. // // bool operator==(Iterator, Iterator); // bool operator==(ConstIterator, Iterator); // bool operator==(Iterator, ConstIterator); // bool operator==(ConstIterator, ConstIterator); // // ... // // In order to do so it uses c++ idioms that are not yet widely supported // by current compiler releases. The library is designed to degrade gracefully // in the face of compiler deficiencies. In general compiler // deficiencies result in less strict error checking and more obscure // error messages, functionality is not affected. // // For full operation compiler support for "Substitution Failure Is Not An Error" // (aka. enable_if) and boost::is_convertible is required. // // The following problems occur if support is lacking. // // Pseudo code // // --------------- // AdaptorA<Iterator1> a1; // AdaptorA<Iterator2> a2; // // // This will result in a no such overload error in full operation // // If enable_if or is_convertible is not supported // // The instantiation will fail with an error hopefully indicating that // // there is no operator== for Iterator1, Iterator2 // // The same will happen if no enable_if is used to remove // // false overloads from the templated conversion constructor // // of AdaptorA. // // a1 == a2; // ---------------- // // AdaptorA<Iterator> a; // AdaptorB<Iterator> b; // // // This will result in a no such overload error in full operation // // If enable_if is not supported the static assert used // // in the operator implementation will fail. // // This will accidently work if is_convertible is not supported. // // a == b; // ---------------- // # 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_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 \ )); \ return_prefix iterator_core_access::base_op( \ *static_cast<Derived1 const*>(&lhs) \ , *static_cast<Derived2 const*>(&rhs) \ , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ ); \ } # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \ BOOST_ITERATOR_FACADE_INTEROP( \ op \ , boost::iterators::detail::always_bool2 \ , return_prefix \ , base_op \ ) BOOST_ITERATOR_FACADE_RELATION(==, return, equal) BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal) # undef BOOST_ITERATOR_FACADE_RELATION # define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) \ { \ /* For those compilers that do not support enable_if */ \ BOOST_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 \ )); \ return_prefix iterator_core_access::base_op( \ *static_cast<Derived1 const*>(&lhs) \ , *static_cast<Derived2 const*>(&rhs) \ , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ ); \ } # 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 \ ) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from) BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from) # undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION // operator- requires an additional part in the static assertion BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( - , boost::iterators::detail::choose_difference_type , return , distance_from ) # undef BOOST_ITERATOR_FACADE_INTEROP # undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS # define BOOST_ITERATOR_FACADE_PLUS(args) \ BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) \ { \ Derived tmp(static_cast<Derived const&>(i)); \ return tmp += n; \ } BOOST_ITERATOR_FACADE_PLUS(( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n )) BOOST_ITERATOR_FACADE_PLUS(( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i )) # undef BOOST_ITERATOR_FACADE_PLUS # undef BOOST_ITERATOR_FACADE_PLUS_HEAD # undef BOOST_ITERATOR_FACADE_INTEROP_HEAD # undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD # undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL } // namespace iterators using iterators::iterator_core_access; using iterators::iterator_facade; } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_ITERATOR_FACADE_23022003THW_HPP PK h!\'���o o is_readable_iterator.hppnu �[��� // Copyright David Abrahams 2003. 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) #ifndef IS_READABLE_ITERATOR_DWA2003112_HPP # define IS_READABLE_ITERATOR_DWA2003112_HPP #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> // 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 { namespace detail { // Guts of is_readable_iterator. Value is the iterator's value_type // and the result is computed in the nested rebind template. template <class Value> struct is_readable_iterator_impl { static char tester(typename add_lvalue_reference<Value>::type, int); static char (& tester(any_conversion_eater, ...) )[2]; template <class It> struct rebind { static It& x; BOOST_STATIC_CONSTANT( bool , value = ( sizeof( is_readable_iterator_impl<Value>::tester(*x, 1) ) == 1 ) ); }; }; #undef BOOST_READABLE_PRESERVER // // void specializations to handle std input and output iterators // template <> struct is_readable_iterator_impl<void> { template <class It> struct rebind : boost::mpl::false_ {}; }; #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS template <> struct is_readable_iterator_impl<const void> { template <class It> struct rebind : boost::mpl::false_ {}; }; template <> struct is_readable_iterator_impl<volatile void> { template <class It> struct rebind : boost::mpl::false_ {}; }; template <> struct is_readable_iterator_impl<const volatile void> { template <class It> struct rebind : boost::mpl::false_ {}; }; #endif // // This level of dispatching is required for Borland. We might save // an instantiation by removing it for others. // template <class It> struct is_readable_iterator_impl2 : is_readable_iterator_impl< BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const >::template rebind<It> {}; } // namespace detail template< typename T > struct is_readable_iterator : public ::boost::integral_constant<bool,::boost::iterators::detail::is_readable_iterator_impl2<T>::value> { public: BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_readable_iterator,(T)) }; } // namespace iterators using iterators::is_readable_iterator; } // namespace boost #endif #include <boost/iterator/detail/config_undef.hpp> #endif // IS_READABLE_ITERATOR_DWA2003112_HPP PK h!\�(T� � function_output_iterator.hppnu �[��� // (C) Copyright Jeremy Siek 2001. // 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) // Revision History: // 27 Feb 2001 Jeremy Siek // Initial checkin. #ifndef BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP #define BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP #include <iterator> namespace boost { namespace iterators { template <class UnaryFunction> class function_output_iterator { typedef function_output_iterator self; public: typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; explicit function_output_iterator() {} explicit function_output_iterator(const UnaryFunction& f) : m_f(f) {} struct output_proxy { output_proxy(UnaryFunction& f) : m_f(f) { } template <class T> output_proxy& operator=(const T& value) { m_f(value); return *this; } UnaryFunction& m_f; }; output_proxy operator*() { return output_proxy(m_f); } self& operator++() { return *this; } self& operator++(int) { return *this; } private: UnaryFunction m_f; }; template <class UnaryFunction> inline function_output_iterator<UnaryFunction> make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) { return function_output_iterator<UnaryFunction>(f); } } // namespace iterators using iterators::function_output_iterator; using iterators::make_function_output_iterator; } // namespace boost #endif // BOOST_ITERATOR_FUNCTION_OUTPUT_ITERATOR_HPP PK h!\�z�; ; permutation_iterator.hppnu �[��� // (C) Copyright Toon Knapen 2001. // (C) Copyright David Abrahams 2003. // (C) Copyright Roland Richter 2003. // 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_PERMUTATION_ITERATOR_HPP #define BOOST_PERMUTATION_ITERATOR_HPP #include <iterator> #include <boost/iterator/iterator_adaptor.hpp> namespace boost { namespace iterators { template< class ElementIterator , class IndexIterator> class permutation_iterator : public iterator_adaptor< permutation_iterator<ElementIterator, IndexIterator> , IndexIterator, typename std::iterator_traits<ElementIterator>::value_type , use_default, typename std::iterator_traits<ElementIterator>::reference> { typedef iterator_adaptor< permutation_iterator<ElementIterator, IndexIterator> , IndexIterator, typename std::iterator_traits<ElementIterator>::value_type , use_default, typename std::iterator_traits<ElementIterator>::reference> super_t; friend class iterator_core_access; public: permutation_iterator() : m_elt_iter() {} explicit permutation_iterator(ElementIterator x, IndexIterator y) : super_t(y), m_elt_iter(x) {} template<class OtherElementIterator, class OtherIndexIterator> permutation_iterator( permutation_iterator<OtherElementIterator, OtherIndexIterator> const& r , typename enable_if_convertible<OtherElementIterator, ElementIterator>::type* = 0 , typename enable_if_convertible<OtherIndexIterator, IndexIterator>::type* = 0 ) : super_t(r.base()), m_elt_iter(r.m_elt_iter) {} private: typename super_t::reference dereference() const { return *(m_elt_iter + *this->base()); } #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS template <class,class> friend class permutation_iterator; #else public: #endif ElementIterator m_elt_iter; }; template <class ElementIterator, class IndexIterator> inline permutation_iterator<ElementIterator, IndexIterator> make_permutation_iterator( ElementIterator e, IndexIterator i ) { return permutation_iterator<ElementIterator, IndexIterator>( e, i ); } } // namespace iterators using iterators::permutation_iterator; using iterators::make_permutation_iterator; } // namespace boost #endif PK h!\��/p� � detail/config_def.hppnu �[��� // (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) // no include guard multiple inclusion intended // // This is a temporary workaround until the bulk of this is // available in boost config. // 23/02/03 thw // #include <boost/config.hpp> // for prior #include <boost/detail/workaround.hpp> #ifdef BOOST_ITERATOR_CONFIG_DEF # error you have nested config_def #inclusion. #else # define BOOST_ITERATOR_CONFIG_DEF #endif // We enable this always now. Otherwise, the simple case in // libs/iterator/test/constant_iterator_arrow.cpp fails to compile // because the operator-> return is improperly deduced as a non-const // pointer. #if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x531)) // Recall that in general, compilers without partial specialization // can't strip constness. Consider counting_iterator, which normally // passes a const Value to iterator_facade. As a result, any code // which makes a std::vector of the iterator's value_type will fail // when its allocator declares functions overloaded on reference and // const_reference (the same type). // // Furthermore, Borland 5.5.1 drops constness in enough ways that we // end up using a proxy for operator[] when we otherwise shouldn't. // Using reference constness gives it an extra hint that it can // return the value_type from operator[] directly, but is not // strictly necessary. Not sure how best to resolve this one. # define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1 #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)) \ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) # define BOOST_NO_LVALUE_RETURN_DETECTION # if 0 // test code struct v {}; typedef char (&no)[3]; template <class T> no foo(T const&, ...); template <class T> char foo(T&, int); struct value_iterator { v operator*() const; }; template <class T> struct lvalue_deref_helper { static T& x; enum { value = (sizeof(foo(*x,0)) == 1) }; }; int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1]; int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ]; # endif #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 PK h!\��c�� � detail/minimum_category.hppnu �[��� // Copyright David Abrahams 2003. 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) #ifndef MINIMUM_CATEGORY_DWA20031119_HPP # define MINIMUM_CATEGORY_DWA20031119_HPP # include <boost/iterator/minimum_category.hpp> namespace boost { // This import below (as well as the whole header) is for backward compatibility // with boost/token_iterator.hpp. It should be removed as soon as that header is fixed. namespace detail { using iterators::minimum_category; } // namespace detail } // namespace boost #endif // MINIMUM_CATEGORY_DWA20031119_HPP PK h!\1F��` ` # detail/facade_iterator_category.hppnu �[��� // Copyright David Abrahams 2003. 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) #ifndef FACADE_ITERATOR_CATEGORY_DWA20031118_HPP # define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP # include <boost/core/use_default.hpp> # include <boost/iterator/iterator_categories.hpp> # 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/mpl/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 <boost/type_traits/is_same.hpp> # include <boost/iterator/detail/config_def.hpp> // try to keep this last # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY # include <boost/detail/indirect_traits.hpp> # endif // // iterator_category deduction for iterator_facade // namespace boost { namespace iterators { using boost::use_default; namespace detail { struct input_output_iterator_tag : std::input_iterator_tag { // Using inheritance for only input_iterator_tag helps to avoid // ambiguities when a stdlib implementation dispatches on a // function which is overloaded on both input_iterator_tag and // output_iterator_tag, as STLPort does, in its __valid_range // function. I claim it's better to avoid the ambiguity in these // cases. operator std::output_iterator_tag() const { return std::output_iterator_tag(); } }; // // True iff the user has explicitly disabled writability of this // iterator. Pass the iterator_facade's Value parameter and its // nested ::reference type. // template <class ValueParam, class Reference> struct iterator_writability_disabled # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY // Adding Thomas' logic? : mpl::or_< is_const<Reference> , boost::detail::indirect_traits::is_reference_to_const<Reference> , is_const<ValueParam> > # else : is_const<ValueParam> # endif {}; // // Convert an iterator_facade's traversal category, Value parameter, // and ::reference type to an appropriate old-style category. // // Due to changeset 21683, this now never results in a category convertible // to output_iterator_tag. // // Change at: https://svn.boost.org/trac/boost/changeset/21683 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> > , mpl::eval_if< is_convertible<Traversal,random_access_traversal_tag> , mpl::identity<std::random_access_iterator_tag> , mpl::if_< 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> // check for readability , is_convertible<Reference, ValueParam> > , mpl::identity<std::input_iterator_tag> , mpl::identity<Traversal> > > { }; // True iff T is convertible to an old-style iterator category. template <class T> struct is_iterator_category : mpl::or_< is_convertible<T,std::input_iterator_tag> , is_convertible<T,std::output_iterator_tag> > { }; template <class T> struct is_iterator_traversal : is_convertible<T,incrementable_traversal_tag> {}; // // A composite iterator_category tag convertible to Category (a pure // old-style category) and Traversal (a pure traversal tag). // Traversal must be a strict increase of the traversal power given by // Category. // template <class Category, class Traversal> struct iterator_category_with_traversal : Category, 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_MPL_ASSERT_NOT(( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >)); BOOST_MPL_ASSERT((is_iterator_category<Category>)); BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>)); BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>)); # if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>)); # endif }; // Computes an iterator_category tag whose traversal is Traversal and // which is appropriate for an iterator template <class Traversal, class ValueParam, class Reference> struct facade_iterator_category_impl { BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>)); typedef typename iterator_facade_default_category< Traversal,ValueParam,Reference >::type category; typedef typename mpl::if_< is_same< Traversal , typename iterator_category_to_traversal<category>::type > , category , iterator_category_with_traversal<category,Traversal> >::type type; }; // // Compute an iterator_category for iterator_facade // template <class CategoryOrTraversal, class ValueParam, class Reference> struct facade_iterator_category : mpl::eval_if< is_iterator_category<CategoryOrTraversal> , mpl::identity<CategoryOrTraversal> // old-style categories are fine as-is , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference> > { }; }}} // namespace boost::iterators::detail # include <boost/iterator/detail/config_undef.hpp> #endif // FACADE_ITERATOR_CATEGORY_DWA20031118_HPP PK h!\# 6� � detail/enable_if.hppnu �[��� // (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/detail/workaround.hpp> #include <boost/mpl/identity.hpp> #include <boost/iterator/detail/config_def.hpp> // // 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 : mpl::identity<Return> # endif { }; } // namespace iterators } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_ENABLE_IF_23022003THW_HPP PK h!\��N� � detail/config_undef.hppnu �[��� // (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) // no include guard multiple inclusion intended // // This is a temporary workaround until the bulk of this is // available in boost config. // 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 #else # error missing or nested #include config_def #endif PK h!\ ��6� � detail/any_conversion_eater.hppnu �[��� // Copyright David Abrahams 2003. 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) #ifndef ANY_CONVERSION_EATER_DWA20031117_HPP # define ANY_CONVERSION_EATER_DWA20031117_HPP namespace boost { namespace iterators { namespace detail { // This type can be used in traits to "eat" up the one user-defined // implicit conversion allowed. struct any_conversion_eater { template <class T> any_conversion_eater(T const&); }; }}} // namespace boost::iterators::detail #endif // ANY_CONVERSION_EATER_DWA20031117_HPP PK h!\N�>(�( �( zip_iterator.hppnu �[��� // Copyright David Abrahams and Thomas Becker 2000-2006. // Copyright Kohei Takahashi 2012-2014. // // 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_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 #include <boost/iterator/iterator_categories.hpp> #include <boost/iterator/minimum_category.hpp> #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> #include <boost/mpl/placeholders.hpp> #include <boost/fusion/algorithm/iteration/for_each.hpp> #include <boost/fusion/algorithm/transformation/transform.hpp> #include <boost/fusion/sequence/convert.hpp> #include <boost/fusion/sequence/intrinsic/at_c.hpp> #include <boost/fusion/sequence/comparison/equal_to.hpp> #include <boost/fusion/support/tag_of_fwd.hpp> namespace boost { namespace iterators { // Zip iterator forward declaration for zip_iterator_base template<typename IteratorTuple> class zip_iterator; namespace detail { // Functors to be used with tuple algorithms // template<typename DiffType> class advance_iterator { public: advance_iterator(DiffType step) : m_step(step) {} template<typename Iterator> void operator()(Iterator& it) const { it += m_step; } private: DiffType m_step; }; // struct increment_iterator { template<typename Iterator> void operator()(Iterator& it) const { ++it; } }; // struct decrement_iterator { template<typename Iterator> void operator()(Iterator& it) const { --it; } }; // struct dereference_iterator { template<typename> struct result; template<typename This, typename Iterator> struct result<This(Iterator)> { typedef typename remove_cv<typename remove_reference<Iterator>::type>::type iterator; typedef typename iterator_reference<iterator>::type type; }; template<typename Iterator> typename result<dereference_iterator(Iterator)>::type operator()(Iterator const& it) const { return *it; } }; // Metafunction to obtain the type of the tuple whose element types // are the reference types of an iterator tuple. // template<typename IteratorTuple> struct tuple_of_references : mpl::transform< IteratorTuple, iterator_reference<mpl::_1> > { }; // Specialization for std::pair template<typename Iterator1, typename Iterator2> struct tuple_of_references<std::pair<Iterator1, Iterator2> > { typedef std::pair< typename iterator_reference<Iterator1>::type , typename iterator_reference<Iterator2>::type > type; }; // Metafunction to obtain the minimal traversal tag in a tuple // of iterators. // template<typename IteratorTuple> struct minimum_traversal_category_in_iterator_tuple { typedef typename mpl::transform< IteratorTuple , pure_traversal_tag<iterator_traversal<> > >::type tuple_of_traversal_tags; typedef typename mpl::fold< tuple_of_traversal_tags , random_access_traversal_tag , minimum_category<> >::type type; }; template<typename Iterator1, typename Iterator2> struct minimum_traversal_category_in_iterator_tuple<std::pair<Iterator1, Iterator2> > { typedef typename pure_traversal_tag< typename iterator_traversal<Iterator1>::type >::type iterator1_traversal; typedef typename pure_traversal_tag< typename iterator_traversal<Iterator2>::type >::type iterator2_traversal; typedef typename minimum_category< iterator1_traversal , typename minimum_category< iterator2_traversal , random_access_traversal_tag >::type >::type type; }; /////////////////////////////////////////////////////////////////// // // Class zip_iterator_base // // Builds and exposes the iterator facade type from which the zip // iterator will be derived. // template<typename IteratorTuple> struct zip_iterator_base { private: // Reference type is the type of the tuple obtained from the // iterators' reference types. typedef typename detail::tuple_of_references<IteratorTuple>::type reference; // Value type is the same as reference type. typedef reference value_type; // Difference type is the first iterator's difference type typedef typename iterator_difference< typename mpl::at_c<IteratorTuple, 0>::type >::type difference_type; // Traversal catetgory is the minimum traversal category in the // iterator tuple. typedef typename detail::minimum_traversal_category_in_iterator_tuple< IteratorTuple >::type traversal_category; public: // The iterator facade type from which the zip iterator will // be derived. typedef iterator_facade< zip_iterator<IteratorTuple>, value_type, traversal_category, reference, difference_type > type; }; template <> struct zip_iterator_base<int> { typedef int type; }; template <typename reference> struct converter { template <typename Seq> static reference call(Seq seq) { typedef typename fusion::traits::tag_of<reference>::type tag; return fusion::convert<tag>(seq); } }; template <typename Reference1, typename Reference2> struct converter<std::pair<Reference1, Reference2> > { typedef std::pair<Reference1, Reference2> reference; template <typename Seq> static reference call(Seq seq) { return reference( fusion::at_c<0>(seq) , fusion::at_c<1>(seq)); } }; } ///////////////////////////////////////////////////////////////////// // // zip_iterator class definition // template<typename IteratorTuple> class zip_iterator : public detail::zip_iterator_base<IteratorTuple>::type { // Typedef super_t as our base class. typedef typename detail::zip_iterator_base<IteratorTuple>::type super_t; // iterator_core_access is the iterator's best friend. friend class iterator_core_access; public: // Construction // ============ // Default constructor zip_iterator() { } // Constructor from iterator tuple zip_iterator(IteratorTuple iterator_tuple) : m_iterator_tuple(iterator_tuple) { } // Copy constructor template<typename OtherIteratorTuple> zip_iterator( const zip_iterator<OtherIteratorTuple>& other, typename enable_if_convertible< OtherIteratorTuple, IteratorTuple >::type* = 0 ) : m_iterator_tuple(other.get_iterator_tuple()) {} // Get method for the iterator tuple. const IteratorTuple& get_iterator_tuple() const { return m_iterator_tuple; } private: // Implementation of Iterator Operations // ===================================== // Dereferencing returns a tuple built from the dereferenced // iterators in the iterator tuple. typename super_t::reference dereference() const { typedef typename super_t::reference reference; typedef detail::converter<reference> gen; return gen::call(fusion::transform( get_iterator_tuple(), detail::dereference_iterator())); } // Two zip iterators are equal if all iterators in the iterator // tuple are equal. NOTE: It should be possible to implement this // as // // return get_iterator_tuple() == other.get_iterator_tuple(); // // but equality of tuples currently (7/2003) does not compile // under several compilers. No point in bringing in a bunch // of #ifdefs here. // template<typename OtherIteratorTuple> bool equal(const zip_iterator<OtherIteratorTuple>& other) const { return fusion::equal_to( get_iterator_tuple(), other.get_iterator_tuple()); } // Advancing a zip iterator means to advance all iterators in the // iterator tuple. void advance(typename super_t::difference_type n) { fusion::for_each( m_iterator_tuple, detail::advance_iterator<BOOST_DEDUCED_TYPENAME super_t::difference_type>(n)); } // Incrementing a zip iterator means to increment all iterators in // the iterator tuple. void increment() { fusion::for_each( m_iterator_tuple, detail::increment_iterator()); } // Decrementing a zip iterator means to decrement all iterators in // the iterator tuple. void decrement() { fusion::for_each( m_iterator_tuple, detail::decrement_iterator()); } // Distance is calculated using the first iterator in the tuple. template<typename OtherIteratorTuple> typename super_t::difference_type distance_to( const zip_iterator<OtherIteratorTuple>& other ) const { return fusion::at_c<0>(other.get_iterator_tuple()) - fusion::at_c<0>(this->get_iterator_tuple()); } // Data Members // ============ // The iterator tuple. IteratorTuple m_iterator_tuple; }; // Make function for zip iterator // template<typename IteratorTuple> inline zip_iterator<IteratorTuple> make_zip_iterator(IteratorTuple t) { return zip_iterator<IteratorTuple>(t); } } // namespace iterators using iterators::zip_iterator; using iterators::make_zip_iterator; } // namespace boost #endif PK h!\�y4h@ @ filter_iterator.hppnu �[��� // (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_FILTER_ITERATOR_23022003THW_HPP #define BOOST_FILTER_ITERATOR_23022003THW_HPP #include <boost/iterator/iterator_adaptor.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/type_traits/is_class.hpp> #include <boost/static_assert.hpp> namespace boost { namespace iterators { template <class Predicate, class Iterator> class filter_iterator; namespace detail { template <class Predicate, class Iterator> struct filter_iterator_base { typedef iterator_adaptor< filter_iterator<Predicate, Iterator> , Iterator , use_default , typename mpl::if_< is_convertible< typename iterator_traversal<Iterator>::type , random_access_traversal_tag > , bidirectional_traversal_tag , use_default >::type > type; }; } template <class Predicate, class Iterator> class filter_iterator : public detail::filter_iterator_base<Predicate, Iterator>::type { typedef typename detail::filter_iterator_base< Predicate, Iterator >::type super_t; friend class iterator_core_access; public: filter_iterator() { } filter_iterator(Predicate f, Iterator x, Iterator end_ = Iterator()) : super_t(x), m_predicate(f), m_end(end_) { satisfy_predicate(); } filter_iterator(Iterator x, Iterator end_ = Iterator()) : super_t(x), m_predicate(), m_end(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); #endif satisfy_predicate(); } template<class OtherIterator> filter_iterator( filter_iterator<Predicate, OtherIterator> const& t , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 ) : super_t(t.base()), m_predicate(t.predicate()), m_end(t.end()) {} Predicate predicate() const { return m_predicate; } Iterator end() const { return m_end; } private: void increment() { ++(this->base_reference()); satisfy_predicate(); } void decrement() { while(!this->m_predicate(*--(this->base_reference()))){}; } void satisfy_predicate() { while (this->base() != this->m_end && !this->m_predicate(*this->base())) ++(this->base_reference()); } // Probably should be the initial base class so it can be // optimized away via EBO if it is an empty class. Predicate m_predicate; Iterator m_end; }; template <class Predicate, class Iterator> inline filter_iterator<Predicate,Iterator> make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator()) { return filter_iterator<Predicate,Iterator>(f,x,end); } template <class Predicate, class Iterator> inline filter_iterator<Predicate,Iterator> make_filter_iterator( typename iterators::enable_if< is_class<Predicate> , Iterator >::type x , Iterator end = Iterator()) { return filter_iterator<Predicate,Iterator>(x,end); } } // namespace iterators using iterators::filter_iterator; using iterators::make_filter_iterator; } // namespace boost #endif // BOOST_FILTER_ITERATOR_23022003THW_HPP PK h!\�4�9 reverse_iterator.hppnu �[��� // (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_REVERSE_ITERATOR_23022003THW_HPP #define BOOST_REVERSE_ITERATOR_23022003THW_HPP #include <boost/iterator/iterator_adaptor.hpp> namespace boost { namespace iterators { // // // template <class Iterator> class reverse_iterator : public iterator_adaptor< reverse_iterator<Iterator>, Iterator > { typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t; friend class iterator_core_access; public: reverse_iterator() {} explicit reverse_iterator(Iterator x) : super_t(x) {} template<class OtherIterator> reverse_iterator( reverse_iterator<OtherIterator> const& r , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 ) : super_t(r.base()) {} private: typename super_t::reference dereference() const { Iterator it = this->base_reference(); --it; return *it; } void increment() { --this->base_reference(); } void decrement() { ++this->base_reference(); } void advance(typename super_t::difference_type n) { this->base_reference() -= n; } template <class OtherIterator> typename super_t::difference_type distance_to(reverse_iterator<OtherIterator> const& y) const { return this->base_reference() - y.base(); } }; template <class BidirectionalIterator> inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x) { return reverse_iterator<BidirectionalIterator>(x); } } // namespace iterators using iterators::reverse_iterator; using iterators::make_reverse_iterator; } // namespace boost #endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP PK h!\ �:��+ �+ iterator_adaptor.hppnu �[��� // (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_ITERATOR_ADAPTOR_23022003THW_HPP #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP #include <boost/static_assert.hpp> #include <boost/core/use_default.hpp> #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 { namespace iterators { // Used as a default template argument internally, merely to // indicate "use the default", this can also be passed by users // explicitly in order to specify that the default should be used. using boost::use_default; } // 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 { // // Result type used in enable_if_convertible meta function. // This can be an incomplete type, as only pointers to // enable_if_convertible< ... >::type are used. // We could have used void for this, but conversion to // void* is just to easy. // struct enable_type; } // // enable_if for use in adapted iterators constructors. // // In order to provide interoperability between adapted constant and // mutable iterators, adapted iterators will usually provide templated // conversion constructors of the following form // // template <class BaseIterator> // class adapted_iterator : // public iterator_adaptor< adapted_iterator<Iterator>, Iterator > // { // public: // // ... // // template <class OtherIterator> // adapted_iterator( // OtherIterator const& it // , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0); // // ... // }; // // enable_if_convertible is used to remove those overloads from the overload // set that cannot be instantiated. For all practical purposes only overloads // for constant/mutable interaction will remain. This has the advantage that // meta functions like boost::is_convertible do not return false positives, // as they can only look at the signature of the conversion constructor // and not at the actual instantiation. // // enable_if_interoperable can be safely used in user code. It falls back to // always enabled for compilers that don't support enable_if or is_convertible. // There is no need for compiler specific workarounds in user code. // // The operators implementation relies on boost::is_convertible not returning // 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> , boost::iterators::detail::enable_type > {}; # endif // // Default template argument handling for iterator_adaptor // namespace detail { // If T is use_default, return the result of invoking // DefaultNullaryFn, otherwise return T. template <class T, class DefaultNullaryFn> struct ia_dflt_help : mpl::eval_if< is_same<T, use_default> , DefaultNullaryFn , mpl::identity<T> > { }; // A metafunction which computes an iterator_adaptor's base class, // a specialization of iterator_facade. template < class Derived , class Base , class Value , class Traversal , class Reference , class Difference > struct iterator_adaptor_base { typedef iterator_facade< Derived # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY , typename boost::iterators::detail::ia_dflt_help< Value , mpl::eval_if< is_same<Reference,use_default> , iterator_value<Base> , remove_reference<Reference> > >::type # else , typename boost::iterators::detail::ia_dflt_help< Value, iterator_value<Base> >::type # endif , typename boost::iterators::detail::ia_dflt_help< Traversal , iterator_traversal<Base> >::type , typename boost::iterators::detail::ia_dflt_help< Reference , mpl::eval_if< is_same<Value,use_default> , iterator_reference<Base> , add_reference<Value> > >::type , typename boost::iterators::detail::ia_dflt_help< Difference, iterator_difference<Base> >::type > type; }; // workaround for aC++ CR JAGaf33512 template <class Tr1, class Tr2> inline void iterator_adaptor_assert_traversal () { BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value)); } } // // Iterator Adaptor // // The parameter ordering changed slightly with respect to former // 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 // replaced by use_default. // // Value - if supplied, the value_type of the resulting iterator, unless // const. If const, a conforming compiler strips constness for the // value_type. If not supplied, iterator_traits<Base>::value_type is used // // Category - the traversal category of the resulting iterator. If not // supplied, iterator_traversal<Base>::type is used. // // Reference - the reference type of the resulting iterator, and in // particular, the result type of operator*(). If not supplied but // Value is supplied, Value& is used. Otherwise // iterator_traits<Base>::reference is used. // // Difference - the difference_type of the resulting iterator. If not // supplied, iterator_traits<Base>::difference_type is used. // template < class Derived , class Base , class Value = use_default , class Traversal = use_default , class Reference = use_default , class Difference = use_default > class iterator_adaptor : public boost::iterators::detail::iterator_adaptor_base< Derived, Base, Value, Traversal, Reference, Difference >::type { friend class iterator_core_access; protected: typedef typename boost::iterators::detail::iterator_adaptor_base< Derived, Base, Value, Traversal, Reference, Difference >::type super_t; public: iterator_adaptor() {} explicit iterator_adaptor(Base const &iter) : m_iterator(iter) { } typedef Base base_type; Base const& base() const { return m_iterator; } protected: // for convenience in derived classes typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_; // // lvalue access to the Base object for Derived // Base const& base_reference() const { return m_iterator; } Base& base_reference() { return m_iterator; } private: // // Core iterator interface for iterator_facade. This is private // to prevent temptation for Derived classes to use it, which // will often result in an error. Derived classes should use // base_reference(), above, to get direct access to m_iterator. // typename super_t::reference dereference() const { return *m_iterator; } template < class OtherDerived, class OtherIterator, class V, class C, class R, class D > bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const { // Maybe readd with same_distance // BOOST_STATIC_ASSERT( // (detail::same_category_and_difference<Derived,OtherDerived>::value) // ); return m_iterator == x.base(); } typedef typename iterator_category_to_traversal< typename super_t::iterator_category >::type my_traversal; # define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \ boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>(); void advance(typename super_t::difference_type n) { BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) m_iterator += n; } void increment() { ++m_iterator; } void decrement() { BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag) --m_iterator; } template < class OtherDerived, class OtherIterator, class V, class C, class R, class D > typename super_t::difference_type distance_to( iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const { BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag) // Maybe readd with same_distance // BOOST_STATIC_ASSERT( // (detail::same_category_and_difference<Derived,OtherDerived>::value) // ); return y.base() - m_iterator; } # undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL private: // data members Base m_iterator; }; } // namespace iterators using iterators::iterator_adaptor; using iterators::enable_if_convertible; } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_ITERATOR_ADAPTOR_23022003THW_HPP PK h!\��hF F iterator_categories.hppnu �[��� // (C) Copyright Jeremy Siek 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_ITERATOR_CATEGORIES_HPP # define BOOST_ITERATOR_CATEGORIES_HPP # include <boost/config.hpp> # include <boost/iterator/detail/config_def.hpp> # include <boost/detail/workaround.hpp> # include <boost/mpl/eval_if.hpp> # include <boost/mpl/identity.hpp> # 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 <iterator> namespace boost { namespace iterators { // // Traversal Categories // struct no_traversal_tag {}; struct incrementable_traversal_tag : no_traversal_tag { // incrementable_traversal_tag() {} // incrementable_traversal_tag(std::output_iterator_tag const&) {}; }; struct single_pass_traversal_tag : incrementable_traversal_tag { // single_pass_traversal_tag() {} // single_pass_traversal_tag(std::input_iterator_tag const&) {}; }; struct forward_traversal_tag : single_pass_traversal_tag { // forward_traversal_tag() {} // forward_traversal_tag(std::forward_iterator_tag const&) {}; }; struct bidirectional_traversal_tag : forward_traversal_tag { // bidirectional_traversal_tag() {}; // bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {}; }; struct random_access_traversal_tag : bidirectional_traversal_tag { // random_access_traversal_tag() {}; // random_access_traversal_tag(std::random_access_iterator_tag const&) {}; }; namespace detail { // // Convert a "strictly old-style" iterator category to a traversal // tag. This is broken out into a separate metafunction to reduce // the cost of instantiating iterator_category_to_traversal, below, // for new-style types. // template <class Cat> struct old_category_to_traversal : mpl::eval_if< is_convertible<Cat,std::random_access_iterator_tag> , mpl::identity<random_access_traversal_tag> , mpl::eval_if< is_convertible<Cat,std::bidirectional_iterator_tag> , mpl::identity<bidirectional_traversal_tag> , mpl::eval_if< is_convertible<Cat,std::forward_iterator_tag> , mpl::identity<forward_traversal_tag> , mpl::eval_if< is_convertible<Cat,std::input_iterator_tag> , mpl::identity<single_pass_traversal_tag> , mpl::eval_if< is_convertible<Cat,std::output_iterator_tag> , mpl::identity<incrementable_traversal_tag> , void > > > > > {}; } // namespace detail // // Convert an iterator category into a traversal tag // 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> , mpl::identity<Cat> , boost::iterators::detail::old_category_to_traversal<Cat> > {}; // Trait to get an iterator's traversal category template <class Iterator = mpl::_1> struct iterator_traversal : iterator_category_to_traversal< typename std::iterator_traits<Iterator>::iterator_category > {}; # ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT // Hack because BOOST_MPL_AUX_LAMBDA_SUPPORT doesn't seem to work // out well. Instantiating the nested apply template also // requires instantiating iterator_traits on the // placeholder. Instead we just specialize it as a metafunction // class. template <> struct iterator_traversal<mpl::_1> { template <class T> struct apply : iterator_traversal<T> {}; }; template <> struct iterator_traversal<mpl::_> : iterator_traversal<mpl::_1> {}; # endif // // Convert an iterator traversal to one of the traversal tags. // template <class Traversal> struct pure_traversal_tag : mpl::eval_if< is_convertible<Traversal,random_access_traversal_tag> , mpl::identity<random_access_traversal_tag> , mpl::eval_if< is_convertible<Traversal,bidirectional_traversal_tag> , mpl::identity<bidirectional_traversal_tag> , mpl::eval_if< is_convertible<Traversal,forward_traversal_tag> , mpl::identity<forward_traversal_tag> , mpl::eval_if< is_convertible<Traversal,single_pass_traversal_tag> , mpl::identity<single_pass_traversal_tag> , mpl::eval_if< is_convertible<Traversal,incrementable_traversal_tag> , mpl::identity<incrementable_traversal_tag> , void > > > > > { }; // // Trait to retrieve one of the iterator traversal tags from the iterator category or traversal. // template <class Iterator = mpl::_1> struct pure_iterator_traversal : pure_traversal_tag<typename iterator_traversal<Iterator>::type> {}; # ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT template <> struct pure_iterator_traversal<mpl::_1> { template <class T> struct apply : pure_iterator_traversal<T> {}; }; template <> struct pure_iterator_traversal<mpl::_> : pure_iterator_traversal<mpl::_1> {}; # endif } // namespace iterators using iterators::no_traversal_tag; using iterators::incrementable_traversal_tag; using iterators::single_pass_traversal_tag; using iterators::forward_traversal_tag; using iterators::bidirectional_traversal_tag; using iterators::random_access_traversal_tag; using iterators::iterator_category_to_traversal; using iterators::iterator_traversal; // This import is needed for backward compatibility with Boost.Range: // boost/range/detail/demote_iterator_traversal_tag.hpp // It should be removed when that header is fixed. namespace detail { using iterators::pure_traversal_tag; } // namespace detail } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_ITERATOR_CATEGORIES_HPP PK h!\��d advance.hppnu �[��� // Copyright (C) 2017 Michel Morin. // // 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_ITERATOR_ADVANCE_HPP #define BOOST_ITERATOR_ADVANCE_HPP #include <boost/config.hpp> #include <boost/iterator/iterator_categories.hpp> namespace boost { namespace iterators { namespace detail { template <typename InputIterator, typename Distance> inline BOOST_CXX14_CONSTEXPR void advance_impl( InputIterator& it , Distance n , incrementable_traversal_tag ) { while (n > 0) { ++it; --n; } } template <typename BidirectionalIterator, typename Distance> inline BOOST_CXX14_CONSTEXPR void advance_impl( BidirectionalIterator& it , Distance n , bidirectional_traversal_tag ) { if (n >= 0) { while (n > 0) { ++it; --n; } } else { while (n < 0) { --it; ++n; } } } template <typename RandomAccessIterator, typename Distance> inline BOOST_CXX14_CONSTEXPR void advance_impl( RandomAccessIterator& it , Distance n , random_access_traversal_tag ) { it += n; } } namespace advance_adl_barrier { template <typename InputIterator, typename Distance> inline BOOST_CXX14_CONSTEXPR void advance(InputIterator& it, Distance n) { detail::advance_impl( it, n, typename iterator_traversal<InputIterator>::type() ); } } using namespace advance_adl_barrier; } // namespace iterators using namespace iterators::advance_adl_barrier; } // namespace boost #endif PK h!\2T indirect_iterator.hppnu �[��� // (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_INDIRECT_ITERATOR_23022003THW_HPP #define BOOST_INDIRECT_ITERATOR_23022003THW_HPP #include <boost/iterator/iterator_adaptor.hpp> #include <boost/pointee.hpp> #include <boost/indirect_reference.hpp> #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> #ifdef BOOST_MPL_CFG_NO_HAS_XXX # include <boost/shared_ptr.hpp> # include <boost/scoped_ptr.hpp> # include <boost/mpl/bool.hpp> # include <memory> #endif #include <boost/iterator/detail/config_def.hpp> // must be last #include namespace boost { namespace iterators { template <class Iter, class Value, class Category, class Reference, class Difference> class indirect_iterator; namespace detail { template <class Iter, class Value, class Category, class Reference, class Difference> struct indirect_base { typedef typename std::iterator_traits<Iter>::value_type dereferenceable; typedef iterator_adaptor< indirect_iterator<Iter, Value, Category, Reference, Difference> , Iter , typename ia_dflt_help< Value, pointee<dereferenceable> >::type , Category , typename ia_dflt_help< Reference , mpl::eval_if< is_same<Value,use_default> , indirect_reference<dereferenceable> , add_reference<Value> > >::type , Difference > type; }; template <> struct indirect_base<int, int, int, int, int> {}; } // namespace detail template < class Iterator , class Value = use_default , class Category = use_default , class Reference = use_default , class Difference = use_default > class indirect_iterator : public detail::indirect_base< Iterator, Value, Category, Reference, Difference >::type { typedef typename detail::indirect_base< Iterator, Value, Category, Reference, Difference >::type super_t; friend class iterator_core_access; public: indirect_iterator() {} indirect_iterator(Iterator iter) : super_t(iter) {} template < class Iterator2, class Value2, class Category2 , class Reference2, class Difference2 > indirect_iterator( indirect_iterator< Iterator2, Value2, Category2, Reference2, Difference2 > const& y , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 ) : super_t(y.base()) {} private: typename super_t::reference dereference() const { # if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x5A0 ) return const_cast<super_t::reference>(**this->base()); # else return **this->base(); # endif } }; template <class Iter> inline indirect_iterator<Iter> make_indirect_iterator(Iter x) { return indirect_iterator<Iter>(x); } template <class Traits, class Iter> inline indirect_iterator<Iter,Traits> make_indirect_iterator(Iter x, Traits* = 0) { return indirect_iterator<Iter, Traits>(x); } } // namespace iterators using iterators::indirect_iterator; using iterators::make_indirect_iterator; } // namespace boost #include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_INDIRECT_ITERATOR_23022003THW_HPP PK h!\�j�3� � new_iterator_tests.hppnu �[��� #ifndef BOOST_NEW_ITERATOR_TESTS_HPP # define BOOST_NEW_ITERATOR_TESTS_HPP // // Copyright (c) David Abrahams 2001. // Copyright (c) Jeremy Siek 2001-2003. // Copyright (c) Thomas Witt 2002. // // 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) // // This is meant to be the beginnings of a comprehensive, generic // test suite for STL concepts such as iterators and containers. // // Revision History: // 28 Oct 2002 Started update for new iterator categories // (Jeremy Siek) // 28 Apr 2002 Fixed input iterator requirements. // For a == b a++ == b++ is no longer required. // See 24.1.1/3 for details. // (Thomas Witt) // 08 Feb 2001 Fixed bidirectional iterator test so that // --i is no longer a precondition. // (Jeremy Siek) // 04 Feb 2001 Added lvalue test, corrected preconditions // (David Abrahams) # include <iterator> # include <boost/static_assert.hpp> # 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> # include <boost/detail/is_incrementable.hpp> # include <boost/core/lightweight_test.hpp> namespace boost { // Do separate tests for *i++ so we can treat, e.g., smart pointers, // as readable and/or writable iterators. template <class Iterator, class T> void readable_iterator_traversal_test(Iterator i1, T v, mpl::true_) { T v2(*i1++); BOOST_TEST(v == v2); } template <class Iterator, class T> void readable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) {} template <class Iterator, class T> void writable_iterator_traversal_test(Iterator i1, T v, mpl::true_) { ++i1; // we just wrote into that position *i1++ = v; Iterator x(i1++); (void)x; } template <class Iterator, class T> void writable_iterator_traversal_test(const Iterator i1, T v, mpl::false_) {} // Preconditions: *i == v template <class Iterator, class T> void readable_iterator_test(const Iterator i1, T v) { Iterator i2(i1); // Copy Constructible typedef typename std::iterator_traits<Iterator>::reference ref_t; ref_t r1 = *i1; ref_t r2 = *i2; T v1 = r1; T v2 = r2; BOOST_TEST(v1 == v); BOOST_TEST(v2 == v); # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>()); // 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); # endif } template <class Iterator, class T> void writable_iterator_test(Iterator i, T v, T v2) { Iterator i2(i); // Copy Constructible *i2 = v; # if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407) writable_iterator_traversal_test( i, v2, mpl::and_< detail::is_incrementable<Iterator> , detail::is_postfix_incrementable<Iterator> >()); # endif } template <class Iterator> void swappable_iterator_test(Iterator i, Iterator j) { Iterator i2(i), j2(j); typename std::iterator_traits<Iterator>::value_type bi = *i, bj = *j; iter_swap(i2, j2); typename std::iterator_traits<Iterator>::value_type ai = *i, aj = *j; BOOST_TEST(bi == aj && bj == ai); } template <class Iterator, class T> 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)); 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); # endif } template <class Iterator, class T> 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)); T& v3 = *i2; BOOST_TEST(v1 == v3); // A non-const lvalue iterator is not neccessarily 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); # endif } template <class Iterator, class T> void forward_readable_iterator_test(Iterator i, Iterator j, T val1, T val2) { Iterator i2; Iterator i3(i); i2 = i; BOOST_TEST(i2 == i3); BOOST_TEST(i != j); BOOST_TEST(i2 != j); readable_iterator_test(i, val1); readable_iterator_test(i2, val1); readable_iterator_test(i3, val1); BOOST_TEST(i == i2++); BOOST_TEST(i != ++i3); readable_iterator_test(i2, val2); readable_iterator_test(i3, val2); readable_iterator_test(i, val1); } template <class Iterator, class T> void forward_swappable_iterator_test(Iterator i, Iterator j, T val1, T val2) { forward_readable_iterator_test(i, j, val1, val2); Iterator i2 = i; ++i2; swappable_iterator_test(i, i2); } // bidirectional // Preconditions: *i == v1, *++i == v2 template <class Iterator, class T> void bidirectional_readable_iterator_test(Iterator i, T v1, T v2) { Iterator j(i); ++j; forward_readable_iterator_test(i, j, v1, v2); ++i; Iterator i1 = i, i2 = i; BOOST_TEST(i == i1--); BOOST_TEST(i != --i2); readable_iterator_test(i, v2); readable_iterator_test(i1, v1); readable_iterator_test(i2, v1); --i; BOOST_TEST(i == i1); BOOST_TEST(i == i2); ++i1; ++i2; readable_iterator_test(i, v1); readable_iterator_test(i1, v2); readable_iterator_test(i2, v2); } // random access // Preconditions: [i,i+N) is a valid range template <class Iterator, class TrueVals> void random_access_readable_iterator_test(Iterator i, int N, TrueVals vals) { bidirectional_readable_iterator_test(i, vals[0], vals[1]); const Iterator j = i; int c; for (c = 0; c < N-1; ++c) { BOOST_TEST(i == j + c); BOOST_TEST(*i == vals[c]); typename std::iterator_traits<Iterator>::value_type x = j[c]; BOOST_TEST(*i == x); BOOST_TEST(*i == *(j + c)); BOOST_TEST(*i == *(c + j)); ++i; BOOST_TEST(i > j); BOOST_TEST(i >= j); BOOST_TEST(j <= i); BOOST_TEST(j < i); } Iterator k = j + N - 1; for (c = 0; c < N-1; ++c) { BOOST_TEST(i == k - c); BOOST_TEST(*i == vals[N - 1 - c]); typename std::iterator_traits<Iterator>::value_type x = j[N - 1 - c]; BOOST_TEST(*i == x); Iterator q = k - c; BOOST_TEST(*i == *q); BOOST_TEST(i > j); BOOST_TEST(i >= j); BOOST_TEST(j <= i); BOOST_TEST(j < i); --i; } } } // namespace boost # include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_NEW_ITERATOR_TESTS_HPP PK h!\�;�� � counting_iterator.hppnu �[��� // Copyright David Abrahams 2003. // 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 COUNTING_ITERATOR_DWA200348_HPP # define COUNTING_ITERATOR_DWA200348_HPP # include <boost/iterator/iterator_adaptor.hpp> # include <boost/detail/numeric_traits.hpp> # include <boost/mpl/bool.hpp> # include <boost/mpl/if.hpp> # include <boost/mpl/identity.hpp> # include <boost/mpl/eval_if.hpp> namespace boost { namespace iterators { template < class Incrementable , class CategoryOrTraversal , class Difference > class counting_iterator; namespace detail { // Try to detect numeric types at compile time in ways compatible // with the limitations of the compiler and library. template <class T> 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); # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized); # else # 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 )); # else BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value); # endif # endif }; template <class T> struct is_numeric : mpl::bool_<(::boost::iterators::detail::is_numeric_impl<T>::value)> {}; # if defined(BOOST_HAS_LONG_LONG) template <> struct is_numeric< ::boost::long_long_type> : mpl::true_ {}; template <> struct is_numeric< ::boost::ulong_long_type> : mpl::true_ {}; # endif // Some compilers fail to have a numeric_limits specialization template <> struct is_numeric<wchar_t> : mpl::true_ {}; template <class T> struct numeric_difference { typedef typename boost::detail::numeric_traits<T>::difference_type type; }; BOOST_STATIC_ASSERT(is_numeric<int>::value); template <class Incrementable, class CategoryOrTraversal, class Difference> struct counting_iterator_base { typedef typename detail::ia_dflt_help< CategoryOrTraversal , mpl::eval_if< is_numeric<Incrementable> , mpl::identity<random_access_traversal_tag> , iterator_traversal<Incrementable> > >::type traversal; typedef typename detail::ia_dflt_help< Difference , mpl::eval_if< is_numeric<Incrementable> , numeric_difference<Incrementable> , iterator_difference<Incrementable> > >::type difference; typedef iterator_adaptor< counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self , Incrementable // Base , Incrementable // Value # ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY const // MSVC won't strip this. Instead we enable Thomas' // criterion (see boost/iterator/detail/facade_iterator_category.hpp) # endif , traversal , Incrementable const& // reference , difference > type; }; // Template class distance_policy_select -- choose a policy for computing the // distance between counting_iterators at compile-time based on whether or not // the iterator wraps an integer or an iterator, using "poor man's partial // specialization". template <bool is_integer> struct distance_policy_select; // A policy for wrapped iterators template <class Difference, class Incrementable1, class Incrementable2> struct iterator_distance { static Difference distance(Incrementable1 x, Incrementable2 y) { return y - x; } }; // A policy for wrapped numbers template <class Difference, class Incrementable1, class Incrementable2> struct number_distance { static Difference distance(Incrementable1 x, Incrementable2 y) { return boost::detail::numeric_distance(x, y); } }; } template < class Incrementable , class CategoryOrTraversal = use_default , class Difference = use_default > class counting_iterator : public detail::counting_iterator_base< Incrementable, CategoryOrTraversal, Difference >::type { typedef typename detail::counting_iterator_base< Incrementable, CategoryOrTraversal, Difference >::type super_t; friend class iterator_core_access; public: typedef typename super_t::difference_type difference_type; counting_iterator() { } counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {} counting_iterator(Incrementable x) : super_t(x) { } # if 0 template<class OtherIncrementable> counting_iterator( counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& t , typename enable_if_convertible<OtherIncrementable, Incrementable>::type* = 0 ) : super_t(t.base()) {} # endif private: typename super_t::reference dereference() const { return this->base_reference(); } template <class OtherIncrementable> difference_type distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const { typedef typename mpl::if_< detail::is_numeric<Incrementable> , detail::number_distance<difference_type, Incrementable, OtherIncrementable> , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable> >::type d; return d::distance(this->base(), y.base()); } }; // Manufacture a counting iterator for an arbitrary incrementable type template <class Incrementable> inline counting_iterator<Incrementable> make_counting_iterator(Incrementable x) { typedef counting_iterator<Incrementable> result_t; return result_t(x); } } // namespace iterators using iterators::counting_iterator; using iterators::make_counting_iterator; } // namespace boost #endif // COUNTING_ITERATOR_DWA200348_HPP PK h!\r� �w w is_lvalue_iterator.hppnu �[��� // Copyright David Abrahams 2003. 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) #ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP # define IS_LVALUE_ITERATOR_DWA2003112_HPP #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> // 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 { namespace detail { #ifndef BOOST_NO_LVALUE_RETURN_DETECTION // Calling lvalue_preserver( <expression>, 0 ) returns a reference // to the expression's result if <expression> is an lvalue, or // not_an_lvalue() otherwise. struct not_an_lvalue {}; template <class T> T& lvalue_preserver(T&, int); template <class U> not_an_lvalue lvalue_preserver(U const&, ...); # define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0) #else # define BOOST_LVALUE_PRESERVER(expr) expr #endif // Guts of is_lvalue_iterator. Value is the iterator's value_type // and the result is computed in the nested rebind template. template <class Value> struct is_lvalue_iterator_impl { // Eat implicit conversions so we don't report true for things // convertible to Value const& struct conversion_eater { conversion_eater(typename add_lvalue_reference<Value>::type); }; static char tester(conversion_eater, int); static char (& tester(any_conversion_eater, ...) )[2]; template <class It> struct rebind { static It& x; BOOST_STATIC_CONSTANT( bool , value = ( sizeof( is_lvalue_iterator_impl<Value>::tester( BOOST_LVALUE_PRESERVER(*x), 0 ) ) == 1 ) ); }; }; #undef BOOST_LVALUE_PRESERVER // // void specializations to handle std input and output iterators // template <> struct is_lvalue_iterator_impl<void> { template <class It> struct rebind : boost::mpl::false_ {}; }; #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS template <> struct is_lvalue_iterator_impl<const void> { template <class It> struct rebind : boost::mpl::false_ {}; }; template <> struct is_lvalue_iterator_impl<volatile void> { template <class It> struct rebind : boost::mpl::false_ {}; }; template <> struct is_lvalue_iterator_impl<const volatile void> { template <class It> struct rebind : boost::mpl::false_ {}; }; #endif // // This level of dispatching is required for Borland. We might save // an instantiation by removing it for others. // template <class It> struct is_readable_lvalue_iterator_impl : is_lvalue_iterator_impl< BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type const >::template rebind<It> {}; template <class It> struct is_non_const_lvalue_iterator_impl : is_lvalue_iterator_impl< BOOST_DEDUCED_TYPENAME std::iterator_traits<It>::value_type >::template rebind<It> {}; } // 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: 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: BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_non_const_lvalue_iterator,(T)) }; } // namespace iterators using iterators::is_lvalue_iterator; using iterators::is_non_const_lvalue_iterator; } // namespace boost #endif #include <boost/iterator/detail/config_undef.hpp> #endif // IS_LVALUE_ITERATOR_DWA2003112_HPP PK h!\-�" interoperable.hppnu �[��� // (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_INTEROPERABLE_23022003THW_HPP # define BOOST_INTEROPERABLE_23022003THW_HPP # 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 { namespace iterators { // // Meta function that determines whether two // iterator types are considered interoperable. // // Two iterator types A,B are considered interoperable if either // A is convertible to B or vice versa. // This interoperability definition is in sync with the // standards requirements on constant/mutable container // iterators (23.1 [lib.container.requirements]). // // For compilers that don't support is_convertible // is_interoperable gives false positives. See comments // on operator implementation for consequences. // 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 { }; } // namespace iterators using iterators::is_interoperable; } // namespace boost # include <boost/iterator/detail/config_undef.hpp> #endif // BOOST_INTEROPERABLE_23022003THW_HPP PK h!\ܧE$L L distance.hppnu �[��� PK h!\�mI�� � � function_input_iterator.hppnu �[��� PK h!\U�� � � minimum_category.hppnu �[��� PK h!\}[fu! ! �& transform_iterator.hppnu �[��� PK h!\���� � 6> iterator_traits.hppnu �[��� PK h!\y�ޡ< �< $D iterator_archetypes.hppnu �[��� PK h!\�É� � � iterator_concepts.hppnu �[��� PK h!\ ��ү� �� :� iterator_facade.hppnu �[��� PK h!\'���o o ,& is_readable_iterator.hppnu �[��� PK h!\�(T� � �1 function_output_iterator.hppnu �[��� PK h!\�z�; ; �8 permutation_iterator.hppnu �[��� PK h!\��/p� � |B detail/config_def.hppnu �[��� PK h!\��c�� � �R detail/minimum_category.hppnu �[��� PK h!\1F��` ` # }U detail/facade_iterator_category.hppnu �[��� PK h!\# 6� � 0m detail/enable_if.hppnu �[��� PK h!\��N� � �t detail/config_undef.hppnu �[��� PK h!\ ��6� � �w detail/any_conversion_eater.hppnu �[��� PK h!\N�>(�( �( �z zip_iterator.hppnu �[��� PK h!\�y4h@ @ �� filter_iterator.hppnu �[��� PK h!\�4�9 2� reverse_iterator.hppnu �[��� PK h!\ �:��+ �+ }� iterator_adaptor.hppnu �[��� PK h!\��hF F G� iterator_categories.hppnu �[��� PK h!\��d � advance.hppnu �[��� PK h!\2T indirect_iterator.hppnu �[��� PK h!\�j�3� � n new_iterator_tests.hppnu �[��� PK h!\�;�� � V4 counting_iterator.hppnu �[��� PK h!\r� �w w #M is_lvalue_iterator.hppnu �[��� PK h!\-�" �] interoperable.hppnu �[��� PK ` 6d
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????