std::cow_string_storage< E, TAllocator > Template-Klassenreferenz

#include <cow_string_storage.hpp>

Öffentliche Typen
using	value_type = E
using	size_type = int
using	allocator_type = TAllocator
using	const_iterator = value_type *

Öffentliche Methoden
	cow_string_storage (const allocator_type &allocator)
	cow_string_storage (const value_type *str, const allocator_type &allocator)
	cow_string_storage (const value_type *str, size_type len, const allocator_type &allocator)
	ow_string_storage (size_type len, const allocator_type &allocator)
	cow_string_storage (const cow_string_storage &rhs, const allocator_type &allocator)
	~cow_string_storage ()
cow_string_storage &	operator= (const cow_string_storage &rhs)
void	assign (const value_type *str, size_type len)
void	resize (size_type len)
void	append (const value_type *str, size_type len)
const value_type *	c_str () const
size_type	length () const
const allocator_type &	get_allocator () const
value_type *	reserve (size_type capacity_hint)
void	clear ()
void	resize (size_type size)

Statische öffentliche Attribute
static const unsigned long	kGranularity = 32

Geschützte Methoden
bool	invariant () const
void	make_unique (size_type capacity_hint)
E *	get_data ()

Ausführliche Beschreibung

template<typename E, class TAllocator>
class std::cow_string_storage< E, TAllocator >

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<typename E , class TAllocator >

using std::cow_string_storage< E, TAllocator >::allocator_type = TAllocator

const_iterator

template<typename E , class TAllocator >

using std::cow_string_storage< E, TAllocator >::const_iterator = value_type*

size_type

template<typename E , class TAllocator >

using std::cow_string_storage< E, TAllocator >::size_type = int

value_type

template<typename E , class TAllocator >

using std::cow_string_storage< E, TAllocator >::value_type = E

Beschreibung der Konstruktoren und Destruktoren

cow_string_storage() [1/4]

template<typename E , class TAllocator >

std::cow_string_storage< E, TAllocator >::cow_string_storage ( const allocator_type &  allocator )

inlineexplicit

                : m_allocator(allocator)
            {
                    construct_string(0);
            }

cow_string_storage() [2/4]

template<typename E , class TAllocator >

std::cow_string_storage< E, TAllocator >::cow_string_storage ( const value_type *  str, const allocator_type &  allocator  )

inline

                :  m_allocator(allocator)
            {
                    const int len = strlen(str);
                    construct_string(len);
                    Sys::MemCpy(m_data, str, len*sizeof(value_type));
                    assert(len < string_rep::kMaxCapacity);
                    get_rep()->size = static_cast<short>(len);
                    m_data[len] = 0;
            }

cow_string_storage() [3/4]

template<typename E , class TAllocator >

std::cow_string_storage< E, TAllocator >::cow_string_storage ( const value_type *  str, size_type  len, const allocator_type &  allocator  )

inline

                : m_allocator(allocator)
            {
                    construct_string(len);
                    Sys::MemCpy(m_data, str, len*sizeof(value_type));
                    assert(len < string_rep::kMaxCapacity);
                    get_rep()->size = static_cast<short>(len);
                    m_data[len] = 0;
            }

cow_string_storage() [4/4]

template<typename E , class TAllocator >

std::cow_string_storage< E, TAllocator >::cow_string_storage ( const cow_string_storage< E, TAllocator > &  rhs, const allocator_type &  allocator  )

inline

                : m_data(rhs.m_data), m_allocator(allocator)
            {
                    if (rhs.is_dynamic())
                    {
                            get_rep()->add_ref();
                    }
                    else
                    {
                            const int len = rhs.length();
                            construct_string(len);
                            Sys::MemCpy(m_data, rhs.c_str(), len*sizeof(value_type));
                            assert(len < string_rep::kMaxCapacity);
                            get_rep()->size = static_cast<short>(len);
                            m_data[len] = 0;
                    }
            }

~cow_string_storage()

template<typename E , class TAllocator >

std::cow_string_storage< E, TAllocator >::~cow_string_storage ( )

inline

            {
                    if (!is_dynamic())
                            RDE_ASSERT(get_rep()->refs == 1);
                    release_string();
            }

Dokumentation der Elementfunktionen

append()

template<typename E , class TAllocator >

void std::cow_string_storage< E, TAllocator >::append ( const value_type *  str, size_type  len  )

inline

            {
                    const size_type prevLen = length();
                    const size_type newCapacity = prevLen + len;
                    make_unique(newCapacity);
                    string_rep* rep = get_rep();
                    assert(rep->capacity >= short(newCapacity));
                    const size_type newLen = prevLen + len;
                    assert(short(newLen) <= rep->capacity);
                    Sys::MemCpy(m_data + prevLen, str, len * sizeof(value_type));
                    m_data[newLen] = 0;
                    rep->size = short(newLen);
            }

assign()

template<typename E , class TAllocator >

void std::cow_string_storage< E, TAllocator >::assign ( const value_type *  str, size_type  len  )

inline

            {
                    assert(str != m_data);
                    release_string();
                    construct_string(len);
                    Sys::MemCpy(m_data, str, len*sizeof(value_type));
                    get_rep()->size = short(len);
                    m_data[len] = 0;
            }

c_str()

template<typename E , class TAllocator >

const value_type* std::cow_string_storage< E, TAllocator >::c_str ( ) const

inline

            {
                    return m_data;
            }

clear()

template<typename E , class TAllocator >

void std::cow_string_storage< E, TAllocator >::clear ( )

inline

            {
                    resize(0);
            }

get_allocator()

template<typename E , class TAllocator >

const allocator_type& std::cow_string_storage< E, TAllocator >::get_allocator ( ) const

inline

{ return m_allocator; }

get_data()

template<typename E , class TAllocator >

E* std::cow_string_storage< E, TAllocator >::get_data ( )

inlineprotected

{ return m_data; }

invariant()

template<typename E , class TAllocator >

bool std::cow_string_storage< E, TAllocator >::invariant ( ) const

inlineprotected

            {
                    assert(m_data);
                    string_rep* rep = get_rep();
                    assert(rep->refs >= 1);
                    assert(rep->size <= rep->capacity);
                    if (length() != 0)
                            assert(m_data[length()] == 0);
                    return true;
            }

length()

template<typename E , class TAllocator >

size_type std::cow_string_storage< E, TAllocator >::length ( ) const

inline

            {
                    return get_rep()->size;
            }

make_unique()

template<typename E , class TAllocator >

void std::cow_string_storage< E, TAllocator >::make_unique ( size_type  capacity_hint )

inlineprotected

            {
                    string_rep* rep = get_rep();
                    assert(rep->refs >= 1);

                    if (capacity_hint != 0)
                    {
                            ++capacity_hint;
                            capacity_hint = (capacity_hint+kGranularity-1) & ~(kGranularity-1);
                            if (capacity_hint < kGranularity)
                                    capacity_hint = kGranularity;
                    }
                    assert(capacity_hint < string_rep::kMaxCapacity);
                    // Reallocate string only if we truly need to make it unique
                    // (it's shared) or if our current buffer is too small.
                    if (rep->refs > 1 || short(capacity_hint) > rep->capacity)
                    {
                            if (capacity_hint > 0)
                            {
                                    const size_type toAlloc = sizeof(string_rep) + sizeof(value_type)*capacity_hint;
                                    void* newMem = m_allocator.allocate(toAlloc);
                                    string_rep* newRep = reinterpret_cast<string_rep*>(newMem);
                                    newRep->init(short(capacity_hint));
                                    value_type* newData = reinterpret_cast<value_type*>(newRep + 1);
                                    Sys::MemCpy(newData, m_data, rep->size*sizeof(value_type));
                                    newRep->size = rep->size;
                                    newData[rep->size] = 0;
                                    release_string();
                                    m_data = newData;
                            }
                            else
                            {
                                    release_string();
                                    string_rep* rep = reinterpret_cast<string_rep*>(m_buffer);
                                    rep->init();
                                    m_data = reinterpret_cast<value_type*>(rep + 1);
                                    *m_data = 0;
                            }
                    }
            }

operator=()

template<typename E , class TAllocator >

cow_string_storage& std::cow_string_storage< E, TAllocator >::operator= ( const cow_string_storage< E, TAllocator > &  rhs )

inline

            {
                    if (m_data != rhs.m_data)
                    {
                            release_string();
                            m_data = rhs.m_data;
                            get_rep()->add_ref();
                    }
                    return *this;
            }

ow_string_storage()

template<typename E , class TAllocator >

std::cow_string_storage< E, TAllocator >::ow_string_storage ( size_type  len, const allocator_type &  allocator  )

inline

                : m_allocator(allocator)
            {
                    construct_string(len);
                    assert(len < string_rep::kMaxCapacity);
                    get_rep()->size = static_cast<short>(len);
                    m_data[len] = 0;
            }

reserve()

template<typename E , class TAllocator >

value_type* std::cow_string_storage< E, TAllocator >::reserve ( size_type  capacity_hint )

inline

            {
                    make_unique(capacity_hint);
                    return m_data;
            }

resize() [1/2]

template<typename E , class TAllocator >

void std::cow_string_storage< E, TAllocator >::resize ( size_type  len )

inline

            {
                    const size_type prevLen = length();
                    const size_type newCapacity = len;
                    make_unique(newCapacity);
                    string_rep* rep = get_rep();
                    assert(rep->capacity >= short(newCapacity));
                    const size_type newLen = prevLen + len;
                    assert(short(newLen) <= rep->capacity);
                    m_data[newLen] = 0;
                    rep->size = short(newLen);
            }

resize() [2/2]

template<typename E , class TAllocator >

void std::cow_string_storage< E, TAllocator >::resize ( size_type  size )

inline

            {
                    string_rep* rep = get_rep();
                    make_unique(size);
                    rep->size = (short)size;
                    m_data[size] = 0;
            }

Dokumentation der Datenelemente

kGranularity

template<typename E , class TAllocator >

const unsigned long std::cow_string_storage< E, TAllocator >::kGranularity = 32

static

---

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

• include/cow_string_storage.hpp