Changeset 5817 in orxonox.OLD for branches/world_entities/src/lib/tinyxml/tinystr.h

Timestamp:

Nov 29, 2005, 10:52:08 AM (19 years ago)

Author:

bensch

Message:

orxonox/branches/we: new tinyXML-version (version 2.4.2)

File:

• branches/world_entities/src/lib/tinyxml/tinystr.h (modified) (5 diffs)

branches/world_entities/src/lib/tinyxml/tinystr.h

@@ -3 +3 @@
 Original file by Yves Berquin.
 
-This software is provided 'as-is', without any express or implied 
-warranty. In no event will the authors be held liable for any 
+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.
 
-Permission is granted to anyone to use this software for any 
-purpose, including commercial applications, and to alter it and 
+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:
 
-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 
+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.
 
@@ -19 +19 @@
 must not be misrepresented as being the original software.
 
-3. This notice may not be removed or altered from any source 
+3. This notice may not be removed or altered from any source
 distribution.
 */
 
-#include "tinyxml.h"
-
+/*
+ * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005.
+ *
+ * - completely rewritten. compact, clean, and fast implementation.
+ * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems)
+ * - fixed reserve() to work as per specification.
+ * - fixed buggy compares operator==(), operator<(), and operator>()
+ * - fixed operator+=() to take a const ref argument, following spec.
+ * - added "copy" constructor with length, and most compare operators.
+ * - added swap(), clear(), size(), capacity(), operator+().
+ */
 
 #ifndef TIXML_USE_STL
@@ -31 +40 @@
 #define TIXML_STRING_INCLUDED
 
-#ifdef _MSC_VER
-#pragma warning( disable : 4530 )
-#pragma warning( disable : 4786 )
-#endif
-
 #include <assert.h>
+#include <string.h>
 
 /*
-   TiXmlString is an emulation of the std::string template.
+   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.
@@ -48 +53 @@
 {
   public :
-    // TiXmlString constructor, based on a string, mark explicit to force
-        // us to find unnecessary casting.
-    explicit TiXmlString (const char * instring);
-
-    // TiXmlString empty constructor
-    TiXmlString ()
-    {
-        allocated = 0;
-        cstring = NULL;
-        current_length = 0;
-    }
-
-    // TiXmlString copy constructor
-    explicit TiXmlString (const TiXmlString& copy);
-
-    // TiXmlString destructor
-    ~ TiXmlString ()
-    {
-        empty_it ();
-    }
-
-    // Convert a TiXmlString into a classical char *
-    const char * c_str () const
-    {
-        if (allocated)
-            return cstring;
-        return "";
-    }
-
-    // Return the length of a TiXmlString
-    size_t length () const
-        {
-                return ( allocated ) ? current_length : 0;
-        }
-
-    // TiXmlString = operator
-    void operator = (const char * content);
-
-    // = operator
-    void operator = (const TiXmlString & copy);
-
-    // += operator. Maps to append
-    TiXmlString& operator += (const char * suffix)
-    {
-        append (suffix);
-                return *this;
-    }
-
-    // += operator. Maps to append
-    TiXmlString& operator += (char single)
-    {
-        append (single);
-                return *this;
-    }
-
-    // += operator. Maps to append
-    TiXmlString& operator += (TiXmlString & suffix)
-    {
-        append (suffix);
-                return *this;
-    }
-    bool operator == (const TiXmlString & compare) const;
-    bool operator == (const char* compare) const;
-    bool operator < (const TiXmlString & compare) const;
-    bool operator > (const TiXmlString & compare) const;
-
-    // Checks if a TiXmlString is empty
-    bool empty () const
-    {
-        return length () ? false : true;
-    }
-
-    // single char extraction
-    const char& at (unsigned index) const
-    {
-        assert( index < length ());
-        return cstring [index];
-    }
-
-    // find a char in a string. Return TiXmlString::notfound if not found
-    unsigned find (char lookup) const
-    {
-        return find (lookup, 0);
-    }
-
-    // find a char in a string from an offset. Return TiXmlString::notfound if not found
-    unsigned find (char tofind, unsigned offset) const;
-
-    /*  Function to reserve a big amount of data when we know we'll need it. Be aware that this
-                function clears the content of the TiXmlString if any exists.
-    */
-    void reserve (unsigned size)
-    {
-        empty_it ();
-        if (size)
-        {
-            allocated = size;
-            cstring = new char [size];
-            cstring [0] = 0;
-            current_length = 0;
-        }
-    }
-
-    // [] operator 
-    char& operator [] (unsigned index) const
-    {
-        assert( index < length ());
-        return cstring [index];
-    }
-
-    // Error value for find primitive 
-    enum {      notfound = 0xffffffff,
-            npos = notfound };
-
-    void append (const char *str, size_t len );
-
-  protected :
-
-    // The base string
-    char * cstring;
-    // Number of chars allocated
-    size_t allocated;
-    // Current string size
-    size_t current_length;
-
-    // New size computation. It is simplistic right now : it returns twice the amount
-    // we need
-    size_t assign_new_size (size_t minimum_to_allocate)
-    {
-        return minimum_to_allocate * 2;
-    }
-
-    // Internal function that clears the content of a TiXmlString
-    void empty_it ()
-    {
-        if (cstring)
-            delete [] cstring;
-        cstring = NULL;
-        allocated = 0;
-        current_length = 0;
-    }
-
-    void append (const char *suffix );
-
-    // append function for another TiXmlString
-    void append (const TiXmlString & suffix)
-    {
-        append (suffix . c_str ());
-    }
-
-    // append for a single char.
-    void append (char single)
-    {
-        if ( cstring && current_length < (allocated-1) )
+        // The size type used
+        typedef unsigned int 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)
+        {
+                init(copy.length());
+                memcpy(start(), copy.data(), length());
+        }
+
+        // TiXmlString constructor, based on a string
+        TiXmlString (const char * copy)
+        {
+                init( static_cast<size_type>( strlen(copy) ));
+                memcpy(start(), copy, length());
+        }
+
+        // TiXmlString constructor, based on a string
+        TiXmlString (const char * str, size_type len)
+        {
+                init(len);
+                memcpy(start(), str, len);
+        }
+
+        // TiXmlString destructor
+        ~TiXmlString ()
+        {
+                quit();
+        }
+
+        // = operator
+        TiXmlString& operator = (const char * copy)
+        {
+                return assign( copy, (size_type)strlen(copy));
+        }
+
+        // = operator
+        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)
                 {
-                        cstring[ current_length ] = single;
-                        ++current_length;
-                        cstring[ current_length ] = 0;
+                   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
                 {
-                        char smallstr [2];
-                        smallstr [0] = single;
-                        smallstr [1] = 0;
-                        append (smallstr);
+                        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_;
 
 } ;
 
-/* 
+
+inline bool operator == (const TiXmlString & a, const TiXmlString & b)
+{
+        return    ( a.length() == b.length() )                          // optimization on some platforms
+               && ( strcmp(a.c_str(), b.c_str()) == 0 );        // actual compare
+}
+inline bool operator < (const TiXmlString & a, const TiXmlString & b)
+{
+        return strcmp(a.c_str(), b.c_str()) < 0;
+}
+
+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); }
+
+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); }
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
+TiXmlString operator + (const TiXmlString & a, const char* b);
+TiXmlString operator + (const char* a, const TiXmlString & b);
+
+
+/*
    TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
    Only the operators that we need for TinyXML have been developped.
@@ -225 +284 @@
 {
 public :
-    TiXmlOutStream () : TiXmlString () {}
-
-    // TiXmlOutStream << operator. Maps to TiXmlString::append
-    TiXmlOutStream & operator << (const char * in)
-    {
-        append (in);
-        return (* this);
-    }
-
-    // TiXmlOutStream << operator. Maps to TiXmlString::append
-    TiXmlOutStream & operator << (const TiXmlString & in)
-    {
-        append (in . c_str ());
-        return (* this);
-    }
+
+        // TiXmlOutStream << operator.
+        TiXmlOutStream & operator << (const TiXmlString & in)
+        {
+                *this += in;
+                return *this;
+        }
+
+        // TiXmlOutStream << operator.
+        TiXmlOutStream & operator << (const char * in)
+        {
+                *this += in;
+                return *this;
+        }
+
 } ;
-
-#ifdef _MSC_VER
-#pragma warning( default : 4530 )
-#pragma warning( default : 4786 )
-#endif
 
 #endif  // TIXML_STRING_INCLUDED