- Cal3D 0.9 API Reference -

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 #pragma warning( disable : 4514 )
00034 
00035 #include "cal3d/platform.h"
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     // 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     }
00183 
00184     // Internal function that clears the content of a TiXmlString
00185     void empty_it ()
00186     {
00187         if (cstring)
00188             delete [] cstring;
00189         cstring = NULL;
00190         allocated = 0;
00191         current_length = 0;
00192     }
00193 
00194     void append (const char *suffix );
00195 
00196     // append function for another TiXmlString
00197     void append (const TiXmlString & suffix)
00198     {
00199         append (suffix . c_str ());
00200     }
00201 
00202     // append for a single char. This could be improved a lot if needed
00203     void append (char single)
00204     {
00205         char smallstr [2];
00206         smallstr [0] = single;
00207         smallstr [1] = 0;
00208         append (smallstr);
00209     }
00210 
00211 } ;
00212 
00213 /* 
00214    TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
00215    Only the operators that we need for TinyXML have been developped.
00216 */
00217 class TiXmlOutStream : public TiXmlString
00218 {
00219 public :
00220     TiXmlOutStream () : TiXmlString () {}
00221 
00222     // TiXmlOutStream << operator. Maps to TiXmlString::append
00223     TiXmlOutStream & operator << (const char * in)
00224     {
00225         append (in);
00226         return (* this);
00227     }
00228 
00229     // TiXmlOutStream << operator. Maps to TiXmlString::append
00230     TiXmlOutStream & operator << (const TiXmlString & in)
00231     {
00232         append (in . c_str ());
00233         return (* this);
00234     }
00235 } ;
00236 
00237 #endif  // TIXML_STRING_INCLUDED
00238 #endif  // TIXML_USE_STL

Generated at Sun Jan 29 14:29:16 2006 by The Cal3D Team with doxygen 1.4.6 © 1997-2001 Dimitri van Heesch