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

#include <simple_string_storage.hpp>

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

Öffentliche Methoden
	simple_wstring_storage (const allocator_type &allocator)
	simple_wstring_storage (const value_type *str, const allocator_type &allocator)
	simple_wstring_storage (const value_type *str, size_type len, const allocator_type &allocator)
	simple_wstring_storage (const simple_wstring_storage &rhs, const allocator_type &allocator)
	~simple_wstring_storage ()
simple_wstring_storage &	operator= (const simple_wstring_storage &rhs)
void	assign (const value_type *str, size_type len)
void	append (const value_type *str, size_type len)
const value_type *	c_str () const
size_type	length () const
size_type	capacity () const
void	clear ()
const allocator_type &	get_allocator () const
void	make_unique (size_type)
value_type *	get_data ()

Statische öffentliche Attribute
static const unsigned long	kGranularity = 32

Geschützte Methoden
bool	invariant () const

Ausführliche Beschreibung

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

Dokumentation der benutzerdefinierten Datentypen

allocator_type

template<typename E , class TAllocator >

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

const_iterator

template<typename E , class TAllocator >

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

size_type

template<typename E , class TAllocator >

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

value_type

template<typename E , class TAllocator >

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

Beschreibung der Konstruktoren und Destruktoren

simple_wstring_storage() [1/4]

template<typename E , class TAllocator >

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

inlineexplicit

            : m_length(0), m_allocator(allocator)
        {
            m_data = construct_string(0, m_capacity);
        }

simple_wstring_storage() [2/4]

template<typename E , class TAllocator >

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

inline

            : m_allocator(allocator)
        {
            const int len = wcslen(str);
            m_data = construct_string(len, m_capacity);
            Sys::wMemCpy(m_data, str, len*sizeof(value_type));
            m_length = len;
            m_data[len] = 0;
        }

simple_wstring_storage() [3/4]

template<typename E , class TAllocator >

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

inline

            : m_allocator(allocator)
        {
            m_data = construct_string(len, m_capacity);
            Sys::wMemCpy(m_data, str, len*sizeof(value_type));
            m_length = len;
            m_data[len] = 0;
        }

simple_wstring_storage() [4/4]

template<typename E , class TAllocator >

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

inline

            : m_data(0), m_capacity(0), m_length(0), m_allocator(allocator)
        {
            assign(rhs.c_str(), rhs.length());
        }

~simple_wstring_storage()

template<typename E , class TAllocator >

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

inline

        {
            release_string();
        }

Dokumentation der Elementfunktionen

append()

template<typename E , class TAllocator >

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

inline

        {
            const size_type prevLen = length();
            const size_type newLen = prevLen + len;
            if (m_capacity <= newLen + 1)
            {
                    size_type newCapacity;
                    value_type* newData = construct_string(newLen, newCapacity);
                    Sys::wMemCpy(newData, m_data, prevLen * sizeof(value_type));
                    release_string();
                    m_data = newData;
                    m_capacity = newCapacity;
            }
            Sys::wMemCpy(m_data + prevLen, str, len * sizeof(value_type));
            m_data[newLen] = 0;
            m_length = newLen;
            assert(invariant());
        }

assign()

template<typename E , class TAllocator >

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

inline

        {
            //assert(str != m_data);
            if (m_capacity <= len + 1)
            {
                    release_string();
                    m_data = construct_string(len, m_capacity);
            }
            Sys::wMemCpy(m_data, str, len*sizeof(value_type));
            m_length = len;
            m_data[len] = 0;
        }

c_str()

template<typename E , class TAllocator >

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

inline

        {
            return m_data;
        }

capacity()

template<typename E , class TAllocator >

size_type std::simple_wstring_storage< E, TAllocator >::capacity ( ) const

inline

{ return m_capacity; }

clear()

template<typename E , class TAllocator >

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

inline

        {
            release_string();
            m_data = construct_string(0, m_capacity);
            m_length = 0;
        }

get_allocator()

template<typename E , class TAllocator >

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

inline

{ return m_allocator; }

get_data()

template<typename E , class TAllocator >

value_type* std::simple_wstring_storage< E, TAllocator >::get_data ( )

inline

{ return m_data; }

invariant()

template<typename E , class TAllocator >

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

inlineprotected

        {
                assert(m_data);
                assert(m_length <= m_capacity);
                if (length() != 0)
                        assert(m_data[length()] == 0);
                return true;
        }

length()

template<typename E , class TAllocator >

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

inline

        {
            return m_length;
        }

make_unique()

template<typename E , class TAllocator >

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

inline

{}

operator=()

template<typename E , class TAllocator >

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

inline

        {
            if (m_data != rhs.c_str()) 
            {
                    assign(rhs.c_str(), rhs.length());
            }
            return *this;
        }

Dokumentation der Datenelemente

kGranularity

template<typename E , class TAllocator >

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

static

---

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

• include/simple_string_storage.hpp