#include <boost/iterator/iterator_facade.hpp>
#include <vector>
#include <cassert>

namespace test
{
  template<typename ValueType, typename ReferenceType /*= ValueType&*/>
  class iterator_base
    : public boost::iterator_facade<iterator_base<ValueType, ReferenceType>,
                                    ValueType,
                                    boost::forward_traversal_tag>
  {
    friend class boost::iterator_core_access;
    
  protected:
    virtual void increment() = 0;
    virtual ReferenceType dereference() const = 0;
    
  public:
    virtual bool equal(iterator_base const & other) const = 0;
    virtual iterator_base* clone() const = 0;
  };


  template<typename CPlusPlusIterator>
  class cplusplus_iterator_adaptor
    : public iterator_base<typename std::iterator_traits<CPlusPlusIterator>::value_type,
			   typename std::iterator_traits<CPlusPlusIterator>::reference>
  {
  private:
    CPlusPlusIterator backing;
    typedef typename std::iterator_traits<CPlusPlusIterator>::value_type ValueType;
    typedef typename std::iterator_traits<CPlusPlusIterator>::reference Reference;
    
  public:
    cplusplus_iterator_adaptor()
    {}
    
    cplusplus_iterator_adaptor(cplusplus_iterator_adaptor const & other)
      : backing(other.backing)
    {}
    
    explicit cplusplus_iterator_adaptor(CPlusPlusIterator iter)
      : backing(iter)
    {}
    
    
    virtual cplusplus_iterator_adaptor* clone() const {
      return new cplusplus_iterator_adaptor(*this);
    }
    
    virtual void increment() {
      ++backing;
    }
    
    virtual bool equal(iterator_base<ValueType, Reference> const & other) const {
      const cplusplus_iterator_adaptor * p =
	dynamic_cast<cplusplus_iterator_adaptor const*>(&other);
      
      if (p) {
	return backing == p->backing;
      }
      else {
	return false;
      }
    }
    
    Reference dereference() const {
      return *backing;
    }
  };


  template<typename ValueType, typename ReferenceType = ValueType &>
  class iterator_base_wrapper
    : public boost::iterator_facade<iterator_base_wrapper<ValueType, ReferenceType>,
				    ValueType,
				    boost::forward_traversal_tag,
				    ReferenceType>
  {
  private:
    // iterator_base_wrapper acts as the RAII class for this. I
    // really want a cloning smart pointer, but there isn't one
    // standard. So I'll do it myself.
    iterator_base<ValueType, ReferenceType> * backing;

  public:
    iterator_base_wrapper()
      : backing(0)
    {}

    iterator_base_wrapper(iterator_base_wrapper const & other)
      : backing(other.backing->clone())
    {}

    template<typename V, typename R>
    explicit iterator_base_wrapper(iterator_base<V, R> const & base)
      : backing(base.clone())
    {}

    /////////////////////////////
    // Functions to support RAII

  private:
    void swap(iterator_base_wrapper & other) const // throw()
    {
      std::swap(backing, other.backing);
    }

  public:
    iterator_base_wrapper & operator=(iterator_base_wrapper const & other)
    {
      // Copy-and-swap
      iterator_base_wrapper copy(other);
      swap(copy);
      return *this;
    }

    ~iterator_base_wrapper()
    {
      delete backing;
    }

            
  private:
    friend class boost::iterator_core_access;
            
    ////////////////////////////////
    // Iterator functions
    virtual void increment()
    {
      ++(*backing);
    }

    virtual bool equal(iterator_base_wrapper const & other) const
    {
      return backing->equal(*other.backing);
    }

    ReferenceType dereference() const
    {
      return **backing;
    }
  };


  int run()
  {
    const int arr[] = {0,1,2,3,4,5,6,7,8,9,10};
    const int size_arr = sizeof(arr)/sizeof(arr[0]);

    std::vector<int> v(arr, arr+size_arr);

    // Works with vector<int>::iterator (if you also remove the consts
    // from a couple lines down), fails with
    // vector<int>::const_iterator,
    cplusplus_iterator_adaptor<std::vector<int>::const_iterator> a_begin(v.begin());
    cplusplus_iterator_adaptor<std::vector<int>::const_iterator> a_end(v.end());

    iterator_base_wrapper<const int, const int &> ii(a_begin);
    iterator_base_wrapper<const int, const int &> ii_end(a_end);

    std::vector<int>::const_iterator vi = v.begin();
    while(ii != ii_end) {
      assert( *vi == *ii );
      ++vi;
      ++ii;
    }
    assert( vi == v.end() );

    return 0;
  }

}


int main() { return test::run(); }