tinystr.h 9.07 KB
Newer Older
Ulrich Kemloh's avatar
Ulrich Kemloh committed
1
/*
Mohcine Chraibi's avatar
Mohcine Chraibi committed
2
  www.sourceforge.net/projects/tinyxml
Ulrich Kemloh's avatar
Ulrich Kemloh committed
3

Mohcine Chraibi's avatar
Mohcine Chraibi committed
4 5 6
  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.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
7

Mohcine Chraibi's avatar
Mohcine Chraibi committed
8 9 10
  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:
Ulrich Kemloh's avatar
Ulrich Kemloh committed
11

Mohcine Chraibi's avatar
Mohcine Chraibi committed
12 13 14 15
  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.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
16

Mohcine Chraibi's avatar
Mohcine Chraibi committed
17 18
  2. Altered source versions must be plainly marked as such, and
  must not be misrepresented as being the original software.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
19

Mohcine Chraibi's avatar
Mohcine Chraibi committed
20 21
  3. This notice may not be removed or altered from any source
  distribution.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
22 23 24 25 26 27 28 29 30 31 32
*/


#ifndef TIXML_USE_STL

#ifndef TIXML_STRING_INCLUDED
#define TIXML_STRING_INCLUDED

#include <assert.h>
#include <string.h>

Mohcine Chraibi's avatar
Mohcine Chraibi committed
33 34 35
/*      The support for explicit isn't that universal, and it isn't really
        required - it is used to check that the TiXmlString class isn't incorrectly
        used. Be nice to old compilers and macro it here:
Ulrich Kemloh's avatar
Ulrich Kemloh committed
36 37
*/
#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
Mohcine Chraibi's avatar
Mohcine Chraibi committed
38 39
// Microsoft visual studio, version 6 and higher.
#define TIXML_EXPLICIT explicit
Ulrich Kemloh's avatar
Ulrich Kemloh committed
40
#elif defined(__GNUC__) && (__GNUC__ >= 3 )
Mohcine Chraibi's avatar
Mohcine Chraibi committed
41 42
// GCC version 3 and higher.s
#define TIXML_EXPLICIT explicit
Ulrich Kemloh's avatar
Ulrich Kemloh committed
43
#else
Mohcine Chraibi's avatar
Mohcine Chraibi committed
44
#define TIXML_EXPLICIT
Ulrich Kemloh's avatar
Ulrich Kemloh committed
45 46 47 48
#endif


/*
Mohcine Chraibi's avatar
Mohcine Chraibi committed
49 50 51 52 53
  TiXmlString is an emulation of a subset 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.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
54
*/
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
class TiXmlString {
public :
     // The size type used
     typedef size_t size_type;

     // Error value for find primitive
     static const size_type npos; // = -1;


     // TiXmlString empty constructor
     TiXmlString () : rep_(&nullrep_) {
     }

     // TiXmlString copy constructor
     TiXmlString ( const TiXmlString & copy) : rep_(0) {
          init(copy.length());
          memcpy(start(), copy.data(), length());
     }

     // TiXmlString constructor, based on a string
     TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0) {
          init( static_cast<size_type>( strlen(copy) ));
          memcpy(start(), copy, length());
     }

     // TiXmlString constructor, based on a string
     TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0) {
          init(len);
          memcpy(start(), str, len);
     }

     // TiXmlString destructor
     ~TiXmlString () {
          quit();
     }

     TiXmlString& operator = (const char * copy) {
          return assign( copy, (size_type)strlen(copy));
     }

     TiXmlString& operator = (const TiXmlString & copy) {
          return assign(copy.start(), copy.length());
     }


     // += operator. Maps to append
     TiXmlString& operator += (const char * suffix) {
          return append(suffix, static_cast<size_type>( strlen(suffix) ));
     }

     // += operator. Maps to append
     TiXmlString& operator += (char single) {
          return append(&single, 1);
     }

     // += operator. Maps to append
     TiXmlString& operator += (const TiXmlString & suffix) {
          return append(suffix.data(), suffix.length());
     }


     // Convert a TiXmlString into a null-terminated char *
     const char * c_str () const {
          return rep_->str;
     }

     // Convert a TiXmlString into a char * (need not be null terminated).
     const char * data () const {
          return rep_->str;
     }

     // Return the length of a TiXmlString
     size_type length () const {
          return rep_->size;
     }

     // Alias for length()
     size_type size () const {
          return rep_->size;
     }

     // Checks if a TiXmlString is empty
     bool empty () const {
          return rep_->size == 0;
     }

     // Return capacity of string
     size_type capacity () const {
          return rep_->capacity;
     }


     // single char extraction
     const char& at (size_type index) const {
          assert( index < length() );
          return rep_->str[ index ];
     }

     // [] operator
     char& operator [] (size_type index) const {
          assert( index < length() );
          return rep_->str[ index ];
     }

     // find a char in a string. Return TiXmlString::npos if not found
     size_type find (char lookup) const {
          return find(lookup, 0);
     }

     // find a char in a string from an offset. Return TiXmlString::npos if not found
     size_type find (char tofind, size_type offset) const {
          if (offset >= length()) return npos;

          for (const char* p = c_str() + offset; *p != '\0'; ++p) {
               if (*p == tofind) return static_cast< size_type >( p - c_str() );
          }
          return npos;
     }

     void clear () {
          //Lee:
          //The original was just too strange, though correct:
          //  TiXmlString().swap(*this);
          //Instead use the quit & re-init:
          quit();
          init(0,0);
     }

     /*    Function to reserve a big amount of data when we know we'll need it. Be aware that this
           function DOES NOT clear the content of the TiXmlString if any exists.
     */
     void reserve (size_type cap);

     TiXmlString& assign (const char* str, size_type len);

     TiXmlString& append (const char* str, size_type len);

     void swap (TiXmlString& other) {
          Rep* r = rep_;
          rep_ = other.rep_;
          other.rep_ = r;
     }

private:

     void init(size_type sz) {
          init(sz, sz);
     }
     void set_size(size_type sz) {
          rep_->str[ rep_->size = sz ] = '\0';
     }
     char* start() const {
          return rep_->str;
     }
     char* finish() const {
          return rep_->str + rep_->size;
     }

     struct Rep {
          size_type size, capacity;
          char str[1];
     };

     void init(size_type sz, size_type cap) {
          if (cap) {
               // Lee: the original form:
               //      rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
               // doesn't work in some cases of new being overloaded. Switching
               // to the normal allocation, although use an 'int' for systems
               // that are overly picky about structure alignment.
               const size_type bytesNeeded = sizeof(Rep) + cap;
               const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int );
               rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );

               rep_->str[ rep_->size = sz ] = '\0';
               rep_->capacity = cap;
          } else {
               rep_ = &nullrep_;
          }
     }

     void quit() {
          if (rep_ != &nullrep_) {
               // The rep_ is really an array of ints. (see the allocator, above).
               // Cast it back before delete, so the compiler won't incorrectly call destructors.
               delete [] ( reinterpret_cast<int*>( rep_ ) );
          }
     }

     Rep * rep_;
     static Rep nullrep_;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
246 247 248 249 250 251

} ;


inline bool operator == (const TiXmlString & a, const TiXmlString & b)
{
252 253
     return    ( a.length() == b.length() )                                // optimization on some platforms
               && ( strcmp(a.c_str(), b.c_str()) == 0 );     // actual compare
Ulrich Kemloh's avatar
Ulrich Kemloh committed
254 255 256
}
inline bool operator < (const TiXmlString & a, const TiXmlString & b)
{
257
     return strcmp(a.c_str(), b.c_str()) < 0;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
258 259
}

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
inline bool operator != (const TiXmlString & a, const TiXmlString & b)
{
     return !(a == b);
}
inline bool operator >  (const TiXmlString & a, const TiXmlString & b)
{
     return b < a;
}
inline bool operator <= (const TiXmlString & a, const TiXmlString & b)
{
     return !(b < a);
}
inline bool operator >= (const TiXmlString & a, const TiXmlString & b)
{
     return !(a < b);
}
Ulrich Kemloh's avatar
Ulrich Kemloh committed
276

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
inline bool operator == (const TiXmlString & a, const char* b)
{
     return strcmp(a.c_str(), b) == 0;
}
inline bool operator == (const char* a, const TiXmlString & b)
{
     return b == a;
}
inline bool operator != (const TiXmlString & a, const char* b)
{
     return !(a == b);
}
inline bool operator != (const char* a, const TiXmlString & b)
{
     return !(b == a);
}
Ulrich Kemloh's avatar
Ulrich Kemloh committed
293 294 295 296 297 298 299

TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
TiXmlString operator + (const TiXmlString & a, const char* b);
TiXmlString operator + (const char* a, const TiXmlString & b);


/*
Mohcine Chraibi's avatar
Mohcine Chraibi committed
300 301
  TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
  Only the operators that we need for TinyXML have been developped.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
302
*/
303 304 305 306 307 308 309 310 311 312 313 314 315 316
class TiXmlOutStream : public TiXmlString {
public :

     // TiXmlOutStream << operator.
     TiXmlOutStream & operator << (const TiXmlString & in) {
          *this += in;
          return *this;
     }

     // TiXmlOutStream << operator.
     TiXmlOutStream & operator << (const char * in) {
          *this += in;
          return *this;
     }
Ulrich Kemloh's avatar
Ulrich Kemloh committed
317 318 319

} ;

Mohcine Chraibi's avatar
Mohcine Chraibi committed
320 321
#endif  // TIXML_STRING_INCLUDED
#endif  // TIXML_USE_STL