tinyxml2::StrPair Class Reference

#include <tinyxml2.h>

Collaboration diagram for tinyxml2::StrPair:

Public Types
enum	{   NEEDS_ENTITY_PROCESSING = 0x01 , NEEDS_NEWLINE_NORMALIZATION = 0x02 , NEEDS_WHITESPACE_COLLAPSING = 0x04 , TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION ,   TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION , ATTRIBUTE_NAME = 0 , ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION , ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION ,   COMMENT = NEEDS_NEWLINE_NORMALIZATION }

Public Member Functions
	StrPair ()
	~StrPair ()
void	Set (char *start, char *end, int flags)
const char *	GetStr ()
bool	Empty () const
void	SetInternedStr (const char *str)
void	SetStr (const char *str, int flags=0)
char *	ParseText (char *in, const char *endTag, int strFlags)
char *	ParseName (char *in)
void	TransferTo (StrPair *other)

Private Types
enum	{ NEEDS_FLUSH = 0x100 , NEEDS_DELETE = 0x200 }

Private Member Functions
void	Reset ()
void	CollapseWhitespace ()
	StrPair (const StrPair &other)
void	operator= (StrPair &other)

Private Attributes
int	_flags
char *	_start
char *	_end

Detailed Description

Definition at line 116 of file tinyxml2.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
NEEDS_ENTITY_PROCESSING
NEEDS_NEWLINE_NORMALIZATION
NEEDS_WHITESPACE_COLLAPSING
TEXT_ELEMENT
TEXT_ELEMENT_LEAVE_ENTITIES
ATTRIBUTE_NAME
ATTRIBUTE_VALUE
ATTRIBUTE_VALUE_LEAVE_ENTITIES
COMMENT

Definition at line 119 of file tinyxml2.h.

         {
        NEEDS_ENTITY_PROCESSING         = 0x01,
        NEEDS_NEWLINE_NORMALIZATION     = 0x02,
        NEEDS_WHITESPACE_COLLAPSING     = 0x04,
 
        TEXT_ELEMENT                        = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
        TEXT_ELEMENT_LEAVE_ENTITIES     = NEEDS_NEWLINE_NORMALIZATION,
        ATTRIBUTE_NAME                      = 0,
        ATTRIBUTE_VALUE                     = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
        ATTRIBUTE_VALUE_LEAVE_ENTITIES      = NEEDS_NEWLINE_NORMALIZATION,
        COMMENT                     = NEEDS_NEWLINE_NORMALIZATION
    };

anonymous enum

anonymous enum

private

Enumerator
NEEDS_FLUSH
NEEDS_DELETE

Definition at line 164 of file tinyxml2.h.

         {
        NEEDS_FLUSH = 0x100,
        NEEDS_DELETE = 0x200
    };

Constructor & Destructor Documentation

StrPair() [1/2]

tinyxml2::StrPair::StrPair ( )

inline

Definition at line 132 of file tinyxml2.h.

: _flags( 0 ), _start( 0 ), _end( 0 ) {}

~StrPair()

tinyxml2::StrPair::~StrPair

(

)

Definition at line 138 of file tinyxml2.cpp.

{
    Reset();
}

StrPair() [2/2]

tinyxml2::StrPair::StrPair ( const StrPair &  other )

private

Member Function Documentation

CollapseWhitespace()

void tinyxml2::StrPair::CollapseWhitespace ( )

private

Definition at line 231 of file tinyxml2.cpp.

{
    // Adjusting _start would cause undefined behavior on delete[]
    TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
    // Trim leading space.
    _start = XMLUtil::SkipWhiteSpace( _start );
 
    if ( *_start ) {
        char* p = _start;   // the read pointer
        char* q = _start;   // the write pointer
 
        while( *p ) {
            if ( XMLUtil::IsWhiteSpace( *p )) {
                p = XMLUtil::SkipWhiteSpace( p );
                if ( *p == 0 ) {
                    break;    // don't write to q; this trims the trailing space.
                }
                *q = ' ';
                ++q;
            }
            *q = *p;
            ++q;
            ++p;
        }
        *q = 0;
    }
}

Referenced by GetStr().

Empty()

bool tinyxml2::StrPair::Empty ( ) const

inline

Definition at line 144 of file tinyxml2.h.

                       {
        return _start == _end;
    }

Referenced by tinyxml2::XMLNode::ParseDeep(), and tinyxml2::XMLElement::ParseDeep().

GetStr()

const char * tinyxml2::StrPair::GetStr

(

)

Definition at line 260 of file tinyxml2.cpp.

{
    TIXMLASSERT( _start );
    TIXMLASSERT( _end );
    if ( _flags & NEEDS_FLUSH ) {
        *_end = 0;
        _flags ^= NEEDS_FLUSH;
 
        if ( _flags ) {
            char* p = _start;   // the read pointer
            char* q = _start;   // the write pointer
 
            while( p < _end ) {
                if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
                    // CR-LF pair becomes LF
                    // CR alone becomes LF
                    // LF-CR becomes LF
                    if ( *(p+1) == LF ) {
                        p += 2;
                    }
                    else {
                        ++p;
                    }
                    *q++ = LF;
                }
                else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
                    if ( *(p+1) == CR ) {
                        p += 2;
                    }
                    else {
                        ++p;
                    }
                    *q++ = LF;
                }
                else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
                    // Entities handled by tinyXML2:
                    // - special entities in the entity table [in/out]
                    // - numeric character reference [in]
                    //   &#20013; or &#x4e2d;
 
                    if ( *(p+1) == '#' ) {
                        const int buflen = 10;
                        char buf[buflen] = { 0 };
                        int len = 0;
                        char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
                        if ( adjusted == 0 ) {
                            *q = *p;
                            ++p;
                            ++q;
                        }
                        else {
                            TIXMLASSERT( 0 <= len && len <= buflen );
                            TIXMLASSERT( q + len <= adjusted );
                            p = adjusted;
                            memcpy( q, buf, len );
                            q += len;
                        }
                    }
                    else {
                        bool entityFound = false;
                        for( int i = 0; i < NUM_ENTITIES; ++i ) {
                            const Entity& entity = entities[i];
                            if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
                                    && *( p + entity.length + 1 ) == ';' ) {
                                // Found an entity - convert.
                                *q = entity.value;
                                ++q;
                                p += entity.length + 2;
                                entityFound = true;
                                break;
                            }
                        }
                        if ( !entityFound ) {
                            // fixme: treat as error?
                            ++p;
                            ++q;
                        }
                    }
                }
                else {
                    *q = *p;
                    ++p;
                    ++q;
                }
            }
            *q = 0;
        }
        // The loop below has plenty going on, and this
        // is a less useful mode. Break it out.
        if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
            CollapseWhitespace();
        }
        _flags = (_flags & NEEDS_DELETE);
    }
    TIXMLASSERT( _start );
    return _start;
}

Referenced by tinyxml2::XMLAttribute::Name(), tinyxml2::XMLNode::ParseDeep(), tinyxml2::XMLNode::Value(), and tinyxml2::XMLAttribute::Value().

operator=()

void tinyxml2::StrPair::operator= ( StrPair &  other )

private

ParseName()

char * tinyxml2::StrPair::ParseName

(

char *

in

)

Definition at line 211 of file tinyxml2.cpp.

{
    if ( !p || !(*p) ) {
        return 0;
    }
    if ( !XMLUtil::IsNameStartChar( *p ) ) {
        return 0;
    }
 
    char* const start = p;
    ++p;
    while ( *p && XMLUtil::IsNameChar( *p ) ) {
        ++p;
    }
 
    Set( start, p, 0 );
    return p;
}

Referenced by tinyxml2::XMLAttribute::ParseDeep(), and tinyxml2::XMLElement::ParseDeep().

ParseText()

char * tinyxml2::StrPair::ParseText	(	char *	in,
		const char *	endTag,
		int	strFlags
	)

Definition at line 191 of file tinyxml2.cpp.

{
    TIXMLASSERT( endTag && *endTag );
 
    char* start = p;
    char  endChar = *endTag;
    size_t length = strlen( endTag );
 
    // Inner loop of text parsing.
    while ( *p ) {
        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
            Set( start, p, strFlags );
            return p + length;
        }
        ++p;
    }
    return 0;
}

Referenced by tinyxml2::XMLText::ParseDeep(), tinyxml2::XMLComment::ParseDeep(), tinyxml2::XMLDeclaration::ParseDeep(), tinyxml2::XMLUnknown::ParseDeep(), and tinyxml2::XMLAttribute::ParseDeep().

Reset()

void tinyxml2::StrPair::Reset ( )

private

Definition at line 167 of file tinyxml2.cpp.

{
    if ( _flags & NEEDS_DELETE ) {
        delete [] _start;
    }
    _flags = 0;
    _start = 0;
    _end = 0;
}

Referenced by Set(), SetInternedStr(), SetStr(), and ~StrPair().

Set()

void tinyxml2::StrPair::Set ( char *  start, char *  end, int  flags  )

inline

Definition at line 135 of file tinyxml2.h.

                                                  {
        Reset();
        _start  = start;
        _end    = end;
        _flags  = flags | NEEDS_FLUSH;
    }

SetInternedStr()

void tinyxml2::StrPair::SetInternedStr ( const char *  str )

inline

Definition at line 148 of file tinyxml2.h.

                                           {
        Reset();
        _start = const_cast<char*>(str);
    }

Referenced by tinyxml2::XMLNode::SetValue().

SetStr()

void tinyxml2::StrPair::SetStr	(	const char *	str,
		int	flags = 0
	)

Definition at line 178 of file tinyxml2.cpp.

{
    TIXMLASSERT( str );
    Reset();
    size_t len = strlen( str );
    TIXMLASSERT( _start == 0 );
    _start = new char[ len+1 ];
    memcpy( _start, str, len+1 );
    _end = _start + len;
    _flags = flags | NEEDS_DELETE;
}

Referenced by tinyxml2::XMLAttribute::SetAttribute(), tinyxml2::XMLAttribute::SetName(), and tinyxml2::XMLNode::SetValue().

TransferTo()

void tinyxml2::StrPair::TransferTo

(

StrPair *

other

)

Definition at line 144 of file tinyxml2.cpp.

{
    if ( this == other ) {
        return;
    }
    // This in effect implements the assignment operator by "moving"
    // ownership (as in auto_ptr).
 
    TIXMLASSERT( other->_flags == 0 );
    TIXMLASSERT( other->_start == 0 );
    TIXMLASSERT( other->_end == 0 );
 
    other->Reset();
 
    other->_flags = _flags;
    other->_start = _start;
    other->_end = _end;
 
    _flags = 0;
    _start = 0;
    _end = 0;
}

Referenced by tinyxml2::XMLNode::ParseDeep().

Member Data Documentation

_end

char* tinyxml2::StrPair::_end

private

Definition at line 171 of file tinyxml2.h.

Referenced by Empty(), GetStr(), Reset(), Set(), SetStr(), and TransferTo().

_flags

int tinyxml2::StrPair::_flags

private

Definition at line 169 of file tinyxml2.h.

Referenced by CollapseWhitespace(), GetStr(), Reset(), Set(), SetStr(), and TransferTo().

_start

char* tinyxml2::StrPair::_start

private

Definition at line 170 of file tinyxml2.h.

Referenced by CollapseWhitespace(), Empty(), GetStr(), Reset(), Set(), SetInternedStr(), SetStr(), and TransferTo().

---

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

• sdk/tools/xml2sdb/tinyxml2.h
• sdk/tools/xml2sdb/tinyxml2.cpp