A base class for a generic internal fixed size stack and vector. More...

#include <tpie/internal_stack_vector_base.h>

Inherits tpie::linear_memory_base< child_t >.

Public Types
typedef T	value_type

Public Member Functions
	internal_stack_vector_base (size_t size=0, tpie::memory_bucket_ref b=memory_bucket_ref())
	Construct structure with given capacity. More...

void	resize (size_t size=0)
	Change the capacity of the structure and clear all elements. More...

bool	empty () const
	Check if no elements are currently pushed to the structure. More...

size_t	size () const
	Return the number of elements in the data structure. More...

void	clear ()
	Clear the data structure of all elements. More...

Static Public Member Functions
static double	memory_coefficient ()
	Return the memory coefficient of the structure. More...

static double	memory_overhead ()
	Return the memory overhead of the structure. More...

static memory_size_type	memory_usage (memory_size_type size)
	Return the number of bytes required to create a data structure supporting a given number of elements. More...

static memory_size_type	memory_fits (memory_size_type memory)
	Return the maximum number of elements that can be contained in in the structure when it is allowed to fill a given number of bytes. More...

Protected Attributes
array< T >	m_elements
	Element storage. More...

size_t	m_size
	Number of elements pushed to the structure. More...

Detailed Description

template<typename T, typename child_t>
class tpie::internal_stack_vector_base< T, child_t >

A base class for a generic internal fixed size stack and vector.

Template Parameters

T	The type of items stored in the container.
child_t	The subtype of the class (CRTP).

Definition at line 38 of file internal_stack_vector_base.h.

Constructor & Destructor Documentation

template<typename T, typename child_t>

tpie::internal_stack_vector_base< T, child_t >::internal_stack_vector_base	(	size_t	size = `0`,
		tpie::memory_bucket_ref	b = `memory_bucket_ref()`
	)

inline

Construct structure with given capacity.

If a zero capacity is given (the default), no elements may be pushed to the structure until the structure is resized to a different capacity.

Parameters

size	Capacity of the structure.

Definition at line 69 of file internal_stack_vector_base.h.

69 :

70 m_elements(size, b), m_size(0) {}

tpie::internal_stack_vector_base::m_size

size_t m_size

Number of elements pushed to the structure.

Definition: internal_stack_vector_base.h:44

tpie::internal_stack_vector_base::size

size_t size() const

Return the number of elements in the data structure.

Definition: internal_stack_vector_base.h:87

tpie::internal_stack_vector_base::m_elements

array< T > m_elements

Element storage.

Definition: internal_stack_vector_base.h:41

Member Function Documentation

template<typename T, typename child_t>

void tpie::internal_stack_vector_base< T, child_t >::clear ( )

inline

Clear the data structure of all elements.

Definition at line 92 of file internal_stack_vector_base.h.

92 {m_size=0;}

tpie::internal_stack_vector_base::m_size

size_t m_size

Number of elements pushed to the structure.

Definition: internal_stack_vector_base.h:44

template<typename T, typename child_t>

bool tpie::internal_stack_vector_base< T, child_t >::empty ( ) const

inline

Check if no elements are currently pushed to the structure.

Definition at line 82 of file internal_stack_vector_base.h.

82 {return m_size==0;}

tpie::internal_stack_vector_base::m_size

size_t m_size

Number of elements pushed to the structure.

Definition: internal_stack_vector_base.h:44

template<typename T, typename child_t>

static double tpie::internal_stack_vector_base< T, child_t >::memory_coefficient ( )

inlinestatic

Return the memory coefficient of the structure.

Allocating a structure with n elements will use at most $\lfloor \mathrm{memory\_coefficient} \cdot n + \mathrm{memory\_overhead} \rfloor$ bytes. This does not include memory overhead incurred if the structure is allocated using new.

Returns: The memory coefficient of the structure.

Definition at line 51 of file internal_stack_vector_base.h.

51 {return array<T>::memory_coefficient();}

tpie::array::memory_coefficient

static double memory_coefficient()

Return the memory coefficient of the structure.

Definition: array.h:393

template<typename child_t>

static memory_size_type tpie::linear_memory_base< child_t >::memory_fits ( memory_size_type memory )

inlinestaticinherited

Return the maximum number of elements that can be contained in in the structure when it is allowed to fill a given number of bytes.

Parameters

memory The number of bytes the structure is allowed to occupy

Returns: The number of elements that will fit in the structure

Definition at line 93 of file util.h.

                                                                         {
         return static_cast<memory_size_type>(
             floor((memory - child_t::memory_overhead()) / child_t::memory_coefficient()));
     }

template<typename T, typename child_t>

static double tpie::internal_stack_vector_base< T, child_t >::memory_overhead ( )

inlinestatic

Return the memory overhead of the structure.

See also: memory_coefficient()

Returns: The memory overhead.

Definition at line 56 of file internal_stack_vector_base.h.

                                     {
         return array<T>::memory_overhead() - sizeof(array<T>) + sizeof(child_t);
     }

template<typename child_t>

static memory_size_type tpie::linear_memory_base< child_t >::memory_usage ( memory_size_type size )

inlinestaticinherited

Return the number of bytes required to create a data structure supporting a given number of elements.

Parameters

size	The number of elements to support

Returns: The amount of memory required in bytes

Definition at line 81 of file util.h.

                                                                 {
         return static_cast<memory_size_type>(
             floor(static_cast<double>(size) * child_t::memory_coefficient() + child_t::memory_overhead()));
     }