boost/signals2/detail/auto_buffer.hpp
// Copyright Thorsten Ottosen, 2009.
// Distributed under 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)
#ifndef BOOST_SIGNALS2_DETAIL_AUTO_BUFFER_HPP_25_02_2009
#define BOOST_SIGNALS2_DETAIL_AUTO_BUFFER_HPP_25_02_2009
#include <boost/detail/workaround.hpp>
#if defined(_MSC_VER)
# pragma once
#endif
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <boost/core/allocator_access.hpp>
#include <boost/core/swap.hpp>
#include <boost/iterator/reverse_iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/mpl/if.hpp>
#include <boost/signals2/detail/scope_guard.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
#include <boost/type_traits/has_nothrow_assign.hpp>
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/has_trivial_constructor.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#include <algorithm>
#include <cstring>
#include <iterator>
#include <memory>
#include <stdexcept>
namespace boost
{
namespace signals2
{
namespace detail
{
//
// Policies for creating the stack buffer.
//
template< unsigned N >
struct store_n_objects
{
BOOST_STATIC_CONSTANT( unsigned, value = N );
};
template< unsigned N >
struct store_n_bytes
{
BOOST_STATIC_CONSTANT( unsigned, value = N );
};
namespace auto_buffer_detail
{
template< class Policy, class T >
struct compute_buffer_size
{
BOOST_STATIC_CONSTANT( unsigned, value = Policy::value * sizeof(T) );
};
template< unsigned N, class T >
struct compute_buffer_size< store_n_bytes<N>, T >
{
BOOST_STATIC_CONSTANT( unsigned, value = N );
};
template< class Policy, class T >
struct compute_buffer_objects
{
BOOST_STATIC_CONSTANT( unsigned, value = Policy::value );
};
template< unsigned N, class T >
struct compute_buffer_objects< store_n_bytes<N>, T >
{
BOOST_STATIC_CONSTANT( unsigned, value = N / sizeof(T) );
};
}
struct default_grow_policy
{
template< class SizeType >
static SizeType new_capacity( SizeType capacity )
{
//
// @remark: we grow the capacity quite agressively.
// this is justified since we aim to minimize
// heap-allocations, and because we mostly use
// the buffer locally.
return capacity * 4u;
}
template< class SizeType >
static bool should_shrink( SizeType, SizeType )
{
//
// @remark: when defining a new grow policy, one might
// choose that if the waated space is less
// than a certain percentage, then it is of
// little use to shrink.
//
return true;
}
};
template< class T,
class StackBufferPolicy = store_n_objects<256>,
class GrowPolicy = default_grow_policy,
class Allocator = std::allocator<T> >
class auto_buffer;
template
<
class T,
class StackBufferPolicy,
class GrowPolicy,
class Allocator
>
class auto_buffer : Allocator
{
private:
enum { N = auto_buffer_detail::
compute_buffer_objects<StackBufferPolicy,T>::value };
BOOST_STATIC_CONSTANT( bool, is_stack_buffer_empty = N == 0u );
typedef auto_buffer<T, store_n_objects<0>, GrowPolicy, Allocator>
local_buffer;
public:
typedef Allocator allocator_type;
typedef T value_type;
typedef typename boost::allocator_size_type<Allocator>::type size_type;
typedef typename boost::allocator_difference_type<Allocator>::type difference_type;
typedef T* pointer;
typedef typename boost::allocator_pointer<Allocator>::type allocator_pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef pointer iterator;
typedef const_pointer const_iterator;
typedef boost::reverse_iterator<iterator> reverse_iterator;
typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
typedef typename boost::mpl::if_c< boost::has_trivial_assign<T>::value
&& sizeof(T) <= sizeof(long double),
const value_type,
const_reference >::type
optimized_const_reference;
private:
pointer allocate( size_type capacity_arg )
{
if( capacity_arg > N )
return &*get_allocator().allocate( capacity_arg );
else
return static_cast<T*>( members_.address() );
}
void deallocate( pointer where, size_type capacity_arg )
{
if( capacity_arg <= N )
return;
get_allocator().deallocate( allocator_pointer(where), capacity_arg );
}
template< class I >
static void copy_impl( I begin, I end, pointer where, std::random_access_iterator_tag )
{
copy_rai( begin, end, where, boost::has_trivial_assign<T>() );
}
static void copy_rai( const T* begin, const T* end,
pointer where, const boost::true_type& )
{
std::memcpy( where, begin, sizeof(T) * std::distance(begin,end) );
}
template< class I, bool b >
static void copy_rai( I begin, I end,
pointer where, const boost::integral_constant<bool, b>& )
{
std::uninitialized_copy( begin, end, where );
}
template< class I >
static void copy_impl( I begin, I end, pointer where, std::bidirectional_iterator_tag )
{
std::uninitialized_copy( begin, end, where );
}
template< class I >
static void copy_impl( I begin, I end, pointer where )
{
copy_impl( begin, end, where,
typename std::iterator_traits<I>::iterator_category() );
}
template< class I, class I2 >
static void assign_impl( I begin, I end, I2 where )
{
assign_impl( begin, end, where, boost::has_trivial_assign<T>() );
}
template< class I, class I2 >
static void assign_impl( I begin, I end, I2 where, const boost::true_type& )
{
std::memcpy( where, begin, sizeof(T) * std::distance(begin,end) );
}
template< class I, class I2 >
static void assign_impl( I begin, I end, I2 where, const boost::false_type& )
{
for( ; begin != end; ++begin, ++where )
*where = *begin;
}
void unchecked_push_back_n( size_type n, const boost::true_type& )
{
std::uninitialized_fill( end(), end() + n, T() );
size_ += n;
}
void unchecked_push_back_n( size_type n, const boost::false_type& )
{
for( size_type i = 0u; i < n; ++i )
unchecked_push_back();
}
void auto_buffer_destroy( pointer where, const boost::false_type& )
{
(*where).~T();
}
void auto_buffer_destroy( pointer, const boost::true_type& )
{ }
void auto_buffer_destroy( pointer where )
{
auto_buffer_destroy( where, boost::has_trivial_destructor<T>() );
}
void auto_buffer_destroy()
{
BOOST_ASSERT( is_valid() );
if( buffer_ ) // do we need this check? Yes, but only
// for N = 0u + local instances in one_sided_swap()
auto_buffer_destroy( boost::has_trivial_destructor<T>() );
}
void destroy_back_n( size_type n, const boost::false_type& )
{
BOOST_ASSERT( n > 0 );
pointer buffer = buffer_ + size_ - 1u;
pointer new_end = buffer - n;
for( ; buffer > new_end; --buffer )
auto_buffer_destroy( buffer );
}
void destroy_back_n( size_type, const boost::true_type& )
{ }
void destroy_back_n( size_type n )
{
destroy_back_n( n, boost::has_trivial_destructor<T>() );
}
void auto_buffer_destroy( const boost::false_type& x )
{
if( size_ )
destroy_back_n( size_, x );
deallocate( buffer_, members_.capacity_ );
}
void auto_buffer_destroy( const boost::true_type& )
{
deallocate( buffer_, members_.capacity_ );
}
pointer move_to_new_buffer( size_type new_capacity, const boost::false_type& )
{
pointer new_buffer = allocate( new_capacity ); // strong
scope_guard guard = make_obj_guard( *this,
&auto_buffer::deallocate,
new_buffer,
new_capacity );
copy_impl( begin(), end(), new_buffer ); // strong
guard.dismiss(); // nothrow
return new_buffer;
}
pointer move_to_new_buffer( size_type new_capacity, const boost::true_type& )
{
pointer new_buffer = allocate( new_capacity ); // strong
copy_impl( begin(), end(), new_buffer ); // nothrow
return new_buffer;
}
void reserve_impl( size_type new_capacity )
{
pointer new_buffer = move_to_new_buffer( new_capacity,
boost::has_nothrow_copy<T>() );
auto_buffer_destroy();
buffer_ = new_buffer;
members_.capacity_ = new_capacity;
BOOST_ASSERT( size_ <= members_.capacity_ );
}
size_type new_capacity_impl( size_type n )
{
BOOST_ASSERT( n > members_.capacity_ );
size_type new_capacity = GrowPolicy::new_capacity( members_.capacity_ );
// @todo: consider to check for allocator.max_size()
return (std::max)(new_capacity,n);
}
static void swap_helper( auto_buffer& l, auto_buffer& r,
const boost::true_type& )
{
BOOST_ASSERT( l.is_on_stack() && r.is_on_stack() );
auto_buffer temp( l.begin(), l.end() );
assign_impl( r.begin(), r.end(), l.begin() );
assign_impl( temp.begin(), temp.end(), r.begin() );
boost::swap( l.size_, r.size_ );
boost::swap( l.members_.capacity_, r.members_.capacity_ );
}
static void swap_helper( auto_buffer& l, auto_buffer& r,
const boost::false_type& )
{
BOOST_ASSERT( l.is_on_stack() && r.is_on_stack() );
size_type min_size = (std::min)(l.size_,r.size_);
size_type max_size = (std::max)(l.size_,r.size_);
size_type diff = max_size - min_size;
auto_buffer* smallest = l.size_ == min_size ? &l : &r;
auto_buffer* largest = smallest == &l ? &r : &l;
// @remark: the implementation below is not as fast
// as it could be if we assumed T had a default
// constructor.
size_type i = 0u;
for( ; i < min_size; ++i )
boost::swap( (*smallest)[i], (*largest)[i] );
for( ; i < max_size; ++i )
smallest->unchecked_push_back( (*largest)[i] );
largest->pop_back_n( diff );
boost::swap( l.members_.capacity_, r.members_.capacity_ );
}
void one_sided_swap( auto_buffer& temp ) // nothrow
{
BOOST_ASSERT( !temp.is_on_stack() );
auto_buffer_destroy();
// @remark: must be nothrow
get_allocator() = temp.get_allocator();
members_.capacity_ = temp.members_.capacity_;
buffer_ = temp.buffer_;
BOOST_ASSERT( temp.size_ >= size_ + 1u );
size_ = temp.size_;
temp.buffer_ = 0;
BOOST_ASSERT( temp.is_valid() );
}
template< class I >
void insert_impl( const_iterator before, I begin_arg, I end_arg,
std::input_iterator_tag )
{
for( ; begin_arg != end_arg; ++begin_arg )
{
before = insert( before, *begin_arg );
++before;
}
}
void grow_back( size_type n, const boost::true_type& )
{
BOOST_ASSERT( size_ + n <= members_.capacity_ );
size_ += n;
}
void grow_back( size_type n, const boost::false_type& )
{
unchecked_push_back_n(n);
}
void grow_back( size_type n )
{
grow_back( n, boost::has_trivial_constructor<T>() );
}
void grow_back_one( const boost::true_type& )
{
BOOST_ASSERT( size_ + 1 <= members_.capacity_ );
size_ += 1;
}
void grow_back_one( const boost::false_type& )
{
unchecked_push_back();
}
void grow_back_one()
{
grow_back_one( boost::has_trivial_constructor<T>() );
}
template< class I >
void insert_impl( const_iterator before, I begin_arg, I end_arg,
std::forward_iterator_tag )
{
difference_type n = std::distance(begin_arg, end_arg);
if( size_ + n <= members_.capacity_ )
{
bool is_back_insertion = before == cend();
if( !is_back_insertion )
{
grow_back( n );
iterator where = const_cast<T*>(before);
std::copy( before, cend() - n, where + n );
assign_impl( begin_arg, end_arg, where );
}
else
{
unchecked_push_back( begin_arg, end_arg );
}
BOOST_ASSERT( is_valid() );
return;
}
auto_buffer temp( new_capacity_impl( size_ + n ) );
temp.unchecked_push_back( cbegin(), before );
temp.unchecked_push_back( begin_arg, end_arg );
temp.unchecked_push_back( before, cend() );
one_sided_swap( temp );
BOOST_ASSERT( is_valid() );
}
public:
bool is_valid() const // invariant
{
// @remark: allowed for N==0 and when
// using a locally instance
// in insert()/one_sided_swap()
if( buffer_ == 0 )
return true;
if( members_.capacity_ < N )
return false;
if( !is_on_stack() && members_.capacity_ <= N )
return false;
if( buffer_ == members_.address() )
if( members_.capacity_ > N )
return false;
if( size_ > members_.capacity_ )
return false;
return true;
}
auto_buffer()
: members_( N ),
buffer_( static_cast<T*>(members_.address()) ),
size_( 0u )
{
BOOST_ASSERT( is_valid() );
}
auto_buffer( const auto_buffer& r )
: members_( (std::max)(r.size_,size_type(N)) ),
buffer_( allocate( members_.capacity_ ) ),
size_( 0 )
{
copy_impl( r.begin(), r.end(), buffer_ );
size_ = r.size_;
BOOST_ASSERT( is_valid() );
}
auto_buffer& operator=( const auto_buffer& r ) // basic
{
if( this == &r )
return *this;
difference_type diff = size_ - r.size_;
if( diff >= 0 )
{
pop_back_n( static_cast<size_type>(diff) );
assign_impl( r.begin(), r.end(), begin() );
}
else
{
if( members_.capacity_ >= r.size() )
{
unchecked_push_back_n( static_cast<size_type>(-diff) );
assign_impl( r.begin(), r.end(), begin() );
}
else
{
// @remark: we release memory as early as possible
// since we only give the basic guarantee
auto_buffer_destroy();
buffer_ = 0;
pointer new_buffer = allocate( r.size() );
scope_guard guard = make_obj_guard( *this,
&auto_buffer::deallocate,
new_buffer,
r.size() );
copy_impl( r.begin(), r.end(), new_buffer );
guard.dismiss();
buffer_ = new_buffer;
members_.capacity_ = r.size();
size_ = members_.capacity_;
}
}
BOOST_ASSERT( size() == r.size() );
BOOST_ASSERT( is_valid() );
return *this;
}
explicit auto_buffer( size_type capacity_arg )
: members_( (std::max)(capacity_arg, size_type(N)) ),
buffer_( allocate(members_.capacity_) ),
size_( 0 )
{
BOOST_ASSERT( is_valid() );
}
auto_buffer( size_type size_arg, optimized_const_reference init_value )
: members_( (std::max)(size_arg, size_type(N)) ),
buffer_( allocate(members_.capacity_) ),
size_( 0 )
{
std::uninitialized_fill( buffer_, buffer_ + size_arg, init_value );
size_ = size_arg;
BOOST_ASSERT( is_valid() );
}
auto_buffer( size_type capacity_arg, const allocator_type& a )
: allocator_type( a ),
members_( (std::max)(capacity_arg, size_type(N)) ),
buffer_( allocate(members_.capacity_) ),
size_( 0 )
{
BOOST_ASSERT( is_valid() );
}
auto_buffer( size_type size_arg, optimized_const_reference init_value,
const allocator_type& a )
: allocator_type( a ),
members_( (std::max)(size_arg, size_type(N)) ),
buffer_( allocate(members_.capacity_) ),
size_( 0 )
{
std::uninitialized_fill( buffer_, buffer_ + size_arg, init_value );
size_ = size_arg;
BOOST_ASSERT( is_valid() );
}
template< class ForwardIterator >
auto_buffer( ForwardIterator begin_arg, ForwardIterator end_arg )
:
members_( std::distance(begin_arg, end_arg) ),
buffer_( allocate(members_.capacity_) ),
size_( 0 )
{
copy_impl( begin_arg, end_arg, buffer_ );
size_ = members_.capacity_;
if( members_.capacity_ < N )
members_.capacity_ = N;
BOOST_ASSERT( is_valid() );
}
template< class ForwardIterator >
auto_buffer( ForwardIterator begin_arg, ForwardIterator end_arg,
const allocator_type& a )
: allocator_type( a ),
members_( std::distance(begin_arg, end_arg) ),
buffer_( allocate(members_.capacity_) ),
size_( 0 )
{
copy_impl( begin_arg, end_arg, buffer_ );
size_ = members_.capacity_;
if( members_.capacity_ < N )
members_.capacity_ = N;
BOOST_ASSERT( is_valid() );
}
~auto_buffer()
{
auto_buffer_destroy();
}
public:
bool empty() const
{
return size_ == 0;
}
bool full() const
{
return size_ == members_.capacity_;
}
bool is_on_stack() const
{
return members_.capacity_ <= N;
}
size_type size() const
{
return size_;
}
size_type capacity() const
{
return members_.capacity_;
}
public:
pointer data()
{
return buffer_;
}
const_pointer data() const
{
return buffer_;
}
allocator_type& get_allocator()
{
return static_cast<allocator_type&>(*this);
}
const allocator_type& get_allocator() const
{
return static_cast<const allocator_type&>(*this);
}
public:
iterator begin()
{
return buffer_;
}
const_iterator begin() const
{
return buffer_;
}
iterator end()
{
return buffer_ + size_;
}
const_iterator end() const
{
return buffer_ + size_;
}
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(end());
}
reverse_iterator rend()
{
return reverse_iterator(begin());
}
const_reverse_iterator rend() const
{
return const_reverse_iterator(begin());
}
const_iterator cbegin() const
{
return const_cast<const auto_buffer*>(this)->begin();
}
const_iterator cend() const
{
return const_cast<const auto_buffer*>(this)->end();
}
const_reverse_iterator crbegin() const
{
return const_cast<const auto_buffer*>(this)->rbegin();
}
const_reverse_iterator crend() const
{
return const_cast<const auto_buffer*>(this)->rend();
}
public:
reference front()
{
return buffer_[0];
}
optimized_const_reference front() const
{
return buffer_[0];
}
reference back()
{
return buffer_[size_-1];
}
optimized_const_reference back() const
{
return buffer_[size_-1];
}
reference operator[]( size_type n )
{
BOOST_ASSERT( n < size_ );
return buffer_[n];
}
optimized_const_reference operator[]( size_type n ) const
{
BOOST_ASSERT( n < size_ );
return buffer_[n];
}
void unchecked_push_back()
{
BOOST_ASSERT( !full() );
new (buffer_ + size_) T;
++size_;
}
void unchecked_push_back_n( size_type n )
{
BOOST_ASSERT( size_ + n <= members_.capacity_ );
unchecked_push_back_n( n, boost::has_trivial_assign<T>() );
}
void unchecked_push_back( optimized_const_reference x ) // non-growing
{
BOOST_ASSERT( !full() );
new (buffer_ + size_) T( x );
++size_;
}
template< class ForwardIterator >
void unchecked_push_back( ForwardIterator begin_arg,
ForwardIterator end_arg ) // non-growing
{
BOOST_ASSERT( size_ + std::distance(begin_arg, end_arg) <= members_.capacity_ );
copy_impl( begin_arg, end_arg, buffer_ + size_ );
size_ += std::distance(begin_arg, end_arg);
}
void reserve_precisely( size_type n )
{
BOOST_ASSERT( members_.capacity_ >= N );
if( n <= members_.capacity_ )
return;
reserve_impl( n );
BOOST_ASSERT( members_.capacity_ == n );
}
void reserve( size_type n ) // strong
{
BOOST_ASSERT( members_.capacity_ >= N );
if( n <= members_.capacity_ )
return;
reserve_impl( new_capacity_impl( n ) );
BOOST_ASSERT( members_.capacity_ >= n );
}
void push_back()
{
if( size_ != members_.capacity_ )
{
unchecked_push_back();
}
else
{
reserve( size_ + 1u );
unchecked_push_back();
}
}
void push_back( optimized_const_reference x )
{
if( size_ != members_.capacity_ )
{
unchecked_push_back( x );
}
else
{
reserve( size_ + 1u );
unchecked_push_back( x );
}
}
template< class ForwardIterator >
void push_back( ForwardIterator begin_arg, ForwardIterator end_arg )
{
difference_type diff = std::distance(begin_arg, end_arg);
if( size_ + diff > members_.capacity_ )
reserve( size_ + diff );
unchecked_push_back( begin_arg, end_arg );
}
iterator insert( const_iterator before, optimized_const_reference x ) // basic
{
// @todo: consider if we want to support x in 'this'
if( size_ < members_.capacity_ )
{
bool is_back_insertion = before == cend();
iterator where = const_cast<T*>(before);
if( !is_back_insertion )
{
grow_back_one();
std::copy( before, cend() - 1u, where + 1u );
*where = x;
BOOST_ASSERT( is_valid() );
}
else
{
unchecked_push_back( x );
}
return where;
}
auto_buffer temp( new_capacity_impl( size_ + 1u ) );
temp.unchecked_push_back( cbegin(), before );
iterator result = temp.end();
temp.unchecked_push_back( x );
temp.unchecked_push_back( before, cend() );
one_sided_swap( temp );
BOOST_ASSERT( is_valid() );
return result;
}
void insert( const_iterator before, size_type n,
optimized_const_reference x )
{
// @todo: see problems above
if( size_ + n <= members_.capacity_ )
{
grow_back( n );
iterator where = const_cast<T*>(before);
std::copy( before, cend() - n, where + n );
std::fill( where, where + n, x );
BOOST_ASSERT( is_valid() );
return;
}
auto_buffer temp( new_capacity_impl( size_ + n ) );
temp.unchecked_push_back( cbegin(), before );
std::uninitialized_fill_n( temp.end(), n, x );
temp.size_ += n;
temp.unchecked_push_back( before, cend() );
one_sided_swap( temp );
BOOST_ASSERT( is_valid() );
}
template< class ForwardIterator >
void insert( const_iterator before,
ForwardIterator begin_arg, ForwardIterator end_arg ) // basic
{
typedef typename std::iterator_traits<ForwardIterator>
::iterator_category category;
insert_impl( before, begin_arg, end_arg, category() );
}
void pop_back()
{
BOOST_ASSERT( !empty() );
auto_buffer_destroy( buffer_ + size_ - 1, boost::has_trivial_destructor<T>() );
--size_;
}
void pop_back_n( size_type n )
{
BOOST_ASSERT( n <= size_ );
if( n )
{
destroy_back_n( n );
size_ -= n;
}
}
void clear()
{
pop_back_n( size_ );
}
iterator erase( const_iterator where )
{
BOOST_ASSERT( !empty() );
BOOST_ASSERT( cbegin() <= where );
BOOST_ASSERT( cend() > where );
unsigned elements = cend() - where - 1u;
if( elements > 0u )
{
const_iterator start = where + 1u;
std::copy( start, start + elements,
const_cast<T*>(where) );
}
pop_back();
BOOST_ASSERT( !full() );
iterator result = const_cast<T*>( where );
BOOST_ASSERT( result <= end() );
return result;
}
iterator erase( const_iterator from, const_iterator to )
{
BOOST_ASSERT( !(std::distance(from,to)>0) ||
!empty() );
BOOST_ASSERT( cbegin() <= from );
BOOST_ASSERT( cend() >= to );
unsigned elements = std::distance(to,cend());
if( elements > 0u )
{
BOOST_ASSERT( elements > 0u );
std::copy( to, to + elements,
const_cast<T*>(from) );
}
pop_back_n( std::distance(from,to) );
BOOST_ASSERT( !full() );
iterator result = const_cast<T*>( from );
BOOST_ASSERT( result <= end() );
return result;
}
void shrink_to_fit()
{
if( is_on_stack() || !GrowPolicy::should_shrink(size_,members_.capacity_) )
return;
reserve_impl( size_ );
members_.capacity_ = (std::max)(size_type(N),members_.capacity_);
BOOST_ASSERT( is_on_stack() || size_ == members_.capacity_ );
BOOST_ASSERT( !is_on_stack() || size_ <= members_.capacity_ );
}
pointer uninitialized_grow( size_type n ) // strong
{
if( size_ + n > members_.capacity_ )
reserve( size_ + n );
pointer res = end();
size_ += n;
return res;
}
void uninitialized_shrink( size_type n ) // nothrow
{
// @remark: test for wrap-around
BOOST_ASSERT( size_ - n <= members_.capacity_ );
size_ -= n;
}
void uninitialized_resize( size_type n )
{
if( n > size() )
uninitialized_grow( n - size() );
else if( n < size() )
uninitialized_shrink( size() - n );
BOOST_ASSERT( size() == n );
}
// nothrow - if both buffer are on the heap, or
// - if one buffer is on the heap and one has
// 'has_allocated_buffer() == false', or
// - if copy-construction cannot throw
// basic - otherwise (better guarantee impossible)
// requirement: the allocator must be no-throw-swappable
void swap( auto_buffer& r )
{
bool on_stack = is_on_stack();
bool r_on_stack = r.is_on_stack();
bool both_on_heap = !on_stack && !r_on_stack;
if( both_on_heap )
{
boost::swap( get_allocator(), r.get_allocator() );
boost::swap( members_.capacity_, r.members_.capacity_ );
boost::swap( buffer_, r.buffer_ );
boost::swap( size_, r.size_ );
BOOST_ASSERT( is_valid() );
BOOST_ASSERT( r.is_valid() );
return;
}
BOOST_ASSERT( on_stack || r_on_stack );
bool exactly_one_on_stack = (on_stack && !r_on_stack) ||
(!on_stack && r_on_stack);
//
// Remark: we now know that we can copy into
// the unused stack buffer.
//
if( exactly_one_on_stack )
{
auto_buffer* one_on_stack = on_stack ? this : &r;
auto_buffer* other = on_stack ? &r : this;
pointer new_buffer = static_cast<T*>(other->members_.address());
copy_impl( one_on_stack->begin(), one_on_stack->end(),
new_buffer ); // strong
one_on_stack->auto_buffer_destroy(); // nothrow
boost::swap( get_allocator(), r.get_allocator() ); // assume nothrow
boost::swap( members_.capacity_, r.members_.capacity_ );
boost::swap( size_, r.size_ );
one_on_stack->buffer_ = other->buffer_;
other->buffer_ = new_buffer;
BOOST_ASSERT( other->is_on_stack() );
BOOST_ASSERT( !one_on_stack->is_on_stack() );
BOOST_ASSERT( is_valid() );
BOOST_ASSERT( r.is_valid() );
return;
}
BOOST_ASSERT( on_stack && r_on_stack );
swap_helper( *this, r, boost::has_trivial_assign<T>() );
BOOST_ASSERT( is_valid() );
BOOST_ASSERT( r.is_valid() );
}
private:
typedef boost::aligned_storage< N * sizeof(T),
boost::alignment_of<T>::value >
storage;
struct members_type : storage /* to enable EBO */
{
size_type capacity_;
members_type( size_type capacity )
: capacity_(capacity)
{ }
void* address() const
{ return const_cast<storage&>(static_cast<const storage&>(*this)).address(); }
};
members_type members_;
pointer buffer_;
size_type size_;
};
template< class T, class SBP, class GP, class A >
inline void swap( auto_buffer<T,SBP,GP,A>& l, auto_buffer<T,SBP,GP,A>& r )
{
l.swap( r );
}
template< class T, class SBP, class GP, class A >
inline bool operator==( const auto_buffer<T,SBP,GP,A>& l,
const auto_buffer<T,SBP,GP,A>& r )
{
if( l.size() != r.size() )
return false;
return std::equal( l.begin(), l.end(), r.begin() );
}
template< class T, class SBP, class GP, class A >
inline bool operator!=( const auto_buffer<T,SBP,GP,A>& l,
const auto_buffer<T,SBP,GP,A>& r )
{
return !(l == r);
}
template< class T, class SBP, class GP, class A >
inline bool operator<( const auto_buffer<T,SBP,GP,A>& l,
const auto_buffer<T,SBP,GP,A>& r )
{
return std::lexicographical_compare( l.begin(), l.end(),
r.begin(), r.end() );
}
template< class T, class SBP, class GP, class A >
inline bool operator>( const auto_buffer<T,SBP,GP,A>& l,
const auto_buffer<T,SBP,GP,A>& r )
{
return (r < l);
}
template< class T, class SBP, class GP, class A >
inline bool operator<=( const auto_buffer<T,SBP,GP,A>& l,
const auto_buffer<T,SBP,GP,A>& r )
{
return !(l > r);
}
template< class T, class SBP, class GP, class A >
inline bool operator>=( const auto_buffer<T,SBP,GP,A>& l,
const auto_buffer<T,SBP,GP,A>& r )
{
return !(l < r);
}
} // namespace detail
} // namespace signals2
}
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
#pragma warning(pop)
#endif
#endif