/*
www.sourceforge.net/projects/tinyxml
Original file by Yves Berquin.

This software is provided 'as-is', without any express or implied 
warranty. In no event will the authors be held liable for any 
damages arising from the use of this software.

Permission is granted to anyone to use this software for any 
purpose, including commercial applications, and to alter it and 
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must 
not claim that you wrote the original software. If you use this 
software in a product, an acknowledgment in the product documentation 
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source 
distribution.
*/

#include "tinyxml.h"


#ifndef vsxTiXml_USE_STL

#ifndef vsxTiXml_STRING_INCLUDED
#define vsxTiXml_STRING_INCLUDED

#pragma warning( disable : 4514 )

#include "cal3d/platform.h"

#include <assert.h>

/*
   vsxTiXmlString is an emulation of the std::string template.
   Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
   Only the member functions relevant to the TinyXML project have been implemented.
   The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
   a string and there's no more room, we allocate a buffer twice as big as we need.
*/
class vsxTiXmlString
{
  public :
    // vsxTiXmlString constructor, based on a string
    vsxTiXmlString (const char * instring);

    // vsxTiXmlString empty constructor
    vsxTiXmlString ()
    {
        allocated = 0;
        cstring = NULL;
        current_length = 0;
    }

    // vsxTiXmlString copy constructor
    vsxTiXmlString (const vsxTiXmlString& copy);

    // vsxTiXmlString destructor
    ~ vsxTiXmlString ()
    {
        empty_it ();
    }

    // Convert a vsxTiXmlString into a classical char *
    const char * c_str () const
    {
        if (allocated)
            return cstring;
        return "";
    }

    // Return the length of a vsxTiXmlString
    unsigned length () const
	{
		return ( allocated ) ? current_length : 0;
	}

    // vsxTiXmlString = operator
    void operator = (const char * content);

    // = operator
    void operator = (const vsxTiXmlString & copy);

    // += operator. Maps to append
    vsxTiXmlString& operator += (const char * suffix)
    {
        append (suffix);
		return *this;
    }

    // += operator. Maps to append
    vsxTiXmlString& operator += (char single)
    {
        append (single);
		return *this;
    }

    // += operator. Maps to append
    vsxTiXmlString& operator += (vsxTiXmlString & suffix)
    {
        append (suffix);
		return *this;
    }
    bool operator == (const vsxTiXmlString & compare) const;
    bool operator < (const vsxTiXmlString & compare) const;
    bool operator > (const vsxTiXmlString & compare) const;

    // Checks if a vsxTiXmlString is empty
    bool empty () const
    {
        return length () ? false : true;
    }

    // Checks if a vsxTiXmlString contains only whitespace (same rules as isspace)
	// Not actually used in tinyxml. Conflicts with a C macro, "isblank",
	// which is a problem. Commenting out. -lee
//    bool isblank () const;

    // single char extraction
    const char& at (unsigned index) const
    {
        assert( index < length ());
        return cstring [index];
    }

    // find a char in a string. Return vsxTiXmlString::notfound if not found
    unsigned find (char lookup) const
    {
        return find (lookup, 0);
    }

    // find a char in a string from an offset. Return vsxTiXmlString::notfound if not found
    unsigned find (char tofind, unsigned offset) const;

    /*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
		function clears the content of the vsxTiXmlString if any exists.
    */
    void reserve (unsigned size)
    {
        empty_it ();
        if (size)
        {
            allocated = size;
            cstring = new char [size];
            cstring [0] = 0;
            current_length = 0;
        }
    }

    // [] operator 
    char& operator [] (unsigned index) const
    {
        assert( index < length ());
        return cstring [index];
    }

    // Error value for find primitive 
    enum {	notfound = 0xffffffff,
            npos = notfound };

    void append (const char *str, int len );

  protected :

    // The base string
    char * cstring;
    // Number of chars allocated
    unsigned allocated;
    // Current string size
    unsigned current_length;

    // New size computation. It is simplistic right now : it returns twice the amount
    // we need
    unsigned assign_new_size (unsigned minimum_to_allocate)
    {
        return minimum_to_allocate * 2;
    }

    // Internal function that clears the content of a vsxTiXmlString
    void empty_it ()
    {
        if (cstring)
            delete [] cstring;
        cstring = NULL;
        allocated = 0;
        current_length = 0;
    }

    void append (const char *suffix );

    // append function for another vsxTiXmlString
    void append (const vsxTiXmlString & suffix)
    {
        append (suffix . c_str ());
    }

    // append for a single char. This could be improved a lot if needed
    void append (char single)
    {
        char smallstr [2];
        smallstr [0] = single;
        smallstr [1] = 0;
        append (smallstr);
    }

} ;

/* 
   vsxTiXmlOutStream is an emulation of std::ostream. It is based on vsxTiXmlString.
   Only the operators that we need for TinyXML have been developped.
*/
class vsxTiXmlOutStream : public vsxTiXmlString
{
public :
    vsxTiXmlOutStream () : vsxTiXmlString () {}

    // vsxTiXmlOutStream << operator. Maps to vsxTiXmlString::append
    vsxTiXmlOutStream & operator << (const char * in)
    {
        append (in);
        return (* this);
    }

    // vsxTiXmlOutStream << operator. Maps to vsxTiXmlString::append
    vsxTiXmlOutStream & operator << (const vsxTiXmlString & in)
    {
        append (in . c_str ());
        return (* this);
    }
} ;

#endif	// vsxTiXml_STRING_INCLUDED
#endif	// vsxTiXml_USE_STL
