Main Page Class Hierarchy Compound List File List Compound Members

# tinystr.h

    00001 /*
    00002 www.sourceforge.net/projects/tinyxml
    00003 Original file by Yves Berquin.
    00004
    00005 This software is provided 'as-is', without any express or implied
    00006 warranty. In no event will the authors be held liable for any
    00007 damages arising from the use of this software.
    00008
    00009 Permission is granted to anyone to use this software for any
    00010 purpose, including commercial applications, and to alter it and
    00011 redistribute it freely, subject to the following restrictions:
    00012
    00013 1. The origin of this software must not be misrepresented; you must
    00014 not claim that you wrote the original software. If you use this
    00015 software in a product, an acknowledgment in the product documentation
    00016 would be appreciated but is not required.
    00017
    00018 2. Altered source versions must be plainly marked as such, and
    00019 must not be misrepresented as being the original software.
    00020
    00021 3. This notice may not be removed or altered from any source
    00022 distribution.
    00023 */
    00024
    00025 #include "tinyxml.h"
    00026
    00027
    00028 #ifndef TIXML_USE_STL
    00029
    00030 #ifndef TIXML_STRING_INCLUDED
    00031 #define TIXML_STRING_INCLUDED
    00032
    00033 #ifdef _MSC_VER
    00034 #pragma warning( disable : 4786 )   // Debugger truncating names.
    00035 #endif
    00036
    00037 #include <assert.h>
    00038
    00039 /*
    00040    TiXmlString is an emulation of the std::string template.
    00041    Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
    00042    Only the member functions relevant to the TinyXML project have been implemented.
    00043    The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
    00044    a string and there's no more room, we allocate a buffer twice as big as we need.
    00045 */
    00046 class TiXmlString
    00047 {
    00048   public :
    00049     // TiXmlString constructor, based on a string
    00050     TiXmlString (const char * instring);
    00051
    00052     // TiXmlString empty constructor
    00053     TiXmlString ()
    00054     {
    00055         allocated = 0;
    00056         cstring = NULL;
    00057         current_length = 0;
    00058     }
    00059
    00060     // TiXmlString copy constructor
    00061     TiXmlString (const TiXmlString& copy);
    00062
    00063     // TiXmlString destructor
    00064     ~ TiXmlString ()
    00065     {
    00066         empty_it ();
    00067     }
    00068
    00069     // Convert a TiXmlString into a classical char *
    00070     const char * c_str () const
    00071     {
    00072         if (allocated)
    00073             return cstring;
    00074         return "";
    00075     }
    00076
    00077     // Return the length of a TiXmlString
    00078     unsigned length () const
    00079     {
    00080         return ( allocated ) ? current_length : 0;
    00081     }
    00082
    00083     // TiXmlString = operator
    00084     void operator = (const char * content);
    00085
    00086     // = operator
    00087     void operator = (const TiXmlString & copy);
    00088
    00089     // += operator. Maps to append
    00090     TiXmlString& operator += (const char * suffix)
    00091     {
    00092         append (suffix);
    00093         return *this;
    00094     }
    00095
    00096     // += operator. Maps to append
    00097     TiXmlString& operator += (char single)
    00098     {
    00099         append (single);
    00100         return *this;
    00101     }
    00102
    00103     // += operator. Maps to append
    00104     TiXmlString& operator += (TiXmlString & suffix)
    00105     {
    00106         append (suffix);
    00107         return *this;
    00108     }
    00109     bool operator == (const TiXmlString & compare) const;
    00110     bool operator < (const TiXmlString & compare) const;
    00111     bool operator > (const TiXmlString & compare) const;
    00112
    00113     // Checks if a TiXmlString is empty
    00114     bool empty () const
    00115     {
    00116         return length () ? false : true;
    00117     }
    00118
    00119     // single char extraction
    00120     const char& at (unsigned index) const
    00121     {
    00122         assert( index < length ());
    00123         return cstring [index];
    00124     }
    00125
    00126     // find a char in a string. Return TiXmlString::notfound if not found
    00127     unsigned find (char lookup) const
    00128     {
    00129         return find (lookup, 0);
    00130     }
    00131
    00132     // find a char in a string from an offset. Return TiXmlString::notfound if not found
    00133     unsigned find (char tofind, unsigned offset) const;
    00134
    00135     /*  Function to reserve a big amount of data when we know we'll need it. Be aware that this
    00136         function clears the content of the TiXmlString if any exists.
    00137     */
    00138     void reserve (unsigned size)
    00139     {
    00140         empty_it ();
    00141         if (size)
    00142         {
    00143             allocated = size;
    00144             cstring = new char [size];
    00145             cstring [0] = 0;
    00146             current_length = 0;
    00147         }
    00148     }
    00149
    00150     // [] operator
    00151     char& operator [] (unsigned index) const
    00152     {
    00153         assert( index < length ());
    00154         return cstring [index];
    00155     }
    00156
    00157     // Error value for find primitive
    00158     enum {  notfound = 0xffffffff,
    00159             npos = notfound };
    00160
    00161     void append (const char *str, int len );
    00162
    00163   protected :
    00164
    00165     // The base string
    00166     char * cstring;
    00167     // Number of chars allocated
    00168     unsigned allocated;
    00169     // Current string size
    00170     unsigned current_length;
    00171
    00172     // New size computation. It is simplistic right now : it returns twice the amount
    00173     // we need
    00174     unsigned assign_new_size (unsigned minimum_to_allocate)
    00175     {
    00176         return minimum_to_allocate * 2;
    00177     }
    00178
    00179     // Internal function that clears the content of a TiXmlString
    00180     void empty_it ()
    00181     {
    00182         if (cstring)
    00183             delete [] cstring;
    00184         cstring = NULL;
    00185         allocated = 0;
    00186         current_length = 0;
    00187     }
    00188
    00189     void append (const char *suffix );
    00190
    00191     // append function for another TiXmlString
    00192     void append (const TiXmlString & suffix)
    00193     {
    00194         append (suffix . c_str ());
    00195     }
    00196
    00197     // append for a single char.
    00198     void append (char single)
    00199     {
    00200         if ( cstring && current_length < (allocated-1) )
    00201         {
    00202             cstring[ current_length ] = single;
    00203             ++current_length;
    00204             cstring[ current_length ] = 0;
    00205         }
    00206         else
    00207         {
    00208             char smallstr [2];
    00209             smallstr [0] = single;
    00210             smallstr [1] = 0;
    00211             append (smallstr);
    00212         }
    00213     }
    00214
    00215 } ;
    00216
    00217 /*
    00218    TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
    00219    Only the operators that we need for TinyXML have been developped.
    00220 */
    00221 class TiXmlOutStream : public TiXmlString
    00222 {
    00223 public :
    00224     TiXmlOutStream () : TiXmlString () {}
    00225
    00226     // TiXmlOutStream << operator. Maps to TiXmlString::append
    00227     TiXmlOutStream & operator << (const char * in)
    00228     {
    00229         append (in);
    00230         return (* this);
    00231     }
    00232
    00233     // TiXmlOutStream << operator. Maps to TiXmlString::append
    00234     TiXmlOutStream & operator << (const TiXmlString & in)
    00235     {
    00236         append (in . c_str ());
    00237         return (* this);
    00238     }
    00239 } ;
    00240
    00241 #endif  // TIXML_STRING_INCLUDED
    00242 #endif  // TIXML_USE_STL