// | |
// 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 |