Added boost header

test/external/boost/ptr_container/ptr_circular_buffer.hpp

@@ -0,0 +1,531 @@
+//
+// Boost.Pointer Container
+//
+//  Copyright Thorsten Ottosen 2008. 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)
+//
+// For more information, see http://www.boost.org/libs/ptr_container/
+//
+
+#ifndef BOOST_PTR_CONTAINER_PTR_CIRCULAR_BUFFER_HPP
+#define BOOST_PTR_CONTAINER_PTR_CIRCULAR_BUFFER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/circular_buffer.hpp>
+#include <boost/ptr_container/ptr_sequence_adapter.hpp>
+
+namespace boost
+{
+
+    template
+    < 
+        class T, 
+        class CloneAllocator = heap_clone_allocator,
+        class Allocator      = std::allocator<void*>
+    >
+    class ptr_circular_buffer : public 
+        ptr_sequence_adapter< T, 
+                              boost::circular_buffer<void*,Allocator>, 
+                              CloneAllocator >
+    {  
+        typedef ptr_sequence_adapter< T, 
+                                      boost::circular_buffer<void*,Allocator>, 
+                                      CloneAllocator > 
+            base_type;
+
+        typedef boost::circular_buffer<void*,Allocator>         circular_buffer_type;
+        typedef ptr_circular_buffer<T,CloneAllocator,Allocator> this_type;
+        
+    public: // typedefs
+        typedef typename base_type::value_type     value_type;
+        typedef value_type*                        pointer;
+        typedef const value_type*                  const_pointer;
+        typedef typename base_type::size_type      size_type;
+        typedef typename base_type::allocator_type allocator_type;
+        typedef typename base_type::iterator       iterator;
+        typedef typename base_type::const_iterator const_iterator;
+        typedef typename base_type::auto_type      auto_type;
+        
+        typedef std::pair<pointer,size_type>                  array_range;
+        typedef std::pair<const_pointer,size_type>            const_array_range;
+        typedef typename circular_buffer_type::capacity_type  capacity_type;
+
+    public: // constructors
+        ptr_circular_buffer()
+        { }
+
+        explicit ptr_circular_buffer( capacity_type n )
+          : base_type( n, ptr_container_detail::fixed_length_sequence_tag() )
+        { }
+        
+        ptr_circular_buffer( capacity_type n,
+                             const allocator_type& alloc )
+          : base_type( n, alloc, ptr_container_detail::fixed_length_sequence_tag() )
+        { }
+
+        template< class ForwardIterator >
+        ptr_circular_buffer( ForwardIterator first, ForwardIterator last )
+          : base_type( first, last, ptr_container_detail::fixed_length_sequence_tag() )
+        { }
+
+        template< class InputIterator >
+        ptr_circular_buffer( capacity_type n, InputIterator first, InputIterator last )
+          : base_type( n, first, last, ptr_container_detail::fixed_length_sequence_tag() )
+        { }
+
+        ptr_circular_buffer( const ptr_circular_buffer& r )
+          : base_type( r.size(), r.begin(), r.end(), 
+                       ptr_container_detail::fixed_length_sequence_tag() )
+        { }
+
+        template< class U >
+        ptr_circular_buffer( const ptr_circular_buffer<U>& r )
+          : base_type( r.size(), r.begin(), r.end(), 
+                       ptr_container_detail::fixed_length_sequence_tag() )
+        { }
+
+        ptr_circular_buffer& operator=( ptr_circular_buffer r )
+        {
+            this->swap( r );
+            return *this;
+        }
+
+        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_circular_buffer,
+                                                      base_type, this_type )
+            
+    public: // allocators
+        allocator_type& get_allocator() 
+        {
+            return this->base().get_allocator();
+        }
+
+        allocator_type get_allocator() const
+        {
+            return this->base().get_allocator();
+        }
+
+    public: // circular buffer functions
+        array_range array_one() // nothrow
+        {
+            typename circular_buffer_type::array_range r = this->base().array_one();
+            return array_range( reinterpret_cast<pointer>(r.first), r.second );
+        }
+
+        const_array_range array_one() const // nothrow
+        {
+            typename circular_buffer_type::const_array_range r = this->base().array_one();
+            return const_array_range( reinterpret_cast<const_pointer>(r.first), r.second );
+        }
+
+        array_range array_two() // nothrow
+        {
+            typename circular_buffer_type::array_range r = this->base().array_two();
+            return array_range( reinterpret_cast<pointer>(r.first), r.second );
+        }
+
+        const_array_range array_two() const // nothrow
+        {
+            typename circular_buffer_type::const_array_range r = this->base().array_two();
+            return const_array_range( reinterpret_cast<const_pointer>(r.first), r.second );
+        }
+
+        pointer linearize() // nothrow
+        {
+            return reinterpret_cast<pointer>(this->base().linearize());
+        }
+
+        bool full() const // nothrow
+        {
+            return this->base().full();
+        }
+
+        size_type reserve() const // nothrow
+        {
+            return this->base().reserve();
+        }
+
+        void reserve( size_type n ) // strong
+        {
+            if( capacity() < n )
+                set_capacity( n );
+        }
+
+        capacity_type capacity() const // nothrow
+        {
+            return this->base().capacity();
+        }
+
+        void set_capacity( capacity_type new_capacity ) // strong
+        {
+            if( this->size() > new_capacity )
+            {
+                this->erase( this->begin() + new_capacity, this->end() );
+            }
+            this->base().set_capacity( new_capacity );
+        }
+
+        void rset_capacity( capacity_type new_capacity ) // strong
+        {
+            if( this->size() > new_capacity )
+            {
+                this->erase( this->begin(), 
+                             this->begin() + (this->size()-new_capacity) );
+            }
+            this->base().rset_capacity( new_capacity );
+        }
+
+        void resize( size_type size ) // basic
+        {
+            size_type old_size = this->size();
+            if( old_size > size )
+            {
+                this->erase( boost::next( this->begin(), size ), this->end() );  
+            }
+            else if( size > old_size )
+            {
+                for( ; old_size != size; ++old_size )
+                    this->push_back( new BOOST_DEDUCED_TYPENAME 
+                                     boost::remove_pointer<value_type>::type() ); 
+            }
+
+            BOOST_ASSERT( this->size() == size );
+        }
+
+        void resize( size_type size, value_type to_clone ) // basic
+        {
+            size_type old_size = this->size();
+            if( old_size > size )
+            {
+                this->erase( boost::next( this->begin(), size ), this->end() );  
+            }
+            else if( size > old_size )
+            {
+                for( ; old_size != size; ++old_size )
+                    this->push_back( this->null_policy_allocate_clone( to_clone ) ); 
+            }
+
+            BOOST_ASSERT( this->size() == size );        
+        }
+
+        void rresize( size_type size ) // basic
+        {
+            size_type old_size = this->size();
+            if( old_size > size )
+            {
+                this->erase( this->begin(), 
+                             boost::next( this->begin(), old_size - size ) );  
+            }
+            else if( size > old_size )
+            {
+                for( ; old_size != size; ++old_size )
+                    this->push_front( new BOOST_DEDUCED_TYPENAME 
+                                      boost::remove_pointer<value_type>::type() ); 
+            }
+
+            BOOST_ASSERT( this->size() == size );
+        }
+
+        void rresize( size_type size, value_type to_clone ) // basic
+        {
+            size_type old_size = this->size();
+            if( old_size > size )
+            {
+                this->erase( this->begin(), 
+                             boost::next( this->begin(), old_size - size ) );  
+            }
+            else if( size > old_size )
+            {
+                for( ; old_size != size; ++old_size )
+                    this->push_front( this->null_policy_allocate_clone( to_clone ) ); 
+            }
+
+            BOOST_ASSERT( this->size() == size );
+        }           
+
+        template< class InputIterator >
+        void assign( InputIterator first, InputIterator last ) // strong
+        { 
+            ptr_circular_buffer temp( first, last );
+            this->swap( temp );
+        }
+
+        template< class Range >
+        void assign( const Range& r ) // strong
+        {
+            assign( boost::begin(r), boost::end(r ) );
+        }
+
+        void assign( size_type n, value_type to_clone ) // strong
+        {
+            ptr_circular_buffer temp( n );
+            for( size_type i = 0u; i != n; ++i )
+               temp.push_back( this->null_policy_allocate_clone( to_clone ) );
+            this->swap( temp ); 
+        }
+        
+        void assign( capacity_type capacity, size_type n, 
+                     value_type to_clone ) // basic
+        {
+            this->assign( (std::min)(n,capacity), to_clone );
+        }
+
+        template< class InputIterator >
+        void assign( capacity_type capacity, 
+                     InputIterator first, InputIterator last ) // basic
+        {
+            this->assign( first, last );
+            this->set_capacity( capacity );
+        }
+
+        void push_back( value_type ptr ) // nothrow
+        {
+            BOOST_ASSERT( capacity() > 0 );   
+            this->enforce_null_policy( ptr, "Null pointer in 'push_back()'" );
+         
+            auto_type old_ptr;
+            if( full() )
+                old_ptr.reset( &*this->begin() );
+            this->base().push_back( ptr );            
+        }
+
+        template< class U >
+        void push_back( std::auto_ptr<U> ptr ) // nothrow
+        {
+            push_back( ptr.release() ); 
+        }
+
+        void push_front( value_type ptr ) // nothrow
+        {
+            BOOST_ASSERT( capacity() > 0 );
+            this->enforce_null_policy( ptr, "Null pointer in 'push_front()'" );
+
+            auto_type old_ptr;
+            if( full() )
+                old_ptr.reset( &*(--this->end()) );
+            this->base().push_front( ptr );            
+        }
+
+        template< class U >
+        void push_front( std::auto_ptr<U> ptr ) // nothrow
+        {
+            push_front( ptr.release() ); 
+        }
+
+        iterator insert( iterator pos, value_type ptr ) // nothrow
+        {
+            BOOST_ASSERT( capacity() > 0 );
+            this->enforce_null_policy( ptr, "Null pointer in 'insert()'" );
+
+            auto_type new_ptr( ptr );
+            iterator b = this->begin();
+            if( full() && pos == b )
+                return b;
+            
+            auto_type old_ptr;
+            if( full() )
+                old_ptr.reset( &*this->begin() );
+
+            new_ptr.release();
+            return this->base().insert( pos.base(), ptr );
+        }
+
+        template< class U >
+        iterator insert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
+        {
+            return insert( pos, ptr.release() );
+        }
+
+        template< class InputIterator >
+        void insert( iterator pos, InputIterator first, InputIterator last ) // basic
+        {
+            for( ; first != last; ++first, ++pos )
+                pos = insert( pos, this->null_policy_allocate_clone( &*first ) );                
+        }
+
+#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#else
+        template< class Range >
+        BOOST_DEDUCED_TYPENAME
+        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
+        insert( iterator before, const Range& r )
+        {
+            insert( before, boost::begin(r), boost::end(r) );
+        }
+
+#endif
+           
+        iterator rinsert( iterator pos, value_type ptr ) // nothrow
+        {
+            BOOST_ASSERT( capacity() > 0 );
+            this->enforce_null_policy( ptr, "Null pointer in 'rinsert()'" );
+
+            auto_type new_ptr( ptr );
+            iterator b = this->end();
+            if (full() && pos == b)
+                return b;
+            
+            auto_type old_ptr;
+            if( full() )
+                old_ptr.reset( &this->back() );
+
+            new_ptr.release();
+            return this->base().rinsert( pos.base(), ptr );
+        }
+
+        template< class U >
+        iterator rinsert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
+        {
+            return rinsert( pos, ptr.release() );
+        }
+
+ 
+        template< class InputIterator >
+        void rinsert( iterator pos, InputIterator first, InputIterator last ) // basic
+        {
+            for( ; first != last; ++first, ++pos )
+                pos = rinsert( pos, this->null_policy_allocate_clone( &*first ) );                
+        }
+
+#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#else
+        template< class Range >
+        BOOST_DEDUCED_TYPENAME
+        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
+        rinsert( iterator before, const Range& r )
+        {
+            rinsert( before, boost::begin(r), boost::end(r) );
+        }
+
+#endif
+
+        iterator rerase( iterator pos ) // nothrow
+        {
+            BOOST_ASSERT( !this->empty() );
+            BOOST_ASSERT( pos != this->end() );
+
+            this->remove( pos );
+            return iterator( this->base().rerase( pos.base() ) );
+        }
+
+        iterator rerase( iterator first, iterator last ) // nothrow
+        {
+            this->remove( first, last );
+            return iterator( this->base().rerase( first.base(),
+                                                  last.base() ) );
+        }
+
+        template< class Range >
+        iterator rerase( const Range& r ) // nothrow
+        {
+            return rerase( boost::begin(r), boost::end(r) );
+        }
+
+        void rotate( const_iterator new_begin ) // nothrow
+        {
+            this->base().rotate( new_begin.base() );
+        }
+
+    public: // transfer        
+        template< class PtrSeqAdapter >
+        void transfer( iterator before, 
+                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator first, 
+                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator last, 
+                       PtrSeqAdapter& from ) // nothrow
+        {
+            BOOST_ASSERT( (void*)&from != (void*)this );
+            if( from.empty() )
+                return;
+            for( BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator begin = first; 
+                 begin != last;  ++begin, ++before )
+                before = insert( before, &*begin );          // nothrow
+            from.base().erase( first.base(), last.base() );  // nothrow
+        }
+
+        template< class PtrSeqAdapter >
+        void transfer( iterator before, 
+                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator object, 
+                       PtrSeqAdapter& from ) // nothrow
+        {
+            BOOST_ASSERT( (void*)&from != (void*)this );
+            if( from.empty() )
+                return;
+            insert( before, &*object );          // nothrow 
+            from.base().erase( object.base() );  // nothrow 
+        }
+
+#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#else
+        
+        template< class PtrSeqAdapter, class Range >
+        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
+                      BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator > >::type
+        transfer( iterator before, const Range& r, PtrSeqAdapter& from ) // nothrow
+        {
+            transfer( before, boost::begin(r), boost::end(r), from );
+        }
+
+#endif
+        template< class PtrSeqAdapter >
+        void transfer( iterator before, PtrSeqAdapter& from ) // nothrow
+        {
+            transfer( before, from.begin(), from.end(), from );            
+        }
+
+    public: // C-array support
+    
+        void transfer( iterator before, value_type* from, 
+                       size_type size, bool delete_from = true ) // nothrow 
+        {
+            BOOST_ASSERT( from != 0 );
+            if( delete_from )
+            {
+                BOOST_DEDUCED_TYPENAME base_type::scoped_deleter 
+                    deleter( from, size );                         // nothrow
+                for( size_type i = 0u; i != size; ++i, ++before )
+                    before = insert( before, *(from+i) );          // nothrow
+                deleter.release();                                 // nothrow
+            }
+            else
+            {
+                for( size_type i = 0u; i != size; ++i, ++before )
+                    before = insert( before, *(from+i) );          // nothrow
+           }
+        }
+
+        value_type* c_array() // nothrow
+        {
+            if( this->empty() )
+                return 0;
+            this->linearize();
+            T** res = reinterpret_cast<T**>( &this->begin().base()[0] );
+            return res;
+        }
+
+    };
+
+    //////////////////////////////////////////////////////////////////////////////
+    // clonability
+
+    template< typename T, typename CA, typename A >
+    inline ptr_circular_buffer<T,CA,A>* new_clone( const ptr_circular_buffer<T,CA,A>& r )
+    {
+        return r.clone().release();
+    }
+
+    /////////////////////////////////////////////////////////////////////////
+    // swap
+
+    template< typename T, typename CA, typename A >
+    inline void swap( ptr_circular_buffer<T,CA,A>& l, ptr_circular_buffer<T,CA,A>& r )
+    {
+        l.swap(r);
+    }
+    
+}
+
+#endif