Space optimized circular buffer container adaptor. More...

#include <space_optimized.hpp>

Inheritance diagram for boost::circular_buffer_space_optimized< T, Alloc >:

Collaboration diagram for boost::circular_buffer_space_optimized< T, Alloc >:

Public Types
typedef circular_buffer< T, Alloc >::value_type	value_type

typedef circular_buffer< T, Alloc >::pointer	pointer

typedef circular_buffer< T, Alloc >::const_pointer	const_pointer

typedef circular_buffer< T, Alloc >::reference	reference

typedef circular_buffer< T, Alloc >::const_reference	const_reference

typedef circular_buffer< T, Alloc >::size_type	size_type

typedef circular_buffer< T, Alloc >::difference_type	difference_type

typedef circular_buffer< T, Alloc >::allocator_type	allocator_type

typedef circular_buffer< T, Alloc >::const_iterator	const_iterator

typedef circular_buffer< T, Alloc >::iterator	iterator

typedef circular_buffer< T, Alloc > ::const_reverse_iterator	const_reverse_iterator

typedef circular_buffer< T, Alloc >::reverse_iterator	reverse_iterator

typedef circular_buffer< T, Alloc >::array_range	array_range

typedef circular_buffer< T, Alloc >::const_array_range	const_array_range

typedef circular_buffer< T, Alloc >::param_value_type	param_value_type

typedef circular_buffer< T, Alloc >::rvalue_type	rvalue_type

typedef cb_details::capacity_control < size_type >	capacity_type
	Capacity controller of the space optimized circular buffer. More...

Public Member Functions
bool	full () const BOOST_NOEXCEPT
	Is the `circular_buffer_space_optimized` full? More...

size_type	reserve () const BOOST_NOEXCEPT
	Get the maximum number of elements which can be inserted into the `circular_buffer_space_optimized` without overwriting any of already stored elements. More...

const capacity_type &	capacity () const BOOST_NOEXCEPT
	Get the capacity of the `circular_buffer_space_optimized`. More...

void	set_capacity (const capacity_type &capacity_ctrl)
	Change the capacity (and the minimal guaranteed amount of allocated memory) of the `circular_buffer_space_optimized`. More...

void	resize (size_type new_size, param_value_type item=value_type())
	Change the size of the `circular_buffer_space_optimized`. More...

void	rset_capacity (const capacity_type &capacity_ctrl)
	Change the capacity (and the minimal guaranteed amount of allocated memory) of the `circular_buffer_space_optimized`. More...

void	rresize (size_type new_size, param_value_type item=value_type())
	Change the size of the `circular_buffer_space_optimized`. More...

	circular_buffer_space_optimized (const allocator_type &alloc=allocator_type()) BOOST_NOEXCEPT
	Create an empty space optimized circular buffer with zero capacity. More...

	circular_buffer_space_optimized (capacity_type capacity_ctrl, const allocator_type &alloc=allocator_type())
	Create an empty space optimized circular buffer with the specified capacity. More...

	circular_buffer_space_optimized (capacity_type capacity_ctrl, param_value_type item, const allocator_type &alloc=allocator_type())
	Create a full space optimized circular buffer with the specified capacity filled with `capacity_ctrl.` More...

	circular_buffer_space_optimized (capacity_type capacity_ctrl, size_type n, param_value_type item, const allocator_type &alloc=allocator_type())
	Create a space optimized circular buffer with the specified capacity filled with `n` copies of `item`. More...

	circular_buffer_space_optimized (const circular_buffer_space_optimized< T, Alloc > &cb)
	The copy constructor. More...

	circular_buffer_space_optimized (circular_buffer_space_optimized< T, Alloc > &&cb) BOOST_NOEXCEPT
	The move constructor. More...

template<class InputIterator >
	circular_buffer_space_optimized (InputIterator first, InputIterator last, const allocator_type &alloc=allocator_type())
	Create a full space optimized circular buffer filled with a copy of the range. More...

template<class InputIterator >
	circular_buffer_space_optimized (capacity_type capacity_ctrl, InputIterator first, InputIterator last, const allocator_type &alloc=allocator_type())
	Create a space optimized circular buffer with the specified capacity (and the minimal guaranteed amount of allocated memory) filled with a copy of the range. More...

circular_buffer_space_optimized < T, Alloc > &	operator= (const circular_buffer_space_optimized< T, Alloc > &cb)
	The assign operator. More...

circular_buffer_space_optimized < T, Alloc > &	operator= (circular_buffer_space_optimized< T, Alloc > &&cb) BOOST_NOEXCEPT
	Move assigns content of `cb` to `*this`, leaving `cb` empty. More...

void	assign (size_type n, param_value_type item)
	Assign `n` items into the space optimized circular buffer. More...

void	assign (capacity_type capacity_ctrl, size_type n, param_value_type item)
	Assign `n` items into the space optimized circular buffer specifying the capacity. More...

template<class InputIterator >
void	assign (InputIterator first, InputIterator last)
	Assign a copy of the range into the space optimized circular buffer. More...

template<class InputIterator >
void	assign (capacity_type capacity_ctrl, InputIterator first, InputIterator last)
	Assign a copy of the range into the space optimized circular buffer specifying the capacity. More...

void	swap (circular_buffer_space_optimized< T, Alloc > &cb) BOOST_NOEXCEPT
	Swap the contents of two space-optimized circular-buffers. More...

void	push_back (param_value_type item)
	Insert a new element at the end of the space optimized circular buffer. More...

void	push_back (rvalue_type item)
	Insert a new element at the end of the space optimized circular buffer. More...

void	push_back ()
	Insert a new element at the end of the space optimized circular buffer. More...

void	push_front (param_value_type item)
	Insert a new element at the beginning of the space optimized circular buffer. More...

void	push_front (rvalue_type item)
	Insert a new element at the beginning of the space optimized circular buffer. More...

void	push_front ()
	Insert a new element at the beginning of the space optimized circular buffer. More...

void	pop_back ()
	Remove the last element from the space optimized circular buffer. More...

void	pop_front ()
	Remove the first element from the space optimized circular buffer. More...

iterator	insert (iterator pos, param_value_type item)
	Insert an element at the specified position. More...

iterator	insert (iterator pos, rvalue_type item)
	Insert an element at the specified position. More...

iterator	insert (iterator pos)
	Insert an element at the specified position. More...

void	insert (iterator pos, size_type n, param_value_type item)
	Insert `n` copies of the `item` at the specified position. More...

template<class InputIterator >
void	insert (iterator pos, InputIterator first, InputIterator last)
	Insert the range `[first, last)` at the specified position. More...

iterator	rinsert (iterator pos, param_value_type item)
	Insert an element before the specified position. More...

iterator	rinsert (iterator pos, rvalue_type item)
	Insert an element before the specified position. More...

iterator	rinsert (iterator pos)
	Insert an element before the specified position. More...

void	rinsert (iterator pos, size_type n, param_value_type item)
	Insert `n` copies of the `item` before the specified position. More...

template<class InputIterator >
void	rinsert (iterator pos, InputIterator first, InputIterator last)
	Insert the range `[first, last)` before the specified position. More...

iterator	erase (iterator pos)
	Remove an element at the specified position. More...

iterator	erase (iterator first, iterator last)
	Erase the range `[first, last)`. More...

iterator	rerase (iterator pos)
	Remove an element at the specified position. More...

iterator	rerase (iterator first, iterator last)
	Erase the range `[first, last)`. More...

void	clear ()
	Remove all stored elements from the space optimized circular buffer. More...

Private Types
typedef circular_buffer< T, Alloc >	this_type
	The type of this `circular_buffer`. More...

Private Member Functions
typedef	BOOST_RV_REF (value_type) rvalue_type
	A type representing rvalue from param type. More...

allocator_type	get_allocator () const BOOST_NOEXCEPT
	Get the allocator. More...

allocator_type &	get_allocator () BOOST_NOEXCEPT
	Get the allocator reference. More...

iterator	begin () BOOST_NOEXCEPT
	Get the iterator pointing to the beginning of the `circular_buffer`. More...

const_iterator	begin () const BOOST_NOEXCEPT
	Get the const iterator pointing to the beginning of the `circular_buffer`. More...

iterator	end () BOOST_NOEXCEPT
	Get the iterator pointing to the end of the `circular_buffer`. More...

const_iterator	end () const BOOST_NOEXCEPT
	Get the const iterator pointing to the end of the `circular_buffer`. More...

reverse_iterator	rbegin () BOOST_NOEXCEPT
	Get the iterator pointing to the beginning of the "reversed" `circular_buffer`. More...

const_reverse_iterator	rbegin () const BOOST_NOEXCEPT
	Get the const iterator pointing to the beginning of the "reversed" `circular_buffer`. More...

reverse_iterator	rend () BOOST_NOEXCEPT
	Get the iterator pointing to the end of the "reversed" `circular_buffer`. More...

const_reverse_iterator	rend () const BOOST_NOEXCEPT
	Get the const iterator pointing to the end of the "reversed" `circular_buffer`. More...

reference	operator[] (size_type index)
	Get the element at the `index` position. More...

const_reference	operator[] (size_type index) const
	Get the element at the `index` position. More...

reference	at (size_type index)
	Get the element at the `index` position. More...

const_reference	at (size_type index) const
	Get the element at the `index` position. More...

reference	front ()
	Get the first element. More...

const_reference	front () const
	Get the first element. More...

reference	back ()
	Get the last element. More...

const_reference	back () const
	Get the last element. More...

array_range	array_one ()
	Get the first continuous array of the internal buffer. More...

const_array_range	array_one () const
	Get the first continuous array of the internal buffer. More...

array_range	array_two ()
	Get the second continuous array of the internal buffer. More...

const_array_range	array_two () const
	Get the second continuous array of the internal buffer. More...

pointer	linearize ()
	Linearize the internal buffer into a continuous array. More...

bool	is_linearized () const BOOST_NOEXCEPT
	Is the `circular_buffer` linearized? More...

void	rotate (const_iterator new_begin)
	Rotate elements in the `circular_buffer`. More...

size_type	size () const BOOST_NOEXCEPT
	Get the number of elements currently stored in the `circular_buffer`. More...

size_type	max_size () const BOOST_NOEXCEPT
	Get the largest possible size or capacity of the `circular_buffer`. More...

bool	empty () const BOOST_NOEXCEPT
	Is the `circular_buffer` empty? More...

void	set_capacity (capacity_type new_capacity)
	Change the capacity of the `circular_buffer`. More...

void	rset_capacity (capacity_type new_capacity)
	Change the capacity of the `circular_buffer`. More...

void	swap (circular_buffer< T, Alloc > &cb) BOOST_NOEXCEPT
	Swap the contents of two `circular_buffer`s. More...

void	push_back (rvalue_type item)
	Insert a new element at the end of the `circular_buffer` using rvalue references or rvalues references emulation. More...

void	push_front (rvalue_type item)
	Insert a new element at the beginning of the `circular_buffer` using rvalue references or rvalues references emulation. More...

iterator	insert (iterator pos, rvalue_type item)
	Insert an element at the specified position. More...

iterator	rinsert (iterator pos, rvalue_type item)
	Insert an element before the specified position. More...

void	erase_begin (size_type n)
	Remove first `n` elements (with constant complexity for scalar types). More...

void	erase_end (size_type n)
	Remove last `n` elements (with constant complexity for scalar types). More...

Detailed Description

template<class T, class Alloc>
class boost::circular_buffer_space_optimized< T, Alloc >

Space optimized circular buffer container adaptor.

T must be a copyable class or must have an noexcept move constructor and move assignment operator.

Member Typedef Documentation

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::allocator_type boost::circular_buffer_space_optimized< T, Alloc >::allocator_type

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::array_range boost::circular_buffer_space_optimized< T, Alloc >::array_range

template<class T, class Alloc>

typedef cb_details::capacity_control<size_type> boost::circular_buffer_space_optimized< T, Alloc >::capacity_type

Capacity controller of the space optimized circular buffer.

See also: capacity_control in details.hpp.

class capacity_control { size_type m_capacity; // Available capacity. size_type m_min_capacity; // Minimum capacity. public: capacity_control(size_type capacity, size_type min_capacity = 0) : m_capacity(capacity), m_min_capacity(min_capacity) {}; size_type capacity() const { return m_capacity; } size_type min_capacity() const { return m_min_capacity; } operator size_type() const { return m_capacity; } };

Always capacity >= min_capacity.

The capacity() represents the capacity of the circular_buffer_space_optimized and the min_capacity() determines the minimal allocated size of its internal buffer.

The converting constructor of the capacity_control allows implicit conversion from size_type-like types which ensures compatibility of creating an instance of the circular_buffer_space_optimized with other STL containers.

On the other hand the operator size_type() provides implicit conversion to the size_type which allows to treat the capacity of the circular_buffer_space_optimized the same way as in the circular_buffer.

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::const_array_range boost::circular_buffer_space_optimized< T, Alloc >::const_array_range

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::const_iterator boost::circular_buffer_space_optimized< T, Alloc >::const_iterator

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::const_pointer boost::circular_buffer_space_optimized< T, Alloc >::const_pointer

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::const_reference boost::circular_buffer_space_optimized< T, Alloc >::const_reference

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::const_reverse_iterator boost::circular_buffer_space_optimized< T, Alloc >::const_reverse_iterator

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::difference_type boost::circular_buffer_space_optimized< T, Alloc >::difference_type

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::iterator boost::circular_buffer_space_optimized< T, Alloc >::iterator

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::param_value_type boost::circular_buffer_space_optimized< T, Alloc >::param_value_type

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::pointer boost::circular_buffer_space_optimized< T, Alloc >::pointer

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::reference boost::circular_buffer_space_optimized< T, Alloc >::reference

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::reverse_iterator boost::circular_buffer_space_optimized< T, Alloc >::reverse_iterator

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::rvalue_type boost::circular_buffer_space_optimized< T, Alloc >::rvalue_type

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::size_type boost::circular_buffer_space_optimized< T, Alloc >::size_type

template<class T, class Alloc>

typedef circular_buffer<T, Alloc>::value_type boost::circular_buffer_space_optimized< T, Alloc >::value_type

Constructor & Destructor Documentation

template<class T, class Alloc>

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized ( const allocator_type & alloc = allocator_type() )

inlineexplicit

Create an empty space optimized circular buffer with zero capacity.

Postcondition: capacity().capacity() == 0 && capacity().min_capacity() == 0 && size() == 0

Parameters

alloc The allocator.

Exceptions

Nothing.

Complexity: Constant.

Warning: Since Boost version 1.36 the behaviour of this constructor has changed. Now it creates a space optimized circular buffer with zero capacity.

template<class T, class Alloc>

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized	(	capacity_type	capacity_ctrl,
		const allocator_type &	alloc = `allocator_type()`
	)

inlineexplicit

Create an empty space optimized circular buffer with the specified capacity.

Postcondition: capacity() == capacity_ctrl && size() == 0

The amount of allocated memory in the internal buffer is capacity_ctrl.min_capacity().

Parameters

capacity_ctrl	The capacity controller representing the maximum number of elements which can be stored in the `circular_buffer_space_optimized` and the minimal allocated size of the internal buffer.
alloc	The allocator.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used).

Complexity: Constant.

template<class T, class Alloc>

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized	(	capacity_type	capacity_ctrl,
		param_value_type	item,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Create a full space optimized circular buffer with the specified capacity filled with capacity_ctrl.

capacity() copies of item.

Postcondition: capacity() == capacity_ctrl && full() && (*this)[0] == item && (*this)[1] == item && ... && (*this) [capacity_ctrl.capacity() - 1] == item

The amount of allocated memory in the internal buffer is capacity_ctrl.capacity().

Parameters

capacity_ctrl	The capacity controller representing the maximum number of elements which can be stored in the `circular_buffer_space_optimized` and the minimal allocated size of the internal buffer.
item	The element the created `circular_buffer_space_optimized` will be filled with.
alloc	The allocator.

Exceptions

An allocation error	if memory is exhausted (`std::bad_alloc` if the standard allocator is used).
Whatever	`T::T(const T&)` throws.

Complexity: Linear (in the capacity_ctrl.capacity()).

template<class T, class Alloc>

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized	(	capacity_type	capacity_ctrl,
		size_type	n,
		param_value_type	item,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Create a space optimized circular buffer with the specified capacity filled with n copies of item.

Precondition: capacity_ctrl.capacity() >= n

Postcondition: capacity() == capacity_ctrl && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this)[n - 1] == item

The amount of allocated memory in the internal buffer is max[n, capacity_ctrl.min_capacity()].

Parameters

capacity_ctrl	The capacity controller representing the maximum number of elements which can be stored in the `circular_buffer_space_optimized` and the minimal allocated size of the internal buffer.
n	The number of elements the created `circular_buffer_space_optimized` will be filled with.
item	The element the created `circular_buffer_space_optimized` will be filled with.
alloc	The allocator.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Complexity: Linear (in the n).

template<class T, class Alloc>

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized ( const circular_buffer_space_optimized< T, Alloc > & cb )

inline

The copy constructor.

Creates a copy of the specified circular_buffer_space_optimized.

Postcondition: *this == cb

The amount of allocated memory in the internal buffer is cb.size().

Parameters

cb	The `circular_buffer_space_optimized` to be copied.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Complexity: Linear (in the size of cb).

template<class T, class Alloc>

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized ( circular_buffer_space_optimized< T, Alloc > && cb )

inline

The move constructor.

Move constructs a circular_buffer_space_optimized from cb, leaving cb empty.

Precondition: C++ compiler with rvalue references support.

Postcondition: cb.empty()

Parameters

cb	`circular_buffer` to 'steal' value from.

Exceptions

Nothing.

Constant.

template<class T, class Alloc>

template<class InputIterator >

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized	(	InputIterator	first,
		InputIterator	last,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Create a full space optimized circular buffer filled with a copy of the range.

Precondition: Valid range [first, last).
first and last have to meet the requirements of InputIterator.

Postcondition: capacity().capacity() == std::distance(first, last) && capacity().min_capacity() == 0 && full() && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)

The amount of allocated memory in the internal buffer is std::distance(first, last).

Parameters

first	The beginning of the range to be copied.
last	The end of the range to be copied.
alloc	The allocator.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept and InputIterator is a move iterator.

Complexity: Linear (in the std::distance(first, last)).

template<class T, class Alloc>

template<class InputIterator >

boost::circular_buffer_space_optimized< T, Alloc >::circular_buffer_space_optimized	(	capacity_type	capacity_ctrl,
		InputIterator	first,
		InputIterator	last,
		const allocator_type &	alloc = `allocator_type()`
	)

inline

Create a space optimized circular buffer with the specified capacity (and the minimal guaranteed amount of allocated memory) filled with a copy of the range.

Precondition: Valid range [first, last).
first and last have to meet the requirements of InputIterator.

Postcondition: capacity() == capacity_ctrl && size() <= std::distance(first, last) && (*this)[0]== (last - capacity_ctrl.capacity()) && (*this)[1] == *(last - capacity_ctrl.capacity() + 1) && ... && (*this)[capacity_ctrl.capacity() - 1] == *(last - 1)

If the number of items to be copied from the range [first, last) is greater than the specified capacity_ctrl.capacity() then only elements from the range [last - capacity_ctrl.capacity(), last) will be copied.

The amount of allocated memory in the internal buffer is max[capacity_ctrl.min_capacity(), min[capacity_ctrl.capacity(), std::distance(first, last)]].

Parameters

capacity_ctrl	The capacity controller representing the maximum number of elements which can be stored in the `circular_buffer_space_optimized` and the minimal allocated size of the internal buffer.
first	The beginning of the range to be copied.
last	The end of the range to be copied.
alloc	The allocator.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Complexity: Linear (in std::distance(first, last); in min[capacity_ctrl.capacity(), std::distance(first, last)] if the InputIterator is a RandomAccessIterator).

References BOOST_DEDUCED_TYPENAME, and boost::detail::type.

Member Function Documentation

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::assign	(	size_type	n,
		param_value_type	item
	)

inline

Assign n items into the space optimized circular buffer.

The content of the circular_buffer_space_optimized will be removed and replaced with n copies of the item.

Postcondition: capacity().capacity() == n && capacity().min_capacity() == 0 && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item

The amount of allocated memory in the internal buffer is n.

Parameters

n	The number of elements the `circular_buffer_space_optimized` will be filled with.
item	The element the `circular_buffer_space_optimized` will be filled with.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the n).

See also: operator=, assign(capacity_type, size_type, const_reference), assign(InputIterator, InputIterator), assign(capacity_type, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::assign().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::assign	(	capacity_type	capacity_ctrl,
		size_type	n,
		param_value_type	item
	)

inline

Assign n items into the space optimized circular buffer specifying the capacity.

The capacity of the circular_buffer_space_optimized will be set to the specified value and the content of the circular_buffer_space_optimized will be removed and replaced with n copies of the item.

Precondition: capacity_ctrl.capacity() >= n

Postcondition: capacity() == capacity_ctrl && size() == n && (*this)[0] == item && (*this)[1] == item && ... && (*this) [n - 1] == item

The amount of allocated memory will be max[n, capacity_ctrl.min_capacity()].

Parameters

capacity_ctrl	The new capacity controller.
n	The number of elements the `circular_buffer_space_optimized` will be filled with.
item	The element the `circular_buffer_space_optimized` will be filled with.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the n).

See also: operator=, assign(size_type, const_reference), assign(InputIterator, InputIterator), assign(capacity_type, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::assign(), BOOST_CB_ASSERT, boost::accumulators::extract::max, and boost::n.

template<class T, class Alloc>

template<class InputIterator >

void boost::circular_buffer_space_optimized< T, Alloc >::assign	(	InputIterator	first,
		InputIterator	last
	)

inline

Assign a copy of the range into the space optimized circular buffer.

The content of the circular_buffer_space_optimized will be removed and replaced with copies of elements from the specified range.

Precondition: Valid range [first, last).
first and last have to meet the requirements of InputIterator.

Postcondition: capacity().capacity() == std::distance(first, last) && capacity().min_capacity() == 0 && size() == std::distance(first, last) && (*this)[0]== *first && (*this)[1] == *(first + 1) && ... && (*this)[std::distance(first, last) - 1] == *(last - 1)

The amount of allocated memory in the internal buffer is std::distance(first, last).

Parameters

first	The beginning of the range to be copied.
last	The end of the range to be copied.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept and InputIterator is a move iterator.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the std::distance(first, last)).

See also: operator=, assign(size_type, const_reference), assign(capacity_type, size_type, const_reference), assign(capacity_type, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::assign().

template<class T, class Alloc>

template<class InputIterator >

void boost::circular_buffer_space_optimized< T, Alloc >::assign	(	capacity_type	capacity_ctrl,
		InputIterator	first,
		InputIterator	last
	)

inline

Assign a copy of the range into the space optimized circular buffer specifying the capacity.

The capacity of the circular_buffer_space_optimized will be set to the specified value and the content of the circular_buffer_space_optimized will be removed and replaced with copies of elements from the specified range.

Precondition: Valid range [first, last).
first and last have to meet the requirements of InputIterator.

Postcondition: capacity() == capacity_ctrl && size() <= std::distance(first, last) && (*this)[0]== *(last - capacity) && (*this)[1] == *(last - capacity + 1) && ... && (*this)[capacity - 1] == *(last - 1)

If the number of items to be copied from the range [first, last) is greater than the specified capacity then only elements from the range [last - capacity, last) will be copied.

The amount of allocated memory in the internal buffer is max[std::distance(first, last), capacity_ctrl.min_capacity()].

Parameters

capacity_ctrl	The new capacity controller.
first	The beginning of the range to be copied.
last	The end of the range to be copied.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept and InputIterator is a move iterator.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in std::distance(first, last); in min[capacity_ctrl.capacity(), std::distance(first, last)] if the InputIterator is a RandomAccessIterator).

See also: operator=, assign(size_type, const_reference), assign(capacity_type, size_type, const_reference), assign(InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::assign().

template<class T, class Alloc>

const capacity_type& boost::circular_buffer_space_optimized< T, Alloc >::capacity ( ) const

inline

Get the capacity of the circular_buffer_space_optimized.

Returns: The capacity controller representing the maximum number of elements which can be stored in the circular_buffer_space_optimized and the minimal allocated size of the internal buffer.

Exceptions

Nothing.

Exception Safety: No-throw.

Iterator Invalidation: Does not invalidate any iterators.

Complexity: Constant (in the size of the circular_buffer_space_optimized).

See also: reserve(), size(), max_size(), set_capacity(const capacity_type&)

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::clear ( )

inline

Remove all stored elements from the space optimized circular buffer.

Postcondition: size() == 0

The amount of allocated memory in the internal buffer may be predictively decreased.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used).

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: ~circular_buffer_space_optimized(), erase(iterator), erase(iterator, iterator), rerase(iterator), rerase(iterator, iterator)

References boost::circular_buffer< T, Alloc >::begin(), boost::circular_buffer< T, Alloc >::end(), and boost::circular_buffer_space_optimized< T, Alloc >::erase().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::erase ( iterator pos )

inline

Remove an element at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized (but not an end()).

Postcondition: The element at the position pos is removed.

The amount of allocated memory in the internal buffer may be predictively decreased.

Parameters

pos	An iterator pointing at the element to be removed.

Returns: Iterator to the first element remaining beyond the removed element or end() if no such element exists.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::operator = (const T&) throws or nothing if T::operator = (T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: erase(iterator, iterator), rerase(iterator), rerase(iterator, iterator), clear()

References boost::circular_buffer< T, Alloc >::begin(), boost::circular_buffer< T, Alloc >::erase(), and boost::it.

Referenced by boost::circular_buffer_space_optimized< T, Alloc >::clear(), and boost::circular_buffer_space_optimized< T, Alloc >::resize().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::erase	(	iterator	first,
		iterator	last
	)

inline

Erase the range [first, last).

Precondition: Valid range [first, last).

Postcondition: The elements from the range [first, last) are removed. (If first == last nothing is removed.)

The amount of allocated memory in the internal buffer may be predictively decreased.

Parameters

first	The beginning of the range to be removed.
last	The end of the range to be removed.

Returns: Iterator to the first element remaining beyond the removed elements or end() if no such element exists.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::operator = (const T&) throws or nothing if T::operator = (T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: erase(iterator), rerase(iterator), rerase(iterator, iterator), clear()

References boost::circular_buffer< T, Alloc >::begin(), boost::circular_buffer< T, Alloc >::erase(), and boost::it.

template<class T, class Alloc>

bool boost::circular_buffer_space_optimized< T, Alloc >::full ( ) const

inline

Is the circular_buffer_space_optimized full?

Returns: true if the number of elements stored in the circular_buffer_space_optimized equals the capacity of the circular_buffer_space_optimized; false otherwise.

Exceptions

Nothing.

Exception Safety: No-throw.

Iterator Invalidation: Does not invalidate any iterators.

Complexity: Constant (in the size of the circular_buffer_space_optimized).

See also: empty()

References boost::circular_buffer< T, Alloc >::size().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::insert	(	iterator	pos,
		param_value_type	item
	)

inline

Insert an element at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The item will be inserted at the position pos.
If the circular_buffer_space_optimized is full, the first element will be overwritten. If the circular_buffer_space_optimized is full and the pos points to begin(), then the item will not be inserted. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the `item` will be inserted.
item	The element to be inserted.

Returns: Iterator to the inserted element or begin() if the item is not inserted. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws. Whatever T::operator = (const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::insert().

Referenced by boost::circular_buffer_space_optimized< T, Alloc >::insert(), and boost::circular_buffer_space_optimized< T, Alloc >::resize().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::insert	(	iterator	pos,
		rvalue_type	item
	)

inline

Insert an element at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The item will be inserted at the position pos.
If the circular_buffer_space_optimized is full, the first element will be overwritten. If the circular_buffer_space_optimized is full and the pos points to begin(), then the item will not be inserted. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the `item` will be inserted.
item	The element to be inserted.

Returns: Iterator to the inserted element or begin() if the item is not inserted. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), boost::circular_buffer< T, Alloc >::insert(), and boost::move().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::insert ( iterator pos )

inline

Insert an element at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The item will be inserted at the position pos.
If the circular_buffer_space_optimized is full, the first element will be overwritten. If the circular_buffer_space_optimized is full and the pos points to begin(), then the item will not be inserted. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the `item` will be inserted.

Returns: Iterator to the inserted element or begin() if the item is not inserted. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T() throws. Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::insert().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::insert	(	iterator	pos,
		size_type	n,
		param_value_type	item
	)

inline

Insert n copies of the item at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The number of min[n, (pos - begin()) + reserve()] elements will be inserted at the position pos.
The number of min[pos - begin(), max[0, n - reserve()]] elements will be overwritten at the beginning of the circular_buffer_space_optimized.
(See Example for the explanation.)

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the `item`s will be inserted.
n	The number of `item`s the to be inserted.
item	The element whose copies will be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws. Whatever T::operator = (const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in min[capacity().capacity(), size() + n]).

Example: Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.

|1|2|3|4| | |
p ___^

After inserting 5 elements at the position p:

insert(p, (size_t)5, 0);

actually only 4 elements get inserted and elements 1 and 2 are overwritten. This is due to the fact the insert operation preserves the capacity. After insertion the internal buffer looks like this:

|0|0|0|0|3|4|

For comparison if the capacity would not be preserved the internal buffer would then result in |1|2|0|0|0|0|0|3|4|.

See also: insert(iterator, value_type), insert(iterator, InputIterator, InputIterator), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::insert().

template<class T, class Alloc>

template<class InputIterator >

void boost::circular_buffer_space_optimized< T, Alloc >::insert	(	iterator	pos,
		InputIterator	first,
		InputIterator	last
	)

inline

Insert the range [first, last) at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.
Valid range [first, last) where first and last meet the requirements of an InputIterator.

Postcondition: Elements from the range [first + max[0, distance(first, last) - (pos - begin()) - reserve()], last) will be inserted at the position pos.
The number of min[pos - begin(), max[0, distance(first, last) - reserve()]] elements will be overwritten at the beginning of the circular_buffer_space_optimized.
(See Example for the explanation.)

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the range will be inserted.
first	The beginning of the range to be inserted.
last	The end of the range to be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in [size() + std::distance(first, last)]; in min[capacity().capacity(), size() + std::distance(first, last)] if the InputIterator is a RandomAccessIterator).

Example: Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.

|1|2|3|4| | |
p ___^

After inserting a range of elements at the position p:

int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);

actually only elements 6, 7, 8 and 9 from the specified range get inserted and elements 1 and 2 are overwritten. This is due to the fact the insert operation preserves the capacity. After insertion the internal buffer looks like this:

|6|7|8|9|3|4|

For comparison if the capacity would not be preserved the internal buffer would then result in |1|2|5|6|7|8|9|3|4|.

See also: insert(iterator, value_type), insert(iterator, size_type, value_type), rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator)

References boost::circular_buffer_space_optimized< T, Alloc >::insert().

template<class T, class Alloc>

circular_buffer_space_optimized<T, Alloc>& boost::circular_buffer_space_optimized< T, Alloc >::operator= ( const circular_buffer_space_optimized< T, Alloc > & cb )

inline

The assign operator.

Makes this circular_buffer_space_optimized to become a copy of the specified circular_buffer_space_optimized.

Postcondition: *this == cb

The amount of allocated memory in the internal buffer is cb.size().

Parameters

cb	The `circular_buffer_space_optimized` to be copied.

Exceptions

An allocation error	if memory is exhausted (`std::bad_alloc` if the standard allocator is used).
Whatever	`T::T(const T&)` throws.

Exception Safety: Strong.

Iterator Invalidation: Invalidates all iterators pointing to this circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of cb).

See also: assign(size_type, const_reference), assign(capacity_type, size_type, const_reference), assign(InputIterator, InputIterator), assign(capacity_type, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::assign(), boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::end().

template<class T, class Alloc>

circular_buffer_space_optimized<T, Alloc>& boost::circular_buffer_space_optimized< T, Alloc >::operator= ( circular_buffer_space_optimized< T, Alloc > && cb )

inline

Move assigns content of cb to *this, leaving cb empty.

Precondition: C++ compiler with rvalue references support.

Postcondition: cb.empty()

Parameters

cb	`circular_buffer` to 'steal' value from.

Exceptions

Nothing.

Complexity: Constant.

References boost::circular_buffer< T, Alloc >::get_allocator(), and boost::circular_buffer_space_optimized< T, Alloc >::swap().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::pop_back ( )

inline

Remove the last element from the space optimized circular buffer.

Precondition: !empty()

Postcondition: The last element is removed from the circular_buffer_space_optimized.

The amount of allocated memory in the internal buffer may be predictively decreased.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used).

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: pop_front(), push_back(const_reference), push_front(const_reference)

References boost::circular_buffer< T, Alloc >::pop_back().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::pop_front ( )

inline

Remove the first element from the space optimized circular buffer.

Precondition: !empty()

Postcondition: The first element is removed from the circular_buffer_space_optimized.

The amount of allocated memory in the internal buffer may be predictively decreased.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used).

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: pop_back(), push_back(const_reference), push_front(const_reference)

References boost::circular_buffer< T, Alloc >::pop_front().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::push_back ( param_value_type item )

inline

Insert a new element at the end of the space optimized circular buffer.

Postcondition: if capacity().capacity() > 0 then back() == item
If the circular_buffer_space_optimized is full, the first element will be removed. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

item	The element to be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: push_front(const_reference), pop_back(), pop_front()

References boost::circular_buffer< T, Alloc >::push_back().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::push_back ( rvalue_type item )

inline

Insert a new element at the end of the space optimized circular buffer.

Postcondition: if capacity().capacity() > 0 then back() == item
If the circular_buffer_space_optimized is full, the first element will be removed. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

item	The element to be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used).

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: push_front(const_reference), pop_back(), pop_front()

References boost::move(), and boost::circular_buffer< T, Alloc >::push_back().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::push_back ( )

inline

Insert a new element at the end of the space optimized circular buffer.

Postcondition: if capacity().capacity() > 0 then back() == item
If the circular_buffer_space_optimized is full, the first element will be removed. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T() throws. Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: push_front(const_reference), pop_back(), pop_front()

References boost::circular_buffer< T, Alloc >::push_back().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::push_front ( param_value_type item )

inline

Insert a new element at the beginning of the space optimized circular buffer.

Postcondition: if capacity().capacity() > 0 then front() == item
If the circular_buffer_space_optimized is full, the last element will be removed. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

item	The element to be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: push_back(const_reference), pop_back(), pop_front()

References boost::circular_buffer< T, Alloc >::push_front().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::push_front ( rvalue_type item )

inline

Insert a new element at the beginning of the space optimized circular buffer.

Postcondition: if capacity().capacity() > 0 then front() == item
If the circular_buffer_space_optimized is full, the last element will be removed. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

item	The element to be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: push_back(const_reference), pop_back(), pop_front()

References boost::move(), and boost::circular_buffer< T, Alloc >::push_front().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::push_front ( )

inline

Insert a new element at the beginning of the space optimized circular buffer.

Postcondition: if capacity().capacity() > 0 then front() == item
If the circular_buffer_space_optimized is full, the last element will be removed. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T() throws. Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: push_back(const_reference), pop_back(), pop_front()

References boost::circular_buffer< T, Alloc >::push_front().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::rerase ( iterator pos )

inline

Remove an element at the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized (but not an end()).

The amount of allocated memory in the internal buffer may be predictively decreased.

Postcondition: The element at the position pos is removed.

Parameters

pos	An iterator pointing at the element to be removed.

Returns: Iterator to the first element remaining in front of the removed element or begin() if no such element exists.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::operator = (const T&) throws or nothing if T::operator = (T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

Note: Basically there is no difference between erase(iterator) and this method. It is implemented only for consistency with the base circular_buffer.

See also: erase(iterator), erase(iterator, iterator), rerase(iterator, iterator), clear()

References boost::circular_buffer< T, Alloc >::begin(), boost::it, and boost::circular_buffer< T, Alloc >::rerase().

Referenced by boost::circular_buffer_space_optimized< T, Alloc >::rresize().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::rerase	(	iterator	first,
		iterator	last
	)

inline

Erase the range [first, last).

Precondition: Valid range [first, last).

Postcondition: The elements from the range [first, last) are removed. (If first == last nothing is removed.)

The amount of allocated memory in the internal buffer may be predictively decreased.

Parameters

first	The beginning of the range to be removed.
last	The end of the range to be removed.

Returns: Iterator to the first element remaining in front of the removed elements or begin() if no such element exists.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::operator = (const T&) throws or nothing if T::operator = (T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

Note: Basically there is no difference between erase(iterator, iterator) and this method. It is implemented only for consistency with the base <circular_buffer.

See also: erase(iterator), erase(iterator, iterator), rerase(iterator), clear()

References boost::circular_buffer< T, Alloc >::begin(), boost::it, and boost::circular_buffer< T, Alloc >::rerase().

template<class T, class Alloc>

size_type boost::circular_buffer_space_optimized< T, Alloc >::reserve ( ) const

inline

Get the maximum number of elements which can be inserted into the circular_buffer_space_optimized without overwriting any of already stored elements.

Returns: capacity().capacity() - size()

Exceptions

Nothing.

Exception Safety: No-throw.

Iterator Invalidation: Does not invalidate any iterators.

Complexity: Constant (in the size of the circular_buffer_space_optimized).

See also: capacity(), size(), max_size()

References boost::circular_buffer< T, Alloc >::size().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::resize	(	size_type	new_size,
		param_value_type	item = `value_type()`
	)

inline

Change the size of the circular_buffer_space_optimized.

Postcondition: size() == new_size && capacity().capacity() >= new_size

If the new size is greater than the current size, copies of item will be inserted at the back of the of the circular_buffer_space_optimized in order to achieve the desired size. In the case the resulting size exceeds the current capacity the capacity will be set to new_size.

If the current number of elements stored in the circular_buffer_space_optimized is greater than the desired new size then number of [size() - new_size] last elements will be removed. (The capacity will remain unchanged.)

The amount of allocated memory in the internal buffer may be accommodated as necessary.

Parameters

new_size	The new size.
item	The element the `circular_buffer_space_optimized` will be filled with in order to gain the requested size. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the new size of the circular_buffer_space_optimized).

See also: rresize(size_type, const_reference), set_capacity(const capacity_type&)

References boost::circular_buffer< T, Alloc >::end(), boost::circular_buffer_space_optimized< T, Alloc >::erase(), boost::circular_buffer_space_optimized< T, Alloc >::insert(), and boost::circular_buffer< T, Alloc >::size().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::rinsert	(	iterator	pos,
		param_value_type	item
	)

inline

Insert an element before the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The item will be inserted before the position pos.
If the circular_buffer_space_optimized is full, the last element will be overwritten. If the circular_buffer_space_optimized is full and the pos points to end(), then the item will not be inserted. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position before which the `item` will be inserted.
item	The element to be inserted.

Returns: Iterator to the inserted element or end() if the item is not inserted. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws. Whatever T::operator = (const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::rinsert().

Referenced by boost::circular_buffer_space_optimized< T, Alloc >::rinsert(), and boost::circular_buffer_space_optimized< T, Alloc >::rresize().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::rinsert	(	iterator	pos,
		rvalue_type	item
	)

inline

Insert an element before the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The item will be inserted before the position pos.
If the circular_buffer_space_optimized is full, the last element will be overwritten. If the circular_buffer_space_optimized is full and the pos points to end(), then the item will not be inserted. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position before which the `item` will be inserted.
item	The element to be inserted.

Returns: Iterator to the inserted element or end() if the item is not inserted. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), boost::move(), and boost::circular_buffer< T, Alloc >::rinsert().

template<class T, class Alloc>

iterator boost::circular_buffer_space_optimized< T, Alloc >::rinsert ( iterator pos )

inline

Insert an element before the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The item will be inserted before the position pos.
If the circular_buffer_space_optimized is full, the last element will be overwritten. If the circular_buffer_space_optimized is full and the pos points to end(), then the item will not be inserted. If the capacity is 0, nothing will be inserted.

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position before which the `item` will be inserted.

Returns: Iterator to the inserted element or end() if the item is not inserted. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T() throws. Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the size of the circular_buffer_space_optimized).

See also: rinsert(iterator, size_type, value_type), rinsert(iterator, InputIterator, InputIterator), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::rinsert().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::rinsert	(	iterator	pos,
		size_type	n,
		param_value_type	item
	)

inline

Insert n copies of the item before the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.

Postcondition: The number of min[n, (end() - pos) + reserve()] elements will be inserted before the position pos.
The number of min[end() - pos, max[0, n - reserve()]] elements will be overwritten at the end of the circular_buffer_space_optimized.
(See Example for the explanation.)

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the `item`s will be inserted.
n	The number of `item`s the to be inserted.
item	The element whose copies will be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws. Whatever T::operator = (const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in min[capacity().capacity(), size() + n]).

Example: Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.

|1|2|3|4| | |
p ___^

After inserting 5 elements before the position p:

rinsert(p, (size_t)5, 0);

actually only 4 elements get inserted and elements 3 and 4 are overwritten. This is due to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks like this:

|1|2|0|0|0|0|

For comparison if the capacity would not be preserved the internal buffer would then result in |1|2|0|0|0|0|0|3|4|.

See also: rinsert(iterator, value_type), rinsert(iterator, InputIterator, InputIterator), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

References boost::circular_buffer< T, Alloc >::begin(), and boost::circular_buffer< T, Alloc >::rinsert().

template<class T, class Alloc>

template<class InputIterator >

void boost::circular_buffer_space_optimized< T, Alloc >::rinsert	(	iterator	pos,
		InputIterator	first,
		InputIterator	last
	)

inline

Insert the range [first, last) before the specified position.

Precondition: pos is a valid iterator pointing to the circular_buffer_space_optimized or its end.
Valid range [first, last) where first and last meet the requirements of an InputIterator.

Postcondition: Elements from the range [first, last - max[0, distance(first, last) - (end() - pos) - reserve()]) will be inserted before the position pos.
The number of min[end() - pos, max[0, distance(first, last) - reserve()]] elements will be overwritten at the end of the circular_buffer.
(See Example for the explanation.)

The amount of allocated memory in the internal buffer may be predictively increased.

Parameters

pos	An iterator specifying the position where the range will be inserted.
first	The beginning of the range to be inserted.
last	The end of the range to be inserted.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws. Whatever T::operator = (const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in [size() + std::distance(first, last)]; in min[capacity().capacity(), size() + std::distance(first, last)] if the InputIterator is a RandomAccessIterator).

Example: Consider a circular_buffer_space_optimized with the capacity of 6 and the size of 4. Its internal buffer may look like the one below.

|1|2|3|4| | |
p ___^

After inserting a range of elements before the position p:

int array[] = { 5, 6, 7, 8, 9 };
insert(p, array, array + 5);

actually only elements 5, 6, 7 and 8 from the specified range get inserted and elements 3 and 4 are overwritten. This is due to the fact the rinsert operation preserves the capacity. After insertion the internal buffer looks like this:

|1|2|5|6|7|8|

For comparison if the capacity would not be preserved the internal buffer would then result in |1|2|5|6|7|8|9|3|4|.

See also: rinsert(iterator, value_type), rinsert(iterator, size_type, value_type), insert(iterator, value_type), insert(iterator, size_type, value_type), insert(iterator, InputIterator, InputIterator)

References boost::circular_buffer_space_optimized< T, Alloc >::rinsert().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::rresize	(	size_type	new_size,
		param_value_type	item = `value_type()`
	)

inline

Change the size of the circular_buffer_space_optimized.

Postcondition: size() == new_size && capacity().capacity() >= new_size

If the new size is greater than the current size, copies of item will be inserted at the front of the of the circular_buffer_space_optimized in order to achieve the desired size. In the case the resulting size exceeds the current capacity the capacity will be set to new_size.

If the current number of elements stored in the circular_buffer_space_optimized is greater than the desired new size then number of [size() - new_size] first elements will be removed. (The capacity will remain unchanged.)

The amount of allocated memory in the internal buffer may be accommodated as necessary.

Parameters

new_size	The new size.
item	The element the `circular_buffer_space_optimized` will be filled with in order to gain the requested size. (See the Effect.)

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws.

Exception Safety: Basic.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in the new size of the circular_buffer_space_optimized).

See also: resize(size_type, const_reference), rset_capacity(const capacity_type&)

References boost::circular_buffer< T, Alloc >::begin(), boost::circular_buffer< T, Alloc >::end(), boost::circular_buffer_space_optimized< T, Alloc >::rerase(), boost::circular_buffer_space_optimized< T, Alloc >::rinsert(), and boost::circular_buffer< T, Alloc >::size().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::rset_capacity ( const capacity_type & capacity_ctrl )

inline

Change the capacity (and the minimal guaranteed amount of allocated memory) of the circular_buffer_space_optimized.

Postcondition: capacity() == capacity_ctrl && size() <= capacity_ctrl

If the current number of elements stored in the circular_buffer_space_optimized is greater than the desired new capacity then number of [size() - capacity_ctrl.capacity()] first elements will be removed and the new size will be equal to capacity_ctrl.capacity().

If the current number of elements stored in the circular_buffer_space_optimized is lower than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as necessary but it will never drop below capacity_ctrl.min_capacity().

Parameters

capacity_ctrl The new capacity controller.

Exceptions

An allocation error if memory is exhausted (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Strong.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in min[size(), capacity_ctrl.capacity()]).

See also: set_capacity(const capacity_type&), rresize(size_type, const_reference)

References boost::asio::b, boost::circular_buffer< T, Alloc >::begin(), boost::circular_buffer< T, Alloc >::rerase(), and boost::circular_buffer< T, Alloc >::size().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::set_capacity ( const capacity_type & capacity_ctrl )

inline

Change the capacity (and the minimal guaranteed amount of allocated memory) of the circular_buffer_space_optimized.

Postcondition: capacity() == capacity_ctrl && size() <= capacity_ctrl.capacity()

If the current number of elements stored in the circular_buffer_space_optimized is greater than the desired new capacity then number of [size() - capacity_ctrl.capacity()] last elements will be removed and the new size will be equal to capacity_ctrl.capacity().

If the current number of elements stored in the circular_buffer_space_optimized is lower than the new capacity then the amount of allocated memory in the internal buffer may be accommodated as necessary but it will never drop below capacity_ctrl.min_capacity().

Parameters

capacity_ctrl The new capacity controller.

Exceptions

An allocation error if memory is exhausted, (std::bad_alloc if the standard allocator is used). Whatever T::T(const T&) throws or nothing if T::T(T&&) is noexcept.

Exception Safety: Strong.

Iterator Invalidation: Invalidates all iterators pointing to the circular_buffer_space_optimized (except iterators equal to end()).

Complexity: Linear (in min[size(), capacity_ctrl.capacity()]).

Note: To explicitly clear the extra allocated memory use the shrink-to-fit technique:

boost::circular_buffer_space_optimized<int> cb(1000); ... boost::circular_buffer_space_optimized<int>(cb).swap(cb);

For more information about the shrink-to-fit technique in STL see http://www.gotw.ca/gotw/054.htm.

See also: rset_capacity(const capacity_type&), resize(size_type, const_reference)

References boost::circular_buffer< T, Alloc >::end(), boost::circular_buffer< T, Alloc >::erase(), and boost::circular_buffer< T, Alloc >::size().

template<class T, class Alloc>

void boost::circular_buffer_space_optimized< T, Alloc >::swap ( circular_buffer_space_optimized< T, Alloc > & cb )

inline

Swap the contents of two space-optimized circular-buffers.

Postcondition: this contains elements of cb and vice versa; the capacity and the amount of allocated memory in the internal buffer of this equal to the capacity and the amount of allocated memory of cb and vice versa.

Parameters

cb	The `circular_buffer_space_optimized` whose content will be swapped.

Exceptions

Nothing.

Exception Safety: No-throw.

Iterator Invalidation: Invalidates all iterators of both circular_buffer_space_optimized containers. (On the other hand the iterators still point to the same elements but within another container. If you want to rely on this feature you have to turn the __debug_support off by defining macro BOOST_CB_DISABLE_DEBUG, otherwise an assertion will report an error if such invalidated iterator is used.)

Complexity: Constant (in the size of the circular_buffer_space_optimized).

See also: swap(circular_buffer<T, Alloc>&, circular_buffer<T, Alloc>&), swap(circular_buffer_space_optimized<T, Alloc>&, circular_buffer_space_optimized<T, Alloc>&)

References boost::circular_buffer< T, Alloc >::swap(), and boost::swap().

Referenced by boost::circular_buffer_space_optimized< T, Alloc >::operator=().

The documentation for this class was generated from the following file:

boost_1_57_0/boost/circular_buffer/space_optimized.hpp

Public Types

Public Member Functions

Private Types

Private Member Functions

Detailed Description

template<class T, class Alloc> class boost::circular_buffer_space_optimized< T, Alloc >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

template<class T, class Alloc>
class boost::circular_buffer_space_optimized< T, Alloc >