Main Page Modules Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

# tinystr.h

Go to the documentation of this file.

    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 #pragma warning( disable : 4514 )
    00034
    00035 #include <assert.h>
    00036
    00037 /*
    00038    TiXmlString is an emulation of the std::string template.
    00039    Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
    00040    Only the member functions relevant to the TinyXML project have been implemented.
    00041    The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
    00042    a string and there's no more room, we allocate a buffer twice as big as we need.
    00043 */
    00044 class TiXmlString
    00045 {
    00046   public :
    00047     // TiXmlString constructor, based on a string
    00048     TiXmlString (const char * instring);
    00049
    00050     // TiXmlString empty constructor
    00051     TiXmlString ()
    00052     {
    00053         allocated = 0;
    00054         cstring = NULL;
    00055         current_length = 0;
    00056     }
    00057
    00058     // TiXmlString copy constructor
    00059     TiXmlString (const TiXmlString& copy);
    00060
    00061     // TiXmlString destructor
    00062     ~ TiXmlString ()
    00063     {
    00064         empty_it ();
    00065     }
    00066
    00067     // Convert a TiXmlString into a classical char *
    00068     const char * c_str () const
    00069     {
    00070         if (allocated)
    00071             return cstring;
    00072         return "";
    00073     }
    00074
    00075     // Return the length of a TiXmlString
    00076     unsigned length () const
    00077     {
    00078         return ( allocated ) ? current_length : 0;
    00079     }
    00080     unsigned size () const
    00081     { return length(); }
    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     // Checks if a TiXmlString contains only whitespace (same rules as isspace)
    00120     // Not actually used in tinyxml. Conflicts with a C macro, "isblank",
    00121     // which is a problem. Commenting out. -lee
    00122 //    bool isblank () const;
    00123
    00124     // single char extraction
    00125     const char& at (unsigned index) const
    00126     {
    00127         assert( index < length ());
    00128         return cstring [index];
    00129     }
    00130
    00131     // find a char in a string. Return TiXmlString::notfound if not found
    00132     unsigned find (char lookup) const
    00133     {
    00134         return find (lookup, 0);
    00135     }
    00136
    00137     // find a char in a string from an offset. Return TiXmlString::notfound if not found
    00138     unsigned find (char tofind, unsigned offset) const;
    00139
    00140     /*  Function to reserve a big amount of data when we know we'll need it. Be aware that this
    00141         function clears the content of the TiXmlString if any exists.
    00142     */
    00143     void reserve (unsigned size)
    00144     {
    00145         empty_it ();
    00146         if (size)
    00147         {
    00148             allocated = size;
    00149             cstring = new char [size];
    00150             cstring [0] = 0;
    00151             current_length = 0;
    00152         }
    00153     }
    00154
    00155     // [] operator
    00156     char& operator [] (unsigned index) const
    00157     {
    00158         assert( index < length ());
    00159         return cstring [index];
    00160     }
    00161
    00162     // Error value for find primitive
    00163     enum {  notfound = 0xffffffff,
    00164             npos = notfound };
    00165
    00166     void append (const char *str, int len );
    00167
    00168   protected :
    00169
    00170     // The base string
    00171     char * cstring;
    00172     // Number of chars allocated
    00173     unsigned allocated;
    00174     // Current string size
    00175     unsigned current_length;
    00176
    00177     // New size computation. It is simplistic right now : it returns twice the amount
    00178     // we need
    00179     unsigned assign_new_size (unsigned minimum_to_allocate)
    00180     {
    00181         //return minimum_to_allocate * 2;
    00182         for (unsigned pow2 = 2; pow2 < minimum_to_allocate; pow2 *= 2)
    00183         {
    00184         }
    00185         return pow2;
    00186     }
    00187
    00188     // Internal function that clears the content of a TiXmlString
    00189     void empty_it ()
    00190     {
    00191         if (cstring)
    00192             delete [] cstring;
    00193         cstring = NULL;
    00194         allocated = 0;
    00195         current_length = 0;
    00196     }
    00197
    00198     void append (const char *suffix );
    00199
    00200     // append function for another TiXmlString
    00201     void append (const TiXmlString & suffix)
    00202     {
    00203         append (suffix . c_str ());
    00204     }
    00205
    00206     // append for a single char. This could be improved a lot if needed
    00207     void append (char single)
    00208     {
    00209         char smallstr [2];
    00210         smallstr [0] = single;
    00211         smallstr [1] = 0;
    00212         append (smallstr);
    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