Subject: [Boost-commit] svn:boost r63605 - in sandbox/SOC/2009/unicode/boost/iterator: . detail
From: loufoque_at_[hidden]
Date: 2010-07-04 12:42:34
Author: mgaunard
Date: 2010-07-04 12:42:33 EDT (Sun, 04 Jul 2010)
New Revision: 63605
URL: http://svn.boost.org/trac/boost/changeset/63605
Log:
removing unused any_iterator
Removed:
sandbox/SOC/2009/unicode/boost/iterator/any_iterator.hpp
sandbox/SOC/2009/unicode/boost/iterator/detail/
Deleted: sandbox/SOC/2009/unicode/boost/iterator/any_iterator.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/iterator/any_iterator.hpp 2010-07-04 12:42:33 EDT (Sun, 04 Jul 2010)
+++ (empty file)
@@ -1,422 +0,0 @@
-// (C) Copyright Thomas Becker 2005. Permission to copy, use, modify, sell and
-// distribute this software is granted provided this copyright notice appears
-// in all copies. This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-
-// Revision History
-// ================
-//
-// 27 Dec 2006 (Thomas Becker) Created
-
-#ifndef ANY_ITERATOR_01102007TMB_HPP
-#define ANY_ITERATOR_01102007TMB_HPP
-
-// Includes
-// ========
-
-#include "detail/any_iterator_abstract_base.hpp"
-#include "detail/any_iterator_wrapper.hpp"
-#include "detail/any_iterator_metafunctions.hpp"
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/static_assert.hpp>
-
-namespace boost
-{
-
- ///////////////////////////////////////////////////////////////////////
- //
- // The any_iterator is modeled after the "type erasure pattern" as set
- // forth in boost::any. The class names correspond as follows:
- //
- // boost::any ==> any_iterator
- // boost::any::placeholder ==> any_iterator_abstract_base
- // boost::any::holder ==> any_iterator_wrapper
- //
- template<
- class Value,
- class CategoryOrTraversal,
- class Reference = Value&,
- class Difference = std::ptrdiff_t
- >
- class any_iterator :
- public boost::iterator_facade<
- any_iterator<
- Value,
- CategoryOrTraversal,
- Reference,
- Difference
- >,
- Value,
- CategoryOrTraversal,
- Reference,
- Difference
- >
- {
-
- // We make every other any_iterator our friend. This is needed only for
- // the conversion from non-const to const, but there should be no harm
- // in being overly friendly here.
- template<
- class OtherValue,
- class OtherCategoryOrTraversal,
- class OtherReference,
- class OtherDifference
- >
- friend class any_iterator;
-
- public:
- typedef typename boost::iterator_category_to_traversal<CategoryOrTraversal>::type Traversal;
-
- private:
-
- struct enabler{}; // a private type avoids misuse
- struct disabler{}; // a private type avoids misuse
-
- // The type-erasing abstract base class, that is, the type that the
- // impl-pointer points to.
- typedef
- detail::any_iterator_abstract_base<
- Value,
- Traversal,
- Reference,
- Difference
- > abstract_base_type;
-
- typedef
- boost::iterator_facade<
- any_iterator<
- Value,
- CategoryOrTraversal,
- Reference,
- Difference
- >,
- Value,
- CategoryOrTraversal,
- Reference,
- Difference
- > super_type;
-
- // The two types that this any_iterator type recognizes as const versions of
- // itself.
- typedef any_iterator<
- typename boost::add_const<Value>::type,
- CategoryOrTraversal,
- typename detail::make_iterator_reference_const<Reference>::type,
- Difference
- > const_type_with_const_value_type;
- //
- typedef any_iterator<
- typename boost::remove_const<Value>::type,
- CategoryOrTraversal,
- typename detail::make_iterator_reference_const<Reference>::type,
- Difference
- > const_type_with_non_const_value_type;
-
- public:
-
- any_iterator() : m_pointer_to_impl(NULL)
- {}
-
- any_iterator(any_iterator const & rhs) : super_type(rhs)
- {
- if( rhs.m_pointer_to_impl )
- {
- m_pointer_to_impl = rhs.m_pointer_to_impl->clone();
- }
- else
- {
- m_pointer_to_impl = NULL;
- }
- }
-
- any_iterator& operator=(any_iterator const & rhs)
- {
- if(this != &rhs)
- {
- any_iterator tmp(rhs);
- swap(tmp);
- }
-
- return *this;
- }
-
- // Constructor from wrapped iterator. The static assert defines the
- // granularity of the type erasure.
- //
- // NOTE 1: If you want to make the constructor non-explicit, then you
- // really must replace the static assert with an enable_if, or else
- // metafunctions such as is_convertible will say the wrong thing.
- // However, if you use enable_if here, you'll descend into the ugly
- // mess described in the last section of my article at
- // http://www.artima.com/cppsource/type_erasure.html.
- //
- // NOTE 2: If you remove the restriction that the wrapped iterator
- // cannot be an any_iterator, you must ensure that the conversions from
- // non-const to const any_iterators still work correctly. If you don't
- // do anything, you will end up with wrapping instead of conversion.
- //
- template<class WrappedIterator>
- explicit any_iterator(
- WrappedIterator const & wrapped_iterator,
- typename boost::disable_if<
- detail::is_any_iterator<WrappedIterator>,
- disabler
- >::type = disabler()
- )
- {
- //////////////////////////////////////////////////////////////////
- //
- // *** Message to Client ***
- //
- // If this static assert fires, you are trying to construct the any_iterator
- // from a concrete iterator that is not suitable for the type erasure that
- // the any_iterator provides.
- //
- BOOST_STATIC_ASSERT((detail::is_iterator_type_erasure_compatible<WrappedIterator, any_iterator>::type::value));
-
- typedef
- detail::any_iterator_wrapper<
- WrappedIterator,
- Value,
- Traversal,
- Reference,
- Difference
- > wrapper_type;
-
- m_pointer_to_impl = wrapper_type::create(wrapped_iterator);
- }
-
- // Assignment from wrapped iterator. The enable_if condition defines
- // the granularity of the type erasure.
- //
- // NOTE: If you remove the restriction that the wrapped iterator
- // cannot be an any_iterator, you must ensure that the conversions from
- // non-const to const any_iterators still work correctly. If you don't
- // do anything, you will end up with wrapping instead of conversion.
- template<class WrappedIterator>
- typename boost::enable_if<
- boost::mpl::and_<
- detail::is_iterator_type_erasure_compatible<WrappedIterator, any_iterator>,
- boost::mpl::not_<detail::is_any_iterator<WrappedIterator> >
- >,
- any_iterator
- >::type &
- operator=(WrappedIterator const & wrapped_iterator)
- {
- any_iterator tmp(wrapped_iterator);
- swap(tmp);
- return *this;
- }
-
- // Conversion from non-const to const any_iterator. There are two versions.
- // This first one applies if the target has const value type.
- operator const_type_with_const_value_type () const
- {
- const_type_with_const_value_type conversion_result;
- if( m_pointer_to_impl )
- {
- conversion_result.m_pointer_to_impl = m_pointer_to_impl->make_const_clone_with_const_value_type();
- }
- return conversion_result;
- }
-
- // Conversion from non-const to const any_iterator. There are two versions.
- // This second one applies if the target has non-const value type.
- operator const_type_with_non_const_value_type () const
- {
- const_type_with_non_const_value_type conversion_result;
- if( m_pointer_to_impl )
- {
- conversion_result.m_pointer_to_impl = m_pointer_to_impl->make_const_clone_with_non_const_value_type();
- }
- return conversion_result;
- }
-
- // Conversion to weaker traversal type
- template<typename TargetTraversal>
- operator any_iterator<
- Value,
- TargetTraversal,
- Reference,
- Difference
- >
- () const
- {
- //////////////////////////////////////////////////////////////////
- //
- // *** Message to Client ***
- //
- // If this static assert fires, you are trying to convert between two
- // any_iterator types that are not suitable for conversion.
- //
- BOOST_STATIC_ASSERT((
- boost::is_base_of<
- typename boost::iterator_category_to_traversal<TargetTraversal>::type,
- typename boost::iterator_category_to_traversal<CategoryOrTraversal>::type
- >::type::value
- ));
-
- any_iterator<
- Value,
- TargetTraversal,
- Reference,
- Difference
- > conversion_result;
-
- if( m_pointer_to_impl )
- {
- typename boost::iterator_category_to_traversal<TargetTraversal>::type* funcSelector = NULL;
- conversion_result.m_pointer_to_impl = make_traversal_converted_version(funcSelector);
- }
- return conversion_result;
- }
-
- ~any_iterator()
- {
- delete m_pointer_to_impl;
- }
-
- private:
-
- friend class boost::iterator_core_access;
-
- Reference dereference() const
- {
- return m_pointer_to_impl->dereference();
- }
-
- bool equal(any_iterator const & rhs) const
- {
- if( m_pointer_to_impl == rhs.m_pointer_to_impl )
- {
- return true;
- }
-
- if( m_pointer_to_impl == NULL || rhs.m_pointer_to_impl == NULL )
- {
- return false;
- }
-
- //////////////////////////////////////////////////////////////////
- //
- // *** Message to Client ***
- //
- // If the next line does not compile, you are trying to compare
- // two iterators for equality whose categories do not allow that
- // comparison.
- return m_pointer_to_impl->equal(*(rhs.m_pointer_to_impl));
- }
-
- void increment()
- {
- m_pointer_to_impl->increment();
- }
-
- void decrement()
- {
- //////////////////////////////////////////////////////////////////
- //
- // *** Message to Client ***
- //
- // If the next line does not compile, you are trying to decrement
- // an iterator whose category does not allow decrementing.
- return m_pointer_to_impl->decrement();
- }
-
- void advance(Difference n)
- {
- //////////////////////////////////////////////////////////////////
- //
- // *** Message to Client ***
- //
- // If the next line does not compile, you are trying to use an
- // operation that is defined only for random access iterators
- // on an iterator that is not random access.
- m_pointer_to_impl->advance(n);
- }
-
- Difference distance_to(any_iterator const & other) const
- {
- //////////////////////////////////////////////////////////////////
- //
- // *** Message to Client ***
- //
- // If the next line does not compile, you are trying to use an
- // operation that is defined only for random access iterators
- // on an iterator that is not random access.
- return m_pointer_to_impl->distance_to(*(other.m_pointer_to_impl));
- }
-
- any_iterator& swap(any_iterator& other)
- {
- // NOTE: iterator_facade doesn't have a swap method, so no call
- // to base class here.
- std::swap(m_pointer_to_impl, other.m_pointer_to_impl);
- return *this;
- }
-
- detail::any_iterator_abstract_base<
- Value,
- boost::incrementable_traversal_tag,
- Reference,
- Difference
- >* make_traversal_converted_version(boost::incrementable_traversal_tag* funcSelector) const
- {
- return m_pointer_to_impl->make_incrementable_version();
- }
-
- detail::any_iterator_abstract_base<
- Value,
- boost::single_pass_traversal_tag,
- Reference,
- Difference
- >* make_traversal_converted_version(boost::single_pass_traversal_tag* funcSelector) const
- {
- return m_pointer_to_impl->make_single_pass_version();
- }
-
- detail::any_iterator_abstract_base<
- Value,
- boost::forward_traversal_tag,
- Reference,
- Difference
- >* make_traversal_converted_version(boost::forward_traversal_tag* funcSelector) const
- {
- return m_pointer_to_impl->make_forward_version();
- }
-
- detail::any_iterator_abstract_base<
- Value,
- boost::bidirectional_traversal_tag,
- Reference,
- Difference
- >* make_traversal_converted_version(boost::bidirectional_traversal_tag* funcSelector) const
- {
- return m_pointer_to_impl->make_bidirectional_version();
- }
-
- abstract_base_type* m_pointer_to_impl;
-
- };
-
- // Metafunction that takes an iterator and returns an any_iterator with the same
- // traits.
- template<class iterator>
- struct make_any_iterator_type
- {
- typedef
- any_iterator<
- typename boost::iterator_value<iterator>::type,
- typename boost::iterator_category<iterator>::type,
- typename boost::iterator_reference<iterator>::type,
- typename boost::iterator_difference<iterator>::type
- > type;
- };
-
-} // end namespace IteratorTypeErasure
-
-#endif // ANY_ITERATOR_01102007TMB_HPP