Chris@16: //////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: // (C) Copyright Ion Gaztanaga 2005-2012.
Chris@16: // (C) Copyright Gennaro Prota 2003 - 2004.
Chris@16: //
Chris@16: // Distributed under the Boost Software License, Version 1.0.
Chris@16: // (See accompanying file LICENSE_1_0.txt or copy at
Chris@16: // http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: // See http://www.boost.org/libs/container for documentation.
Chris@16: //
Chris@16: //////////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: #ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP
Chris@16: #define BOOST_CONTAINER_DETAIL_ITERATORS_HPP
Chris@16: 
Chris@16: #if defined(_MSC_VER)
Chris@16: #  pragma once
Chris@16: #endif
Chris@16: 
Chris@16: #include "config_begin.hpp"
Chris@16: #include <boost/container/detail/workaround.hpp>
Chris@16: #include <boost/move/utility.hpp>
Chris@16: #include <boost/container/allocator_traits.hpp>
Chris@16: #include <boost/container/detail/type_traits.hpp>
Chris@16: #include <boost/static_assert.hpp>
Chris@16: 
Chris@16: #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
Chris@16: #include <boost/container/detail/variadic_templates_tools.hpp>
Chris@16: #else
Chris@16: #include <boost/container/detail/preprocessor.hpp>
Chris@16: #endif
Chris@16: 
Chris@16: #include <iterator>
Chris@16: 
Chris@16: namespace boost {
Chris@16: namespace container {
Chris@16: 
Chris@16: template <class T, class Difference = std::ptrdiff_t>
Chris@16: class constant_iterator
Chris@16:   : public std::iterator
Chris@16:       <std::random_access_iterator_tag, T, Difference, const T*, const T &>
Chris@16: {
Chris@16:    typedef  constant_iterator<T, Difference> this_type;
Chris@16: 
Chris@16:    public:
Chris@16:    explicit constant_iterator(const T &ref, Difference range_size)
Chris@16:       :  m_ptr(&ref), m_num(range_size){}
Chris@16: 
Chris@16:    //Constructors
Chris@16:    constant_iterator()
Chris@16:       :  m_ptr(0), m_num(0){}
Chris@16: 
Chris@16:    constant_iterator& operator++()
Chris@16:    { increment();   return *this;   }
Chris@16:   
Chris@16:    constant_iterator operator++(int)
Chris@16:    {
Chris@16:       constant_iterator result (*this);
Chris@16:       increment();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    constant_iterator& operator--()
Chris@16:    { decrement();   return *this;   }
Chris@16:   
Chris@16:    constant_iterator operator--(int)
Chris@16:    {
Chris@16:       constant_iterator result (*this);
Chris@16:       decrement();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return i.equal(i2); }
Chris@16: 
Chris@16:    friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return !(i == i2); }
Chris@16: 
Chris@16:    friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return i.less(i2); }
Chris@16: 
Chris@16:    friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return i2 < i; }
Chris@16: 
Chris@16:    friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return !(i > i2); }
Chris@16: 
Chris@16:    friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return !(i < i2); }
Chris@16: 
Chris@16:    friend Difference operator- (const constant_iterator& i, const constant_iterator& i2)
Chris@16:    { return i2.distance_to(i); }
Chris@16: 
Chris@16:    //Arithmetic
Chris@16:    constant_iterator& operator+=(Difference off)
Chris@16:    {  this->advance(off); return *this;   }
Chris@16: 
Chris@16:    constant_iterator operator+(Difference off) const
Chris@16:    {
Chris@16:       constant_iterator other(*this);
Chris@16:       other.advance(off);
Chris@16:       return other;
Chris@16:    }
Chris@16: 
Chris@16:    friend constant_iterator operator+(Difference off, const constant_iterator& right)
Chris@16:    {  return right + off; }
Chris@16: 
Chris@16:    constant_iterator& operator-=(Difference off)
Chris@16:    {  this->advance(-off); return *this;   }
Chris@16: 
Chris@16:    constant_iterator operator-(Difference off) const
Chris@16:    {  return *this + (-off);  }
Chris@16: 
Chris@16:    const T& operator*() const
Chris@16:    { return dereference(); }
Chris@16: 
Chris@16:    const T& operator[] (Difference ) const
Chris@16:    { return dereference(); }
Chris@16: 
Chris@16:    const T* operator->() const
Chris@16:    { return &(dereference()); }
Chris@16: 
Chris@16:    private:
Chris@16:    const T *   m_ptr;
Chris@16:    Difference  m_num;
Chris@16: 
Chris@16:    void increment()
Chris@16:    { --m_num; }
Chris@16: 
Chris@16:    void decrement()
Chris@16:    { ++m_num; }
Chris@16: 
Chris@16:    bool equal(const this_type &other) const
Chris@16:    {  return m_num == other.m_num;   }
Chris@16: 
Chris@16:    bool less(const this_type &other) const
Chris@16:    {  return other.m_num < m_num;   }
Chris@16: 
Chris@16:    const T & dereference() const
Chris@16:    { return *m_ptr; }
Chris@16: 
Chris@16:    void advance(Difference n)
Chris@16:    {  m_num -= n; }
Chris@16: 
Chris@16:    Difference distance_to(const this_type &other)const
Chris@16:    {  return m_num - other.m_num;   }
Chris@16: };
Chris@16: 
Chris@16: template <class T, class Difference = std::ptrdiff_t>
Chris@16: class value_init_construct_iterator
Chris@16:   : public std::iterator
Chris@16:       <std::random_access_iterator_tag, T, Difference, const T*, const T &>
Chris@16: {
Chris@16:    typedef  value_init_construct_iterator<T, Difference> this_type;
Chris@16: 
Chris@16:    public:
Chris@16:    explicit value_init_construct_iterator(Difference range_size)
Chris@16:       :  m_num(range_size){}
Chris@16: 
Chris@16:    //Constructors
Chris@16:    value_init_construct_iterator()
Chris@16:       :  m_num(0){}
Chris@16: 
Chris@16:    value_init_construct_iterator& operator++()
Chris@16:    { increment();   return *this;   }
Chris@16:   
Chris@16:    value_init_construct_iterator operator++(int)
Chris@16:    {
Chris@16:       value_init_construct_iterator result (*this);
Chris@16:       increment();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    value_init_construct_iterator& operator--()
Chris@16:    { decrement();   return *this;   }
Chris@16:   
Chris@16:    value_init_construct_iterator operator--(int)
Chris@16:    {
Chris@16:       value_init_construct_iterator result (*this);
Chris@16:       decrement();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return i.equal(i2); }
Chris@16: 
Chris@16:    friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return !(i == i2); }
Chris@16: 
Chris@16:    friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return i.less(i2); }
Chris@16: 
Chris@16:    friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return i2 < i; }
Chris@16: 
Chris@16:    friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return !(i > i2); }
Chris@16: 
Chris@16:    friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return !(i < i2); }
Chris@16: 
Chris@16:    friend Difference operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
Chris@16:    { return i2.distance_to(i); }
Chris@16: 
Chris@16:    //Arithmetic
Chris@16:    value_init_construct_iterator& operator+=(Difference off)
Chris@16:    {  this->advance(off); return *this;   }
Chris@16: 
Chris@16:    value_init_construct_iterator operator+(Difference off) const
Chris@16:    {
Chris@16:       value_init_construct_iterator other(*this);
Chris@16:       other.advance(off);
Chris@16:       return other;
Chris@16:    }
Chris@16: 
Chris@16:    friend value_init_construct_iterator operator+(Difference off, const value_init_construct_iterator& right)
Chris@16:    {  return right + off; }
Chris@16: 
Chris@16:    value_init_construct_iterator& operator-=(Difference off)
Chris@16:    {  this->advance(-off); return *this;   }
Chris@16: 
Chris@16:    value_init_construct_iterator operator-(Difference off) const
Chris@16:    {  return *this + (-off);  }
Chris@16: 
Chris@16:    //This pseudo-iterator's dereference operations have no sense since value is not
Chris@16:    //constructed until ::boost::container::construct_in_place is called.
Chris@16:    //So comment them to catch bad uses
Chris@16:    //const T& operator*() const;
Chris@16:    //const T& operator[](difference_type) const;
Chris@16:    //const T* operator->() const;
Chris@16: 
Chris@16:    private:
Chris@16:    Difference  m_num;
Chris@16: 
Chris@16:    void increment()
Chris@16:    { --m_num; }
Chris@16: 
Chris@16:    void decrement()
Chris@16:    { ++m_num; }
Chris@16: 
Chris@16:    bool equal(const this_type &other) const
Chris@16:    {  return m_num == other.m_num;   }
Chris@16: 
Chris@16:    bool less(const this_type &other) const
Chris@16:    {  return other.m_num < m_num;   }
Chris@16: 
Chris@16:    const T & dereference() const
Chris@16:    {
Chris@16:       static T dummy;
Chris@16:       return dummy;
Chris@16:    }
Chris@16: 
Chris@16:    void advance(Difference n)
Chris@16:    {  m_num -= n; }
Chris@16: 
Chris@16:    Difference distance_to(const this_type &other)const
Chris@16:    {  return m_num - other.m_num;   }
Chris@16: };
Chris@16: 
Chris@16: template <class T, class Difference = std::ptrdiff_t>
Chris@16: class default_init_construct_iterator
Chris@16:   : public std::iterator
Chris@16:       <std::random_access_iterator_tag, T, Difference, const T*, const T &>
Chris@16: {
Chris@16:    typedef  default_init_construct_iterator<T, Difference> this_type;
Chris@16: 
Chris@16:    public:
Chris@16:    explicit default_init_construct_iterator(Difference range_size)
Chris@16:       :  m_num(range_size){}
Chris@16: 
Chris@16:    //Constructors
Chris@16:    default_init_construct_iterator()
Chris@16:       :  m_num(0){}
Chris@16: 
Chris@16:    default_init_construct_iterator& operator++()
Chris@16:    { increment();   return *this;   }
Chris@16:   
Chris@16:    default_init_construct_iterator operator++(int)
Chris@16:    {
Chris@16:       default_init_construct_iterator result (*this);
Chris@16:       increment();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    default_init_construct_iterator& operator--()
Chris@16:    { decrement();   return *this;   }
Chris@16:   
Chris@16:    default_init_construct_iterator operator--(int)
Chris@16:    {
Chris@16:       default_init_construct_iterator result (*this);
Chris@16:       decrement();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return i.equal(i2); }
Chris@16: 
Chris@16:    friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return !(i == i2); }
Chris@16: 
Chris@16:    friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return i.less(i2); }
Chris@16: 
Chris@16:    friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return i2 < i; }
Chris@16: 
Chris@16:    friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return !(i > i2); }
Chris@16: 
Chris@16:    friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return !(i < i2); }
Chris@16: 
Chris@16:    friend Difference operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
Chris@16:    { return i2.distance_to(i); }
Chris@16: 
Chris@16:    //Arithmetic
Chris@16:    default_init_construct_iterator& operator+=(Difference off)
Chris@16:    {  this->advance(off); return *this;   }
Chris@16: 
Chris@16:    default_init_construct_iterator operator+(Difference off) const
Chris@16:    {
Chris@16:       default_init_construct_iterator other(*this);
Chris@16:       other.advance(off);
Chris@16:       return other;
Chris@16:    }
Chris@16: 
Chris@16:    friend default_init_construct_iterator operator+(Difference off, const default_init_construct_iterator& right)
Chris@16:    {  return right + off; }
Chris@16: 
Chris@16:    default_init_construct_iterator& operator-=(Difference off)
Chris@16:    {  this->advance(-off); return *this;   }
Chris@16: 
Chris@16:    default_init_construct_iterator operator-(Difference off) const
Chris@16:    {  return *this + (-off);  }
Chris@16: 
Chris@16:    //This pseudo-iterator's dereference operations have no sense since value is not
Chris@16:    //constructed until ::boost::container::construct_in_place is called.
Chris@16:    //So comment them to catch bad uses
Chris@16:    //const T& operator*() const;
Chris@16:    //const T& operator[](difference_type) const;
Chris@16:    //const T* operator->() const;
Chris@16: 
Chris@16:    private:
Chris@16:    Difference  m_num;
Chris@16: 
Chris@16:    void increment()
Chris@16:    { --m_num; }
Chris@16: 
Chris@16:    void decrement()
Chris@16:    { ++m_num; }
Chris@16: 
Chris@16:    bool equal(const this_type &other) const
Chris@16:    {  return m_num == other.m_num;   }
Chris@16: 
Chris@16:    bool less(const this_type &other) const
Chris@16:    {  return other.m_num < m_num;   }
Chris@16: 
Chris@16:    const T & dereference() const
Chris@16:    {
Chris@16:       static T dummy;
Chris@16:       return dummy;
Chris@16:    }
Chris@16: 
Chris@16:    void advance(Difference n)
Chris@16:    {  m_num -= n; }
Chris@16: 
Chris@16:    Difference distance_to(const this_type &other)const
Chris@16:    {  return m_num - other.m_num;   }
Chris@16: };
Chris@16: 
Chris@16: 
Chris@16: template <class T, class Difference = std::ptrdiff_t>
Chris@16: class repeat_iterator
Chris@16:   : public std::iterator
Chris@16:       <std::random_access_iterator_tag, T, Difference>
Chris@16: {
Chris@16:    typedef repeat_iterator<T, Difference> this_type;
Chris@16:    public:
Chris@16:    explicit repeat_iterator(T &ref, Difference range_size)
Chris@16:       :  m_ptr(&ref), m_num(range_size){}
Chris@16: 
Chris@16:    //Constructors
Chris@16:    repeat_iterator()
Chris@16:       :  m_ptr(0), m_num(0){}
Chris@16: 
Chris@16:    this_type& operator++()
Chris@16:    { increment();   return *this;   }
Chris@16:   
Chris@16:    this_type operator++(int)
Chris@16:    {
Chris@16:       this_type result (*this);
Chris@16:       increment();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    this_type& operator--()
Chris@16:    { increment();   return *this;   }
Chris@16:   
Chris@16:    this_type operator--(int)
Chris@16:    {
Chris@16:       this_type result (*this);
Chris@16:       increment();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    friend bool operator== (const this_type& i, const this_type& i2)
Chris@16:    { return i.equal(i2); }
Chris@16: 
Chris@16:    friend bool operator!= (const this_type& i, const this_type& i2)
Chris@16:    { return !(i == i2); }
Chris@16: 
Chris@16:    friend bool operator< (const this_type& i, const this_type& i2)
Chris@16:    { return i.less(i2); }
Chris@16: 
Chris@16:    friend bool operator> (const this_type& i, const this_type& i2)
Chris@16:    { return i2 < i; }
Chris@16: 
Chris@16:    friend bool operator<= (const this_type& i, const this_type& i2)
Chris@16:    { return !(i > i2); }
Chris@16: 
Chris@16:    friend bool operator>= (const this_type& i, const this_type& i2)
Chris@16:    { return !(i < i2); }
Chris@16: 
Chris@16:    friend Difference operator- (const this_type& i, const this_type& i2)
Chris@16:    { return i2.distance_to(i); }
Chris@16: 
Chris@16:    //Arithmetic
Chris@16:    this_type& operator+=(Difference off)
Chris@16:    {  this->advance(off); return *this;   }
Chris@16: 
Chris@16:    this_type operator+(Difference off) const
Chris@16:    {
Chris@16:       this_type other(*this);
Chris@16:       other.advance(off);
Chris@16:       return other;
Chris@16:    }
Chris@16: 
Chris@16:    friend this_type operator+(Difference off, const this_type& right)
Chris@16:    {  return right + off; }
Chris@16: 
Chris@16:    this_type& operator-=(Difference off)
Chris@16:    {  this->advance(-off); return *this;   }
Chris@16: 
Chris@16:    this_type operator-(Difference off) const
Chris@16:    {  return *this + (-off);  }
Chris@16: 
Chris@16:    T& operator*() const
Chris@16:    { return dereference(); }
Chris@16: 
Chris@16:    T& operator[] (Difference ) const
Chris@16:    { return dereference(); }
Chris@16: 
Chris@16:    T *operator->() const
Chris@16:    { return &(dereference()); }
Chris@16: 
Chris@16:    private:
Chris@16:    T *         m_ptr;
Chris@16:    Difference  m_num;
Chris@16: 
Chris@16:    void increment()
Chris@16:    { --m_num; }
Chris@16: 
Chris@16:    void decrement()
Chris@16:    { ++m_num; }
Chris@16: 
Chris@16:    bool equal(const this_type &other) const
Chris@16:    {  return m_num == other.m_num;   }
Chris@16: 
Chris@16:    bool less(const this_type &other) const
Chris@16:    {  return other.m_num < m_num;   }
Chris@16: 
Chris@16:    T & dereference() const
Chris@16:    { return *m_ptr; }
Chris@16: 
Chris@16:    void advance(Difference n)
Chris@16:    {  m_num -= n; }
Chris@16: 
Chris@16:    Difference distance_to(const this_type &other)const
Chris@16:    {  return m_num - other.m_num;   }
Chris@16: };
Chris@16: 
Chris@16: template <class T, class EmplaceFunctor, class Difference /*= std::ptrdiff_t*/>
Chris@16: class emplace_iterator
Chris@16:   : public std::iterator
Chris@16:       <std::random_access_iterator_tag, T, Difference, const T*, const T &>
Chris@16: {
Chris@16:    typedef emplace_iterator this_type;
Chris@16: 
Chris@16:    public:
Chris@16:    typedef Difference difference_type;
Chris@16:    explicit emplace_iterator(EmplaceFunctor&e)
Chris@16:       :  m_num(1), m_pe(&e){}
Chris@16: 
Chris@16:    emplace_iterator()
Chris@16:       :  m_num(0), m_pe(0){}
Chris@16: 
Chris@16:    this_type& operator++()
Chris@16:    { increment();   return *this;   }
Chris@16:   
Chris@16:    this_type operator++(int)
Chris@16:    {
Chris@16:       this_type result (*this);
Chris@16:       increment();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    this_type& operator--()
Chris@16:    { decrement();   return *this;   }
Chris@16:   
Chris@16:    this_type operator--(int)
Chris@16:    {
Chris@16:       this_type result (*this);
Chris@16:       decrement();
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    friend bool operator== (const this_type& i, const this_type& i2)
Chris@16:    { return i.equal(i2); }
Chris@16: 
Chris@16:    friend bool operator!= (const this_type& i, const this_type& i2)
Chris@16:    { return !(i == i2); }
Chris@16: 
Chris@16:    friend bool operator< (const this_type& i, const this_type& i2)
Chris@16:    { return i.less(i2); }
Chris@16: 
Chris@16:    friend bool operator> (const this_type& i, const this_type& i2)
Chris@16:    { return i2 < i; }
Chris@16: 
Chris@16:    friend bool operator<= (const this_type& i, const this_type& i2)
Chris@16:    { return !(i > i2); }
Chris@16: 
Chris@16:    friend bool operator>= (const this_type& i, const this_type& i2)
Chris@16:    { return !(i < i2); }
Chris@16: 
Chris@16:    friend difference_type operator- (const this_type& i, const this_type& i2)
Chris@16:    { return i2.distance_to(i); }
Chris@16: 
Chris@16:    //Arithmetic
Chris@16:    this_type& operator+=(difference_type off)
Chris@16:    {  this->advance(off); return *this;   }
Chris@16: 
Chris@16:    this_type operator+(difference_type off) const
Chris@16:    {
Chris@16:       this_type other(*this);
Chris@16:       other.advance(off);
Chris@16:       return other;
Chris@16:    }
Chris@16: 
Chris@16:    friend this_type operator+(difference_type off, const this_type& right)
Chris@16:    {  return right + off; }
Chris@16: 
Chris@16:    this_type& operator-=(difference_type off)
Chris@16:    {  this->advance(-off); return *this;   }
Chris@16: 
Chris@16:    this_type operator-(difference_type off) const
Chris@16:    {  return *this + (-off);  }
Chris@16: 
Chris@16:    //This pseudo-iterator's dereference operations have no sense since value is not
Chris@16:    //constructed until ::boost::container::construct_in_place is called.
Chris@16:    //So comment them to catch bad uses
Chris@16:    //const T& operator*() const;
Chris@16:    //const T& operator[](difference_type) const;
Chris@16:    //const T* operator->() const;
Chris@16: 
Chris@16:    template<class A>
Chris@16:    void construct_in_place(A &a, T* ptr)
Chris@16:    {  (*m_pe)(a, ptr);  }
Chris@16: 
Chris@16:    private:
Chris@16:    difference_type m_num;
Chris@16:    EmplaceFunctor *            m_pe;
Chris@16: 
Chris@16:    void increment()
Chris@16:    { --m_num; }
Chris@16: 
Chris@16:    void decrement()
Chris@16:    { ++m_num; }
Chris@16: 
Chris@16:    bool equal(const this_type &other) const
Chris@16:    {  return m_num == other.m_num;   }
Chris@16: 
Chris@16:    bool less(const this_type &other) const
Chris@16:    {  return other.m_num < m_num;   }
Chris@16: 
Chris@16:    const T & dereference() const
Chris@16:    {
Chris@16:       static T dummy;
Chris@16:       return dummy;
Chris@16:    }
Chris@16: 
Chris@16:    void advance(difference_type n)
Chris@16:    {  m_num -= n; }
Chris@16: 
Chris@16:    difference_type distance_to(const this_type &other)const
Chris@16:    {  return difference_type(m_num - other.m_num);   }
Chris@16: };
Chris@16: 
Chris@16: #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
Chris@16: 
Chris@16: template<class ...Args>
Chris@16: struct emplace_functor
Chris@16: {
Chris@16:    typedef typename container_detail::build_number_seq<sizeof...(Args)>::type index_tuple_t;
Chris@16: 
Chris@16:    emplace_functor(Args&&... args)
Chris@16:       : args_(args...)
Chris@16:    {}
Chris@16: 
Chris@16:    template<class A, class T>
Chris@16:    void operator()(A &a, T *ptr)
Chris@16:    {  emplace_functor::inplace_impl(a, ptr, index_tuple_t());  }
Chris@16: 
Chris@16:    template<class A, class T, int ...IdxPack>
Chris@16:    void inplace_impl(A &a, T* ptr, const container_detail::index_tuple<IdxPack...>&)
Chris@16:    {
Chris@16:       allocator_traits<A>::construct
Chris@16:          (a, ptr, ::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
Chris@16:    }
Chris@16: 
Chris@16:    container_detail::tuple<Args&...> args_;
Chris@16: };
Chris@16: 
Chris@16: #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING
Chris@16: 
Chris@16: #define BOOST_PP_LOCAL_MACRO(n)                                                        \
Chris@16:    BOOST_PP_EXPR_IF(n, template <)                                                     \
Chris@16:       BOOST_PP_ENUM_PARAMS(n, class P)                                                 \
Chris@16:          BOOST_PP_EXPR_IF(n, >)                                                        \
Chris@16:    struct BOOST_PP_CAT(BOOST_PP_CAT(emplace_functor, n), arg)                          \
Chris@16:    {                                                                                   \
Chris@16:       BOOST_PP_CAT(BOOST_PP_CAT(emplace_functor, n), arg)                              \
Chris@16:          ( BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _) )                        \
Chris@16:       BOOST_PP_EXPR_IF(n, :) BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_INIT, _){}      \
Chris@16:                                                                                        \
Chris@16:       template<class A, class T>                                                       \
Chris@16:       void operator()(A &a, T *ptr)                                                    \
Chris@16:       {                                                                                \
Chris@16:          allocator_traits<A>::construct                                                \
Chris@16:             (a, ptr BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _) ); \
Chris@16:       }                                                                                \
Chris@16:       BOOST_PP_REPEAT(n, BOOST_CONTAINER_PP_PARAM_DEFINE, _)                           \
Chris@16:    };                                                                                  \
Chris@16:    //!
Chris@16: #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
Chris@16: #include BOOST_PP_LOCAL_ITERATE()
Chris@16: 
Chris@16: #endif
Chris@16: 
Chris@16: namespace container_detail {
Chris@16: 
Chris@16: template<class T>
Chris@16: struct has_iterator_category
Chris@16: {
Chris@16:    template <typename X>
Chris@16:    static char test(int, typename X::iterator_category*);
Chris@16: 
Chris@16:    template <typename X>
Chris@16:    static int test(int, ...);
Chris@16: 
Chris@16:    static const bool value = (1 == sizeof(test<T>(0, 0)));
Chris@16: };
Chris@16: 
Chris@16: 
Chris@16: template<class T, bool = has_iterator_category<T>::value >
Chris@16: struct is_input_iterator
Chris@16: {
Chris@16:    static const bool value = is_same<typename T::iterator_category, std::input_iterator_tag>::value;
Chris@16: };
Chris@16: 
Chris@16: template<class T>
Chris@16: struct is_input_iterator<T, false>
Chris@16: {
Chris@16:    static const bool value = false;
Chris@16: };
Chris@16: 
Chris@16: template<class T, bool = has_iterator_category<T>::value >
Chris@16: struct is_forward_iterator
Chris@16: {
Chris@16:    static const bool value = is_same<typename T::iterator_category, std::forward_iterator_tag>::value;
Chris@16: };
Chris@16: 
Chris@16: template<class T>
Chris@16: struct is_forward_iterator<T, false>
Chris@16: {
Chris@16:    static const bool value = false;
Chris@16: };
Chris@16: 
Chris@16: template<class T, bool = has_iterator_category<T>::value >
Chris@16: struct is_bidirectional_iterator
Chris@16: {
Chris@16:    static const bool value = is_same<typename T::iterator_category, std::bidirectional_iterator_tag>::value;
Chris@16: };
Chris@16: 
Chris@16: template<class T>
Chris@16: struct is_bidirectional_iterator<T, false>
Chris@16: {
Chris@16:    static const bool value = false;
Chris@16: };
Chris@16: 
Chris@16: template<class IIterator>
Chris@16: struct iiterator_types
Chris@16: {
Chris@16:    typedef typename IIterator::value_type                            it_value_type;
Chris@16:    typedef typename it_value_type::value_type                        value_type;
Chris@16:    typedef typename std::iterator_traits<IIterator>::pointer         it_pointer;
Chris@16:    typedef typename std::iterator_traits<IIterator>::difference_type difference_type;
Chris@16:    typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
Chris@16:       template rebind_pointer<value_type>::type                      pointer;
Chris@16:    typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
Chris@16:       template rebind_pointer<const value_type>::type                const_pointer;
Chris@16:    typedef typename ::boost::intrusive::
Chris@16:       pointer_traits<pointer>::reference                             reference;
Chris@16:    typedef typename ::boost::intrusive::
Chris@16:       pointer_traits<const_pointer>::reference                       const_reference;
Chris@16:    typedef typename IIterator::iterator_category                     iterator_category;
Chris@16: };
Chris@16: 
Chris@16: template<class IIterator, bool IsConst>
Chris@16: struct std_iterator
Chris@16: {
Chris@16:    typedef typename std::iterator
Chris@16:       < typename iiterator_types<IIterator>::iterator_category
Chris@16:       , typename iiterator_types<IIterator>::value_type
Chris@16:       , typename iiterator_types<IIterator>::difference_type
Chris@16:       , typename iiterator_types<IIterator>::const_pointer
Chris@16:       , typename iiterator_types<IIterator>::const_reference> type;
Chris@16: };
Chris@16: 
Chris@16: template<class IIterator>
Chris@16: struct std_iterator<IIterator, false>
Chris@16: {
Chris@16:    typedef typename std::iterator
Chris@16:       < typename iiterator_types<IIterator>::iterator_category
Chris@16:       , typename iiterator_types<IIterator>::value_type
Chris@16:       , typename iiterator_types<IIterator>::difference_type
Chris@16:       , typename iiterator_types<IIterator>::pointer
Chris@16:       , typename iiterator_types<IIterator>::reference> type;
Chris@16: };
Chris@16: 
Chris@16: template<class IIterator, bool IsConst>
Chris@16: class iterator
Chris@16:    :  public std_iterator<IIterator, IsConst>::type
Chris@16: {
Chris@16:    typedef typename std_iterator<IIterator, IsConst>::type types_t;
Chris@16: 
Chris@16:    public:
Chris@16:    typedef typename types_t::value_type      value_type;
Chris@16:    typedef typename types_t::pointer         pointer;
Chris@16:    typedef typename types_t::reference       reference;
Chris@16: 
Chris@16:    iterator()
Chris@16:    {}
Chris@16: 
Chris@16:    explicit iterator(IIterator iit) BOOST_CONTAINER_NOEXCEPT
Chris@16:       : m_iit(iit)
Chris@16:    {}
Chris@16: 
Chris@16:    iterator(iterator<IIterator, false> const& other) BOOST_CONTAINER_NOEXCEPT
Chris@16:       :  m_iit(other.get())
Chris@16:    {}
Chris@16: 
Chris@16:    iterator& operator++() BOOST_CONTAINER_NOEXCEPT
Chris@16:    {  ++this->m_iit;   return *this;  }
Chris@16: 
Chris@16:    iterator operator++(int) BOOST_CONTAINER_NOEXCEPT
Chris@16:    {
Chris@16:       iterator result (*this);
Chris@16:       ++this->m_iit;
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    iterator& operator--() BOOST_CONTAINER_NOEXCEPT
Chris@16:    {
Chris@16:       //If the iterator is not a bidirectional iterator, operator-- should not exist
Chris@16:       BOOST_STATIC_ASSERT((is_bidirectional_iterator<iterator>::value));
Chris@16:       --this->m_iit;   return *this;
Chris@16:    }
Chris@16: 
Chris@16:    iterator operator--(int) BOOST_CONTAINER_NOEXCEPT
Chris@16:    {
Chris@16:       iterator result (*this);
Chris@16:       --this->m_iit;
Chris@16:       return result;
Chris@16:    }
Chris@16: 
Chris@16:    friend bool operator== (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
Chris@16:    {  return l.m_iit == r.m_iit;   }
Chris@16: 
Chris@16:    friend bool operator!= (const iterator& l, const iterator& r) BOOST_CONTAINER_NOEXCEPT
Chris@16:    {  return !(l == r); }
Chris@16: 
Chris@16:    reference operator*()  const BOOST_CONTAINER_NOEXCEPT
Chris@16:    {  return (*this->m_iit).get_data();  }
Chris@16: 
Chris@16:    pointer   operator->() const BOOST_CONTAINER_NOEXCEPT
Chris@16:    {  return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*());  }
Chris@16: 
Chris@16:    const IIterator &get() const BOOST_CONTAINER_NOEXCEPT
Chris@16:    {  return this->m_iit;   }
Chris@16: 
Chris@16:    private:
Chris@16:    IIterator m_iit;
Chris@16: };
Chris@16: 
Chris@16: }  //namespace container_detail {
Chris@16: }  //namespace container {
Chris@16: }  //namespace boost {
Chris@16: 
Chris@16: #include <boost/container/detail/config_end.hpp>
Chris@16: 
Chris@16: #endif   //#ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP