tinyxmla.cpp

文字編輯器源碼 Text editor source code

	return clone;
}


TiXmlDocumentA::TiXmlDocumentA() : TiXmlNodeA( TiXmlNodeA::DOCUMENT )
{
	tabsize = 4;
	ClearError();
}

TiXmlDocumentA::TiXmlDocumentA( const char * documentName ) : TiXmlNodeA( TiXmlNodeA::DOCUMENT )
{
	tabsize = 4;
	value = documentName;
	ClearError();
}

bool TiXmlDocumentA::LoadFile()
{
	// See STL_STRING_BUG below.
	StringToBuffer buf( value );

	if ( buf.buffer && LoadFile( buf.buffer ) )
		return true;

	return false;
}


bool TiXmlDocumentA::SaveFile() const
{
	// See STL_STRING_BUG below.
	StringToBuffer buf( value );

	if ( buf.buffer && SaveFile( buf.buffer ) )
		return true;

	return false;
}

bool TiXmlDocumentA::LoadFile( const char* filename )
{
	// Delete the existing data:
	Clear();
	location.Clear();

	// There was a really terrifying little bug here. The code:
	//		value = filename
	// in the STL case, cause the assignment method of the std::string to
	// be called. What is strange, is that the std::string had the same
	// address as it's c_str() method, and so bad things happen. Looks
	// like a bug in the Microsoft STL implementation.
	// See STL_STRING_BUG above.
	// Fixed with the StringToBuffer class.
	value = filename;

	FILE* file = fopen( value.c_str (), "r" );

	if ( file )
	{
		// Get the file size, so we can pre-allocate the string. HUGE speed impact.
		long length = 0;
		fseek( file, 0, SEEK_END );
		length = ftell( file );
		fseek( file, 0, SEEK_SET );

		// Strange case, but good to handle up front.
		if ( length == 0 )
		{
			fclose( file );
			return false;
		}

		// If we have a file, assume it is all one big XML file, and read it in.
		// The document parser may decide the document ends sooner than the entire file, however.
		TIXMLA_STRING data;
		data.reserve( length );

		const int BUF_SIZE = 2048;
		char buf[BUF_SIZE];

		while( fgets( buf, BUF_SIZE, file ) )
		{
			data += buf;
		}
		fclose( file );

		Parse( data.c_str(), 0 );

		if (  Error() )
            return false;
        else
			return true;
	}
	SetError( TIXMLA_ERROR_OPENING_FILE, 0, 0 );
	return false;
}

bool TiXmlDocumentA::LoadUnicodeFilePath( const TCHAR* filename )
{
	
	// Delete the existing data:
	Clear();
	location.Clear();

	// There was a really terrifying little bug here. The code:
	//		value = filename
	// in the STL case, cause the assignment method of the std::generic_string to
	// be called. What is strange, is that the std::generic_string had the same
	// address as it's c_str() method, and so bad things happen. Looks
	// like a bug in the Microsoft STL implementation.
	// See STL_STRING_BUG above.
	// Fixed with the StringToBuffer class.

	FILE* file = generic_fopen(filename, TEXT("r"));

	if ( file )
	{
		// Get the file size, so we can pre-allocate the generic_string. HUGE speed impact.
		long length = 0;
		fseek( file, 0, SEEK_END );
		length = ftell( file );
		fseek( file, 0, SEEK_SET );

		// Strange case, but good to handle up front.
		if ( length == 0 )
		{
			fclose( file );
			return false;
		}

		// If we have a file, assume it is all one big XML file, and read it in.
		// The document parser may decide the document ends sooner than the entire file, however.
		TIXMLA_STRING data;
		data.reserve( length );

		const int BUF_SIZE = 2048;
		char buf[BUF_SIZE];

		while( fgets( buf, BUF_SIZE, file ) )
		{
			data += buf;
		}
		fclose( file );

		Parse( data.c_str(), 0 );

		if (  Error() )
            return false;
        else
			return true;
	}
	SetError( TIXMLA_ERROR_OPENING_FILE, 0, 0 );
	return false;
}

bool TiXmlDocumentA::SaveFile( const char * filename ) const
{
	// The old c stuff lives on...
	FILE* fp = fopen( filename, "w" );
	if ( fp )
	{
		Print( fp, 0 );
		fclose( fp );
		return true;
	}
	return false;
}


TiXmlNodeA* TiXmlDocumentA::Clone() const
{
	TiXmlDocumentA* clone = new TiXmlDocumentA();
	if ( !clone )
		return 0;

	CopyToClone( clone );
	clone->error = error;
	clone->errorDesc = errorDesc.c_str ();

	TiXmlNodeA* node = 0;
	for ( node = firstChild; node; node = node->NextSibling() )
	{
		clone->LinkEndChild( node->Clone() );
	}
	return clone;
}


void TiXmlDocumentA::Print( FILE* cfile, int depth ) const
{
	TiXmlNodeA* node;
	for ( node=FirstChild(); node; node=node->NextSibling() )
	{
		node->Print( cfile, depth );
		fprintf( cfile, "\n" );
	}
}

void TiXmlDocumentA::StreamOut( TIXMLA_OSTREAM * out ) const
{
	TiXmlNodeA* node;
	for ( node=FirstChild(); node; node=node->NextSibling() )
	{
		node->StreamOut( out );

		// Special rule for streams: stop after the root element.
		// The stream in code will only read one element, so don't
		// write more than one.
		if ( node->ToElement() )
			break;
	}
}


TiXmlAttributeA* TiXmlAttributeA::Next() const
{
	// We are using knowledge of the sentinel. The sentinel
	// have a value or name.
	if ( next->value.empty() && next->name.empty() )
		return 0;
	return next;
}


TiXmlAttributeA* TiXmlAttributeA::Previous() const
{
	// We are using knowledge of the sentinel. The sentinel
	// have a value or name.
	if ( prev->value.empty() && prev->name.empty() )
		return 0;
	return prev;
}


void TiXmlAttributeA::Print( FILE* cfile, int /*depth*/ ) const
{
	TIXMLA_STRING n, v;

	PutString( Name(), &n );
	PutString( Value(), &v );

	if (value.find ('\"') == TIXMLA_STRING::npos)
		fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
	else
		fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
}


void TiXmlAttributeA::StreamOut( TIXMLA_OSTREAM * stream ) const
{
	if (value.find( '\"' ) != TIXMLA_STRING::npos)
	{
		PutString( name, stream );
		(*stream) << "=" << "'";
		PutString( value, stream );
		(*stream) << "'";
	}
	else
	{
		PutString( name, stream );
		(*stream) << "=" << "\"";
		PutString( value, stream );
		(*stream) << "\"";
	}
}

int TiXmlAttributeA::QueryIntValue( int* ival ) const
{
	if ( sscanf( value.c_str(), "%d", ival ) == 1 )
		return TIXMLA_SUCCESS;
	return TIXMLA_WRONG_TYPE;
}

int TiXmlAttributeA::QueryDoubleValue( double* dval ) const
{
	if ( sscanf( value.c_str(), "%lf", dval ) == 1 )
		return TIXMLA_SUCCESS;
	return TIXMLA_WRONG_TYPE;
}

void TiXmlAttributeA::SetIntValue( int _value )
{
	char buf [64];
	sprintf (buf, "%d", _value);
	SetValue (buf);
}

void TiXmlAttributeA::SetDoubleValue( double _value )
{
	char buf [64];
	sprintf (buf, "%lf", _value);
	SetValue (buf);
}

const int TiXmlAttributeA::IntValue() const
{
	return atoi (value.c_str ());
}

const double  TiXmlAttributeA::DoubleValue() const
{
	return atof (value.c_str ());
}

void TiXmlCommentA::Print( FILE* cfile, int depth ) const
{
	for ( int i=0; i<depth; i++ )
	{
		fputs( "    ", cfile );
	}
	fprintf( cfile, "<!--%s-->", value.c_str() );
}

void TiXmlCommentA::StreamOut( TIXMLA_OSTREAM * stream ) const
{
	(*stream) << "<!--";
	PutString( value, stream );
	(*stream) << "-->";
}

TiXmlNodeA* TiXmlCommentA::Clone() const
{
	TiXmlCommentA* clone = new TiXmlCommentA();

	if ( !clone )
		return 0;

	CopyToClone( clone );
	return clone;
}


void TiXmlTextA::Print( FILE* cfile, int /*depth*/ ) const
{
	TIXMLA_STRING buffer;
	PutString( value, &buffer );
	fprintf( cfile, "%s", buffer.c_str() );
}


void TiXmlTextA::StreamOut( TIXMLA_OSTREAM * stream ) const
{
	PutString( value, stream );
}


TiXmlNodeA* TiXmlTextA::Clone() const
{	
	TiXmlTextA* clone = 0;
	clone = new TiXmlTextA( "" );

	if ( !clone )
		return 0;

	CopyToClone( clone );
	return clone;
}


TiXmlDeclarationA::TiXmlDeclarationA( const char * _version,
	const char * _encoding,
	const char * _standalone )
: TiXmlNodeA( TiXmlNodeA::DECLARATION )
{
	version = _version;
	encoding = _encoding;
	standalone = _standalone;
}


void TiXmlDeclarationA::Print( FILE* cfile, int /*depth*/ ) const
{
	fprintf (cfile, "<?xml ");

	if ( !version.empty() )
		fprintf (cfile, "version=\"%s\" ", version.c_str ());
	if ( !encoding.empty() )
		fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ());
	if ( !standalone.empty() )
		fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ());
	fprintf (cfile, "?>");
}

void TiXmlDeclarationA::StreamOut( TIXMLA_OSTREAM * stream ) const
{
	(*stream) << "<?xml ";

	if ( !version.empty() )
	{
		(*stream) << "version=\"";
		PutString( version, stream );
		(*stream) << "\" ";
	}
	if ( !encoding.empty() )
	{
		(*stream) << "encoding=\"";
		PutString( encoding, stream );
		(*stream ) << "\" ";
	}
	if ( !standalone.empty() )
	{
		(*stream) << "standalone=\"";
		PutString( standalone, stream );
		(*stream) << "\" ";
	}
	(*stream) << "?>";
}

TiXmlNodeA* TiXmlDeclarationA::Clone() const
{	
	TiXmlDeclarationA* clone = new TiXmlDeclarationA();

	if ( !clone )
		return 0;

	CopyToClone( clone );
	clone->version = version;
	clone->encoding = encoding;
	clone->standalone = standalone;
	return clone;
}


void TiXmlUnknownA::Print( FILE* cfile, int depth ) const
{
	for ( int i=0; i<depth; i++ )
		fprintf( cfile, "    " );
	fprintf( cfile, "%s", value.c_str() );
}

void TiXmlUnknownA::StreamOut( TIXMLA_OSTREAM * stream ) const
{
	(*stream) << "<" << value << ">";		// Don't use entities hear! It is unknown.
}

TiXmlNodeA* TiXmlUnknownA::Clone() const
{
	TiXmlUnknownA* clone = new TiXmlUnknownA();

	if ( !clone )
		return 0;

	CopyToClone( clone );
	return clone;
}


TiXmlAttributeSetA::TiXmlAttributeSetA()
{
	sentinel.next = &sentinel;
	sentinel.prev = &sentinel;
}


TiXmlAttributeSetA::~TiXmlAttributeSetA()
{
	assert( sentinel.next == &sentinel );
	assert( sentinel.prev == &sentinel );
}


void TiXmlAttributeSetA::Add( TiXmlAttributeA* addMe )
{
	assert( !Find( addMe->Name() ) );	// Shouldn't be multiply adding to the set.

	addMe->next = &sentinel;
	addMe->prev = sentinel.prev;

	sentinel.prev->next = addMe;
	sentinel.prev      = addMe;
}

void TiXmlAttributeSetA::Remove( TiXmlAttributeA* removeMe )
{
	TiXmlAttributeA* node;

	for( node = sentinel.next; node != &sentinel; node = node->next )
	{
		if ( node == removeMe )
		{
			node->prev->next = node->next;
			node->next->prev = node->prev;
			node->next = 0;
			node->prev = 0;
			return;
		}
	}
	assert( 0 );		// we tried to remove a non-linked attribute.
}

TiXmlAttributeA*	TiXmlAttributeSetA::Find( const char * name ) const
{
	TiXmlAttributeA* node;

	for( node = sentinel.next; node != &sentinel; node = node->next )
	{
		if ( node->name == name )
			return node;
	}
	return 0;
}


#ifdef TIXMLA_USE_STL	
TIXMLA_ISTREAM & operator >> (TIXMLA_ISTREAM & in, TiXmlNodeA & base)
{
	TIXMLA_STRING tag;
	tag.reserve( 8 * 1000 );
	base.StreamIn( &in, &tag );

	base.Parse( tag.c_str(), 0 );
	return in;
}
#endif


TIXMLA_OSTREAM & operator<< (TIXMLA_OSTREAM & out, const TiXmlNodeA & base)
{
	base.StreamOut (& out);
	return out;
}


#ifdef TIXMLA_USE_STL	
std::string & operator<< (std::string& out, const TiXmlNodeA& base )
{
   std::ostringstream os_stream( std::ostringstream::out );
   base.StreamOut( &os_stream );
   
   out.append( os_stream.str() );
   return out;
}
#endif


TiXmlHandleA TiXmlHandleA::FirstChild() const
{
	if ( node )
	{
		TiXmlNodeA* child = node->FirstChild();
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}


TiXmlHandleA TiXmlHandleA::FirstChild( const char * value ) const
{
	if ( node )
	{
		TiXmlNodeA* child = node->FirstChild( value );
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}


TiXmlHandleA TiXmlHandleA::FirstChildElement() const
{
	if ( node )
	{
		TiXmlElementA* child = node->FirstChildElement();
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}


TiXmlHandleA TiXmlHandleA::FirstChildElement( const char * value ) const
{
	if ( node )
	{
		TiXmlElementA* child = node->FirstChildElement( value );
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}

TiXmlHandleA TiXmlHandleA::Child( int count ) const
{
	if ( node )
	{
		int i;
		TiXmlNodeA* child = node->FirstChild();
		for (	i=0;
				child && i<count;
				child = child->NextSibling(), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}


TiXmlHandleA TiXmlHandleA::Child( const char* value, int count ) const
{
	if ( node )
	{
		int i;
		TiXmlNodeA* child = node->FirstChild( value );
		for (	i=0;
				child && i<count;
				child = child->NextSibling( value ), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}


TiXmlHandleA TiXmlHandleA::ChildElement( int count ) const
{
	if ( node )
	{
		int i;
		TiXmlElementA* child = node->FirstChildElement();
		for (	i=0;
				child && i<count;
				child = child->NextSiblingElement(), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}


TiXmlHandleA TiXmlHandleA::ChildElement( const char* value, int count ) const
{
	if ( node )
	{
		int i;
		TiXmlElementA* child = node->FirstChildElement( value );
		for (	i=0;
				child && i<count;
				child = child->NextSiblingElement( value ), ++i )
		{
			// nothing
		}
		if ( child )
			return TiXmlHandleA( child );
	}
	return TiXmlHandleA( 0 );
}