TiXmlString Class Reference

#include <tinystr.h>

Inheritance diagram for TiXmlString:

Collaboration diagram for TiXmlString:

Classes
struct	Rep

Public Types
typedef size_t	size_type

Public Member Functions
TiXmlString &	append (const char *str, size_type len)
TiXmlString &	assign (const char *str, size_type len)
const char &	at (size_type index) const
const char *	c_str () const
size_type	capacity () const
void	clear ()
const char *	data () const
bool	empty () const
size_type	find (char lookup) const
size_type	find (char tofind, size_type offset) const
size_type	length () const
TiXmlString &	operator+= (char single)
TiXmlString &	operator+= (const char *suffix)
TiXmlString &	operator+= (const TiXmlString &suffix)
TiXmlString &	operator= (const char *copy)
TiXmlString &	operator= (const TiXmlString &copy)
char &	operator[] (size_type index) const
void	reserve (size_type cap)
size_type	size () const
void	swap (TiXmlString &other)
	TiXmlString ()
TIXML_EXPLICIT	TiXmlString (const char *copy)
TIXML_EXPLICIT	TiXmlString (const char *str, size_type len)
	TiXmlString (const TiXmlString &copy)
	~TiXmlString ()

Static Public Attributes
static const size_type	npos = static_cast< TiXmlString::size_type >(-1)

Private Member Functions
char *	finish () const
void	init (size_type sz)
void	init (size_type sz, size_type cap)
void	quit ()
void	set_size (size_type sz)
char *	start () const

Private Attributes
Rep *	rep_

Static Private Attributes
static Rep	nullrep_ = { 0, 0, { '\0' } }

Member Typedef Documentation

size_type

typedef size_t TiXmlString::size_type

Constructor & Destructor Documentation

TiXmlString() [1/4]

TiXmlString::TiXmlString ( )

inline

                   : rep_(&nullrep_)
    {
    }

TiXmlString() [2/4]

TiXmlString::TiXmlString ( const TiXmlString &  copy )

inline

                                            : rep_(0)
    {
        init(copy.length());
        memcpy(start(), copy.data(), length());
    }

TiXmlString() [3/4]

TIXML_EXPLICIT TiXmlString::TiXmlString ( const char *  copy )

inline

                                                    : rep_(0)
    {
        init( static_cast<size_type>( strlen(copy) ));
        memcpy(start(), copy, length());
    }

TiXmlString() [4/4]

TIXML_EXPLICIT TiXmlString::TiXmlString ( const char *  str, size_type  len  )

inline

                                                                  : rep_(0)
    {
        init(len);
        memcpy(start(), str, len);
    }

~TiXmlString()

TiXmlString::~TiXmlString ( )

inline

    {
        quit();
    }

Member Function Documentation

append()

TiXmlString & TiXmlString::append	(	const char *	str,
		size_type	len
	)

{
    size_type newsize = length() + len;
    if (newsize > capacity())
    {
        reserve (newsize + capacity());
    }
    memmove(finish(), str, len);
    set_size(newsize);
    return *this;
}

assign()

TiXmlString & TiXmlString::assign	(	const char *	str,
		size_type	len
	)

{
    size_type cap = capacity();
    if (len > cap || cap > 3*(len + 8))
    {
        TiXmlString tmp;
        tmp.init(len);
        memcpy(tmp.start(), str, len);
        swap(tmp);
    }
    else
    {
        memmove(start(), str, len);
        set_size(len);
    }
    return *this;
}

at()

const char& TiXmlString::at ( size_type  index ) const

inline

    {
        assert( index < length() );
        return rep_->str[ index ];
    }

c_str()

const char* TiXmlString::c_str ( ) const

inline

{ return rep_->str; }

capacity()

size_type TiXmlString::capacity ( ) const

inline

{ return rep_->capacity; }

clear()

void TiXmlString::clear ( )

inline

    {
        //Lee:
        //The original was just too strange, though correct:
        //  TiXmlString().swap(*this);
        //Instead use the quit & re-init:
        quit();
        init(0,0);
    }

data()

const char* TiXmlString::data ( ) const

inline

{ return rep_->str; }

empty()

bool TiXmlString::empty ( ) const

inline

{ return rep_->size == 0; }

find() [1/2]

size_type TiXmlString::find ( char  lookup ) const

inline

    {
        return find(lookup, 0);
    }

find() [2/2]

size_type TiXmlString::find ( char  tofind, size_type  offset  ) const

inline

    {
        if (offset >= length()) return npos;
 
        for (const char* p = c_str() + offset; *p != '\0'; ++p)
        {
           if (*p == tofind) return static_cast< size_type >( p - c_str() );
        }
        return npos;
    }

finish()

char* TiXmlString::finish ( ) const

inlineprivate

{ return rep_->str + rep_->size; }

init() [1/2]

void TiXmlString::init ( size_type  sz )

inlineprivate

{ init(sz, sz); }

init() [2/2]

void TiXmlString::init ( size_type  sz, size_type  cap  )

inlineprivate

    {
        if (cap)
        {
            // Lee: the original form:
            //  rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
            // doesn't work in some cases of new being overloaded. Switching
            // to the normal allocation, although use an 'int' for systems
            // that are overly picky about structure alignment.
            const size_type bytesNeeded = sizeof(Rep) + cap;
            const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
            rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
 
            rep_->str[ rep_->size = sz ] = '\0';
            rep_->capacity = cap;
        }
        else
        {
            rep_ = &nullrep_;
        }
    }

length()

size_type TiXmlString::length ( ) const

inline

{ return rep_->size; }

operator+=() [1/3]

TiXmlString& TiXmlString::operator+= ( char  single )

inline

    {
        return append(&single, 1);
    }

operator+=() [2/3]

TiXmlString& TiXmlString::operator+= ( const char *  suffix )

inline

    {
        return append(suffix, static_cast<size_type>( strlen(suffix) ));
    }

operator+=() [3/3]

TiXmlString& TiXmlString::operator+= ( const TiXmlString &  suffix )

inline

    {
        return append(suffix.data(), suffix.length());
    }

operator=() [1/2]

TiXmlString& TiXmlString::operator= ( const char *  copy )

inline

    {
        return assign( copy, (size_type)strlen(copy));
    }

operator=() [2/2]

TiXmlString& TiXmlString::operator= ( const TiXmlString &  copy )

inline

    {
        return assign(copy.start(), copy.length());
    }

operator[]()

char& TiXmlString::operator[] ( size_type  index ) const

inline

    {
        assert( index < length() );
        return rep_->str[ index ];
    }

quit()

void TiXmlString::quit ( )

inlineprivate

    {
        if (rep_ != &nullrep_)
        {
            // The rep_ is really an array of ints. (see the allocator, above).
            // Cast it back before delete, so the compiler won't incorrectly call destructors.
            delete [] ( reinterpret_cast<int*>( rep_ ) );
        }
    }

reserve()

void TiXmlString::reserve

(

size_type

cap

)

{
    if (cap > capacity())
    {
        TiXmlString tmp;
        tmp.init(length(), cap);
        memcpy(tmp.start(), data(), length());
        swap(tmp);
    }
}

set_size()

void TiXmlString::set_size ( size_type  sz )

inlineprivate

{ rep_->str[ rep_->size = sz ] = '\0'; }

size()

size_type TiXmlString::size ( ) const

inline

{ return rep_->size; }

start()

char* TiXmlString::start ( ) const

inlineprivate

{ return rep_->str; }

swap()

void TiXmlString::swap ( TiXmlString &  other )

inline

    {
        Rep* r = rep_;
        rep_ = other.rep_;
        other.rep_ = r;
    }

Member Data Documentation

npos

const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1)

static

nullrep_

TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } }

staticprivate

rep_

Rep* TiXmlString::rep_

private

---

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

• src/libScan/tinystr.h
• src/libScan/tinystr.cpp