00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 
00034 
00035 
00036 
00037 #ifndef TIXML_USE_STL
00038 
00039 #ifndef TIXML_STRING_INCLUDED
00040 #define TIXML_STRING_INCLUDED
00041 
00042 #include <assert.h>
00043 #include <string.h>
00044 
00045 
00046 
00047 
00048 
00049 #if defined(_MSC_VER) && (_MSC_VER >= 1200 )
00050     
00051     #define TIXML_EXPLICIT explicit
00052 #elif defined(__GNUC__) && (__GNUC__ >= 3 )
00053     
00054     #define TIXML_EXPLICIT explicit
00055 #else
00056     #define TIXML_EXPLICIT
00057 #endif
00058 
00059 
00060 
00061 
00062 
00063 
00064 
00065 
00066 
00067 class TiXmlString
00068 {
00069   public :
00070     
00071     typedef size_t size_type;
00072 
00073     
00074     static const size_type npos; 
00075 
00076 
00077     
00078     TiXmlString () : rep_(&nullrep_)
00079     {
00080     }
00081 
00082     
00083     TiXmlString ( const TiXmlString & copy) : rep_(0)
00084     {
00085         init(copy.length());
00086         memcpy(start(), copy.data(), length());
00087     }
00088 
00089     
00090     TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
00091     {
00092         init( static_cast<size_type>( strlen(copy) ));
00093         memcpy(start(), copy, length());
00094     }
00095 
00096     
00097     TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
00098     {
00099         init(len);
00100         memcpy(start(), str, len);
00101     }
00102 
00103     
00104     ~TiXmlString ()
00105     {
00106         quit();
00107     }
00108 
00109     
00110     TiXmlString& operator = (const char * copy)
00111     {
00112         return assign( copy, (size_type)strlen(copy));
00113     }
00114 
00115     
00116     TiXmlString& operator = (const TiXmlString & copy)
00117     {
00118         return assign(copy.start(), copy.length());
00119     }
00120 
00121 
00122     
00123     TiXmlString& operator += (const char * suffix)
00124     {
00125         return append(suffix, static_cast<size_type>( strlen(suffix) ));
00126     }
00127 
00128     
00129     TiXmlString& operator += (char single)
00130     {
00131         return append(&single, 1);
00132     }
00133 
00134     
00135     TiXmlString& operator += (const TiXmlString & suffix)
00136     {
00137         return append(suffix.data(), suffix.length());
00138     }
00139 
00140 
00141     
00142     const char * c_str () const { return rep_->str; }
00143 
00144     
00145     const char * data () const { return rep_->str; }
00146 
00147     
00148     size_type length () const { return rep_->size; }
00149 
00150     
00151     size_type size () const { return rep_->size; }
00152 
00153     
00154     bool empty () const { return rep_->size == 0; }
00155 
00156     
00157     size_type capacity () const { return rep_->capacity; }
00158 
00159 
00160     
00161     const char& at (size_type index) const
00162     {
00163         assert( index < length() );
00164         return rep_->str[ index ];
00165     }
00166 
00167     
00168     char& operator [] (size_type index) const
00169     {
00170         assert( index < length() );
00171         return rep_->str[ index ];
00172     }
00173 
00174     
00175     size_type find (char lookup) const
00176     {
00177         return find(lookup, 0);
00178     }
00179 
00180     
00181     size_type find (char tofind, size_type offset) const
00182     {
00183         if (offset >= length()) return npos;
00184 
00185         for (const char* p = c_str() + offset; *p != '\0'; ++p)
00186         {
00187            if (*p == tofind) return static_cast< size_type >( p - c_str() );
00188         }
00189         return npos;
00190     }
00191 
00192     void clear ()
00193     {
00194         
00195         
00196         
00197         
00198         quit();
00199         init(0,0);
00200     }
00201 
00202     
00203 
00204 
00205     void reserve (size_type cap);
00206 
00207     TiXmlString& assign (const char* str, size_type len);
00208 
00209     TiXmlString& append (const char* str, size_type len);
00210 
00211     void swap (TiXmlString& other)
00212     {
00213         Rep* r = rep_;
00214         rep_ = other.rep_;
00215         other.rep_ = r;
00216     }
00217 
00218   private:
00219 
00220     void init(size_type sz) { init(sz, sz); }
00221     void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
00222     char* start() const { return rep_->str; }
00223     char* finish() const { return rep_->str + rep_->size; }
00224 
00225     struct Rep
00226     {
00227         size_type size, capacity;
00228         char str[1];
00229     };
00230 
00231     void init(size_type sz, size_type cap)
00232     {
00233         if (cap)
00234         {
00235             
00236             
00237             
00238             
00239             
00240             const size_type bytesNeeded = sizeof(Rep) + cap;
00241             const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
00242             rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
00243 
00244             rep_->str[ rep_->size = sz ] = '\0';
00245             rep_->capacity = cap;
00246         }
00247         else
00248         {
00249             rep_ = &nullrep_;
00250         }
00251     }
00252 
00253     void quit()
00254     {
00255         if (rep_ != &nullrep_)
00256         {
00257             
00258             
00259             delete [] ( reinterpret_cast<int*>( rep_ ) );
00260         }
00261     }
00262 
00263     Rep * rep_;
00264     static Rep nullrep_;
00265 
00266 } ;
00267 
00268 
00269 inline bool operator == (const TiXmlString & a, const TiXmlString & b)
00270 {
00271     return    ( a.length() == b.length() )              
00272            && ( strcmp(a.c_str(), b.c_str()) == 0 );    
00273 }
00274 inline bool operator < (const TiXmlString & a, const TiXmlString & b)
00275 {
00276     return strcmp(a.c_str(), b.c_str()) < 0;
00277 }
00278 
00279 inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
00280 inline bool operator >  (const TiXmlString & a, const TiXmlString & b) { return b < a; }
00281 inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
00282 inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
00283 
00284 inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; }
00285 inline bool operator == (const char* a, const TiXmlString & b) { return b == a; }
00286 inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); }
00287 inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); }
00288 
00289 TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
00290 TiXmlString operator + (const TiXmlString & a, const char* b);
00291 TiXmlString operator + (const char* a, const TiXmlString & b);
00292 
00293 
00294 
00295 
00296 
00297 
00298 class TiXmlOutStream : public TiXmlString
00299 {
00300 public :
00301 
00302     
00303     TiXmlOutStream & operator << (const TiXmlString & in)
00304     {
00305         *this += in;
00306         return *this;
00307     }
00308 
00309     
00310     TiXmlOutStream & operator << (const char * in)
00311     {
00312         *this += in;
00313         return *this;
00314     }
00315 
00316 } ;
00317 
00318 #endif  // TIXML_STRING_INCLUDED
00319 #endif  // TIXML_USE_STL