std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow > Template-Strukturreferenz

#include <fixed_vector.hpp>

Klassendiagramm für std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >:

Zusammengehörigkeiten von std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >:

Öffentliche Typen
typedef aligned_as< T >::res	etype_t

Öffentliche Methoden
	fixed_vector_storage (const TAllocator &allocator)
	fixed_vector_storage (e_noinitialize)
void	reallocate (base_vector::size_type newCapacity, base_vector::size_type oldSize)
void	reallocate_discard_old (base_vector::size_type newCapacity)
void	destroy (T *ptr, base_vector::size_type n)
bool	invariant () const
void	record_high_watermark ()
base_vector::size_type	get_high_watermark () const

Öffentliche Attribute
T *	m_begin
T *	m_end
etype_t	m_data [(TCapacity *sizeof(T))/sizeof(etype_t)]
T *	m_capacityEnd
TAllocator	m_allocator
base_vector::size_type	m_max_size

Ausführliche Beschreibung

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>
struct std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >

Dokumentation der benutzerdefinierten Datentypen

etype_t

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

typedef aligned_as<T>::res std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::etype_t

Beschreibung der Konstruktoren und Destruktoren

fixed_vector_storage() [1/2]

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::fixed_vector_storage ( const TAllocator &  allocator )

inlineexplicit

            : m_begin((T*)&m_data[0]),  m_end(m_begin), m_capacityEnd(m_begin + TCapacity), m_allocator(allocator) , m_max_size(0)
        {
        }       

fixed_vector_storage() [2/2]

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::fixed_vector_storage ( e_noinitialize  )

inlineexplicit

        {
        }

Dokumentation der Elementfunktionen

destroy()

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

void std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::destroy ( T *  ptr, base_vector::size_type  n  )

inline

        {
                std::destruct_n(ptr, n);
                if ((etype_t*)ptr != &m_data[0])
                        m_allocator.deallocate(ptr, n * sizeof(T));
        }

get_high_watermark()

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

base_vector::size_type std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::get_high_watermark ( ) const

inline

        {
            return m_max_size;
        }

invariant()

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

bool std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::invariant ( ) const

inline

        {
                return m_end >= m_begin;
        }

reallocate()

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

void std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::reallocate ( base_vector::size_type  newCapacity, base_vector::size_type  oldSize  )

inline

        {
                if (!TGrowOnOverflow)
                {
                        assert(!"fixed_vector cannot grow");
                }
                T* newBegin = static_cast<T*>(m_allocator.allocate(newCapacity * sizeof(T)));
                const base_vector::size_type newSize = oldSize < newCapacity ? oldSize : newCapacity;

                if (m_begin)
                {
                        std::copy_construct_n(m_begin, newSize, newBegin);
                        destroy(m_begin, oldSize);
                }
                m_begin = newBegin;
                m_end = m_begin + newSize;
                m_capacityEnd = m_begin + newCapacity;
                record_high_watermark();
                assert(invariant());
        }

reallocate_discard_old()

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

void std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::reallocate_discard_old ( base_vector::size_type  newCapacity )

inline

        {
                if (newCapacity > base_vector::size_type(m_capacityEnd - m_begin))
                {
                        if (!TGrowOnOverflow)
                        {
                                assert(!"fixed_vector cannot grow");
                        }
                        T* newBegin = static_cast<T*>(m_allocator.allocate(newCapacity * sizeof(T)));
                        const base_vector::size_type currSize((size_t)(m_end - m_begin));
                        if (m_begin)
                                destroy(m_begin, currSize);
                        m_begin = newBegin;
                        m_end = m_begin + currSize;
                        record_high_watermark();
                        m_capacityEnd = m_begin + newCapacity;
                }
                assert(invariant());
        }

record_high_watermark()

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

void std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::record_high_watermark ( )

inline

        {
            const base_vector::size_type curr_size((size_t)(m_end - m_begin));
            if (curr_size > m_max_size)
                    m_max_size = curr_size;
        }

Dokumentation der Datenelemente

m_allocator

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

TAllocator std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::m_allocator

m_begin

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

T* std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::m_begin

m_capacityEnd

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

T* std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::m_capacityEnd

m_data

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

etype_t std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::m_data[(TCapacity *sizeof(T))/sizeof(etype_t)]

m_end

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

T* std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::m_end

m_max_size

template<typename T, class TAllocator, int TCapacity, bool TGrowOnOverflow>

base_vector::size_type std::fixed_vector_storage< T, TAllocator, TCapacity, TGrowOnOverflow >::m_max_size

---

Die Dokumentation für diese Struktur wurde erzeugt aufgrund der Datei:

• include/fixed_vector.hpp