vstring.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vstring_h
#define vstring_h

#include "vtypes.h"

#include "vcodepoint.h"
#include "vstringiterator.h"

class VChar;

typedef std::vector<VString> VStringVector;
typedef std::vector<VString*> VStringPtrVector;

#ifndef V_EFFICIENT_SPRINTF
class VMutex;
#endif

#ifdef VAULT_QT_SUPPORT
#include <qstring.h>
#endif

/*
Best practices for VString creation:

- To pass a temporary VString constructed with vararg formatting, use VSTRING_FORMAT:
  functionThatTakesAString(VSTRING_FORMAT("my %s format %d string", "hey!", 42));

- To construct a local or instance variable with vararg formatting, use VSTRING_ARGS:
  VString s(VSTRING_ARGS("my %s format %d string", "hey!", 42));
  ... mMyInstanceVar(VSTRING_ARGS("my %s format %d string", "hey!", 42)) ...

- To simply construct a VString from a literal, you can just supply the literal, but
  if you care about optimizing compatibility "non-strict" formatting, you may prefer
  to use VSTRING_COPY. It depends whether you are assigning or initializing. Initializing
  does not benefit from this.
  VString x("my string literal");
  VString y = VSTRING_COPY("my literal");

- Where you may want to future-proof to distinguish between making a copy of a temporary
  buffer vs. simply referring to a literal (a feature I have been expirimenting with to
  determine feasibility), use VSTRING_COPY to indicate that a copy must be made. Notice
  the difference between this and the simple literal constructor above; in theory, the
  literal does not need to be copied, but here we do need to copy because the temp buffer
  may live a shorter life than the string.
  VString s = VSTRING_COPY(some_temp_buffer_returned_by_a_system_api);

- So in fact the above is a good distinction:
  If constructing with a literal, just pass it in unadorned.
  If constructing with a temporary char* buffer, wrap it with VSTRING_COPY to ensure
  copying if I later optimize away literal copying. (This is the dilemma; how do I know
  what the pointer points to?)
*/

#ifdef VAULT_VSTRING_STRICT_FORMATTING
    #define VSTRING_FORMAT(format_string, ...) VString(0, format_string, __VA_ARGS__)
    #define VSTRING_ARGS(format_string, ...) true, format_string, __VA_ARGS__
    #define VSTRING_COPY(literal_string) VString(literal_string)
#else
    #define VSTRING_FORMAT(format_string, ...) VString(format_string, __VA_ARGS__)
    #define VSTRING_ARGS(format_string, ...) format_string, __VA_ARGS__
    #define VSTRING_COPY(literal_string) VString((char*)literal_string) // call non-formatting ctor
#endif

// The following macros define the proper formatting directives for the basic POD types,
// and VString constructors for converting those types to strings. For convenience, we
// also define a boolean string constructor.
// My advice and practice in Vault code:
// - %s (char*), and %c (char) are pervasively well-understood and should be used as is. Often %d as well.
// - The other formatters are provided here and should usually be used by name for clarity, except where
//   their presence makes code less understandable because of verbosity.
// For example:
// VSTRING_FORMAT("Hello, %s.", p->getName().chars());                          <-- No need to avoid using %s for (char*) values.
// VSTRING_FORMAT("Answer is %d.", 42);                                         <-- No need to avoid using %d for int values.
// VSTRING_FORMAT("Vector size is " VSTRING_FORMATTER_SIZE, vec.size());        <-- Useful because size_t formatting is sketchy.
// VSTRING_FORMAT("My 32-bit value is " VSTRING_FORMATTER_S32, myVs32Value);    <-- Useful because 32-bit int formatter may depend on compiler mode.
// VSTRING_FORMAT("Jumbo 64-bit size is " VSTRING_FORMATTER_S64, myVs64Value);  <-- Useful because 64-bit int formatter may depend on compiler mode.
// VSTRING_FORMAT("Result dimensions: %lld*%lld*%lld", x, y, z);                <-- Code would be less readable if VSTRING_FORMATTER_S64 were used 3x here, but this is not totally correct on unusual 64-bit platforms.

#define VSTRING_FORMATTER_INT       "%d"
#define VSTRING_FORMATTER_UINT      "%u"
#define VSTRING_FORMATTER_LONG      "%ld"
#define VSTRING_FORMATTER_ULONG     "%lu"
#ifdef VCOMPILER_MSVC
    #define VSTRING_FORMATTER_SIZE  "%Iu"   // VC++ libraries do not conform to IEEE1003.1 here.
#else
    #define VSTRING_FORMATTER_SIZE  "%zu"
#endif
#define VSTRING_FORMATTER_S8        "%hhd"  // Note: %hhd is not universally supported; converting value to other type may be better.
#define VSTRING_FORMATTER_U8        "%hhu"  // Note: %hhu is not universally supported; converting value to other type may be better.
#define VSTRING_FORMATTER_S16       "%hd"
#define VSTRING_FORMATTER_U16       "%hu"

#ifdef Vx32_IS_xINT /* Don't redefine if types are same; else form is untested environment. */
#define VSTRING_FORMATTER_S32       VSTRING_FORMATTER_INT
#define VSTRING_FORMATTER_U32       VSTRING_FORMATTER_UINT
#else
#define VSTRING_FORMATTER_S32       VSTRING_FORMATTER_LONG
#define VSTRING_FORMATTER_U32       VSTRING_FORMATTER_ULONG
#endif

#ifdef Vx64_IS_xINT /* Don't redefine if types are same; else form is normal environment. */
#define VSTRING_FORMATTER_S64       VSTRING_FORMATTER_INT
#define VSTRING_FORMATTER_U64       VSTRING_FORMATTER_UINT
#else
#define VSTRING_FORMATTER_S64       "%lld"
#define VSTRING_FORMATTER_U64       "%llu"
#endif

#define VSTRING_FORMATTER_FLOAT     "%f"
#define VSTRING_FORMATTER_DOUBLE    "%lf"
#define VSTRING_FORMATTER_PTR       "%p"

// Consider these macros a public API for declaring strings that are built by converting integers
// of various sizes, etc. This is preferable to specifying the proper formatting directives manually.
#define VSTRING_INT(n)      VSTRING_FORMAT(VSTRING_FORMATTER_INT, n)    ///< Creates a string by formatting an int value.
#define VSTRING_UINT(n)     VSTRING_FORMAT(VSTRING_FORMATTER_UINT, n)   ///< Creates a string by formatting an unsigned int value.
#define VSTRING_LONG(n)     VSTRING_FORMAT(VSTRING_FORMATTER_LONG, n)   ///< Creates a string by formatting a long value.
#define VSTRING_ULONG(n)    VSTRING_FORMAT(VSTRING_FORMATTER_ULONG, n)  ///< Creates a string by formatting an unsigned long value.
#define VSTRING_SIZE(z)     VSTRING_FORMAT(VSTRING_FORMATTER_SIZE, z)   ///< Creates a string by formatting a size_t value.
#define VSTRING_S8(n)       VSTRING_FORMAT(VSTRING_FORMATTER_S8, n)     ///< Creates a string by formatting an 8-bit int value.
#define VSTRING_U8(n)       VSTRING_FORMAT(VSTRING_FORMATTER_U8, n)     ///< Creates a string by formatting an unsigned 8-bit int value.
#define VSTRING_S16(n)      VSTRING_FORMAT(VSTRING_FORMATTER_S16, n)    ///< Creates a string by formatting a 16-bit int value.
#define VSTRING_U16(n)      VSTRING_FORMAT(VSTRING_FORMATTER_U16, n)    ///< Creates a string by formatting an unsigned 16-bit int value.
#define VSTRING_S32(n)      VSTRING_FORMAT(VSTRING_FORMATTER_S32, n)    ///< Creates a string by formatting a 32-bit int value.
#define VSTRING_U32(n)      VSTRING_FORMAT(VSTRING_FORMATTER_U32, n)    ///< Creates a string by formatting an unsigned 32-bit int value.
#define VSTRING_S64(n)      VSTRING_FORMAT(VSTRING_FORMATTER_S64, n)    ///< Creates a string by formatting a 64-bit int value.
#define VSTRING_U64(n)      VSTRING_FORMAT(VSTRING_FORMATTER_U64, n)    ///< Creates a string by formatting an unsigned 64-bit int value.
#define VSTRING_FLOAT(n)    VSTRING_FORMAT(VSTRING_FORMATTER_FLOAT, n)  ///< Creates a string by formatting a float value.
#define VSTRING_DOUBLE(n)   VSTRING_FORMAT(VSTRING_FORMATTER_DOUBLE, n) ///< Creates a string by formatting a double value.
#define VSTRING_PTR(p)      VSTRING_FORMAT(VSTRING_FORMATTER_PTR, p)    ///< Creates a string by formatting a pointer as hexadecimal preceded by 0x.
#define VSTRING_BOOL(b)     VString(b ? "true" : "false")               ///< Creates a string from a boolean as the text "true" or "false".

class VString {
    public:

        static const VString& EMPTY();
        static const VString& NATIVE_LINE_ENDING();
        static const VString& UNIX_LINE_ENDING();
        static const VString& MAC_CLASSIC_LINE_ENDING();
        static const VString& DOS_LINE_ENDING();

        VString();
        VString(const VChar& c);
        VString(const VString& s);
        explicit VString(char c);
#ifdef VAULT_VSTRING_STRICT_FORMATTING
        VString(const char* s);
#else /* non-strict formatting */
        //lint -e1776 Converting a string literal to char * is not const safe [OK: Intentionally non-const to disambiguate API; function treats parameter as const.]
        VString(char* s);
#endif /* VAULT_VSTRING_STRICT_FORMATTING */

#ifdef VAULT_VARARG_STRING_FORMATTING_SUPPORT

#ifdef VAULT_VSTRING_STRICT_FORMATTING
        VString(Vs8 dummy, const char* formatText, ...);
#else /* non-strict formatting */
        VString(const char* formatText, ...);
#endif /* VAULT_VSTRING_STRICT_FORMATTING */

#endif /* VAULT_VARARG_STRING_FORMATTING_SUPPORT */

        VString(const std::wstring& ws);

#ifdef VAULT_QT_SUPPORT

        VString(const QString& s);
#endif

#ifdef VAULT_BOOST_STRING_FORMATTING_SUPPORT

        VString(const boost::format& fmt);
#endif

#ifdef VAULT_CORE_FOUNDATION_SUPPORT

        VString(const CFStringRef& s);
#endif

        VString(const VCodePoint& cp);

        ~VString();

        VString& operator=(const VString& s);
        VString& operator=(const VString* s);

#ifdef VAULT_QT_SUPPORT

        VString& operator=(const QString& s);
#endif

#ifdef VAULT_BOOST_STRING_FORMATTING_SUPPORT

        VString& operator=(const boost::format& fmt);
#endif

#ifdef VAULT_CORE_FOUNDATION_SUPPORT

        VString& operator=(const CFStringRef& s);
#endif

        VString& operator=(const VCodePoint& cp);

        VString& operator=(const VChar& c);
        VString& operator=(char c);
        VString& operator=(const char* s);
        VString& operator=(const std::wstring& ws);
        VString& operator=(int i);
        VString& operator=(Vu8 i);
        VString& operator=(Vs8 i);
        VString& operator=(Vu16 i);
        VString& operator=(Vs16 i);
        VString& operator=(Vu32 i);

#ifndef Vx32_IS_xINT /* don't redefine if types are same */

        VString& operator=(Vs32 i);
#endif /* not Vx32_IS_xINT */

        VString& operator=(Vu64 i);

#ifndef Vx64_IS_xINT /* don't redefine if types are same */

        VString& operator=(Vs64 i);
#endif /* not Vx64_IS_xINT */

        VString& operator=(VDouble d);


        VString operator+(const char c) const;
        VString operator+(const char* s) const;
        VString operator+(const std::wstring& ws) const;
        VString operator+(const VString& s) const;

#ifdef VAULT_BOOST_STRING_FORMATTING_SUPPORT

        VString operator+(const boost::format& fmt) const;
#endif

        VString operator+(const VCodePoint& cp) const;

        VString& operator+=(const VChar& c);
        VString& operator+=(const VString& s);
        VString& operator+=(char c);
        VString& operator+=(const char* s);
        VString& operator+=(const std::wstring& ws);

#ifdef VAULT_BOOST_STRING_FORMATTING_SUPPORT

        VString& operator+=(const boost::format& fmt);
#endif

        VString& operator+=(const VCodePoint& cp);

        VString& operator+=(int i);
        VString& operator+=(Vu8 i);
        VString& operator+=(Vs8 i);
        VString& operator+=(Vu16 i);
        VString& operator+=(Vs16 i);
        VString& operator+=(Vu32 i);
#ifndef Vx32_IS_xINT /* don't redefine if types are same */

        VString& operator+=(Vs32 i);
#endif /* not Vx32_IS_xINT */

        VString& operator+=(Vu64 i);
#ifndef Vx64_IS_xINT /* don't redefine if types are same */

        VString& operator+=(Vs64 i);
#endif /* not Vx64_IS_xINT */

        VString& operator+=(VDouble f);
        void readFromIStream(std::istream& in);
        void appendFromIStream(std::istream& in);
        
        typedef VStringIterator<VString&> iterator;
        typedef VStringIterator<const VString&> const_iterator;
        typedef VStringIterator<VString&> reverse_iterator;
        typedef VStringIterator<const VString&> const_reverse_iterator;
        
        iterator begin();
        const_iterator begin() const;
        iterator end();
        const_iterator end() const;

        reverse_iterator rbegin();
        const_reverse_iterator rbegin() const;
        reverse_iterator rend();
        const_reverse_iterator rend() const;

#ifdef VAULT_VARARG_STRING_FORMATTING_SUPPORT

        void format(const char* formatText, ...);
#endif

        void insert(const VCodePoint& cp, const VString::iterator& position);
        void insert(const VString& s, const VString::iterator& position);
        void insert(char c, const VString::iterator& position);

        void insert(const VCodePoint& cp, int offset = 0);
        void insert(const VString& s, int offset = 0);
        void insert(char c, int offset = 0);

        int getNumCodePoints() const;
        int length() const;
        void truncateCodePoints(int maxNumCodePoints);
        void truncateLength(int maxLength);
        bool isEmpty() const;
        bool isNotEmpty() const;
        VChar at(int i) const;
        VChar operator[](int i) const;
        char& operator[](int i);
        char charAt(int i) const;
        operator const char*() const;
        const char* chars() const;
        
        std::wstring toUTF16() const;

#ifdef VAULT_QT_SUPPORT

        QString qstring() const;
#endif

#ifdef VAULT_CORE_FOUNDATION_SUPPORT

        CFStringRef cfstring() const;
#endif

        bool equalsIgnoreCase(const VString& s) const;
        bool equalsIgnoreCase(const char* s) const;
        int compare(const VString& s) const;
        int compare(const char* s) const;
        int compareIgnoreCase(const VString& s) const;
        int compareIgnoreCase(const char* s) const;
        bool startsWith(const VString& s) const;
        bool startsWithIgnoreCase(const VString& s) const;
        bool startsWith(const VCodePoint& cp) const;
        bool startsWith(char c) const;
        bool endsWith(const VString& s) const;
        bool endsWithIgnoreCase(const VString& s) const;
        bool endsWith(const VCodePoint& cp) const;
        bool endsWith(char c) const;
        VString::const_iterator find(const VCodePoint& cp) const;
        VString::iterator find(const VCodePoint& cp);
        VString::const_iterator find(const VCodePoint& cp, const VString::const_iterator& startPosition, const VString::const_iterator& endPosition) const;
        VString::iterator find(const VCodePoint& cp, const VString::iterator& startPosition, const VString::iterator& endPosition);
        int indexOf(char c, int fromIndex = 0) const;
        int indexOfIgnoreCase(char c, int fromIndex = 0) const;
        int indexOf(const VString& s, int fromIndex = 0) const;
        int indexOfIgnoreCase(const VString& s, int fromIndex = 0) const;
        int lastIndexOf(char c, int fromIndex = -1) const;
        int lastIndexOfIgnoreCase(char c, int fromIndex = -1) const;
        int lastIndexOf(const VString& s, int fromIndex = -1) const;
        int lastIndexOfIgnoreCase(const VString& s, int fromIndex = -1) const;
        bool regionMatches(int thisIndex, const VString& otherString, int otherIndex, int regionLength, bool caseSensitive = true) const;
        bool contains(char c, int fromIndex = 0) const;
        bool containsIgnoreCase(char c, int fromIndex = 0) const;
        bool contains(const VString& s, int fromIndex = 0) const;
        bool containsIgnoreCase(const VString& s, int fromIndex = 0) const;
        int replace(const VString& searchString, const VString& replacementString, bool caseSensitiveSearch = true);
        int replace(const VCodePoint& searchChar, const VCodePoint& replacementChar, bool caseSensitiveSearch = true);

        void toLowerCase();
        void toUpperCase();
        int parseInt() const;
        Vs64 parseS64() const;
        Vu64 parseU64() const;
        VDouble parseDouble() const;
        void set(int i, const VChar& c);
        void getSubstring(VString& toString, int startIndex/* = 0*/, int endIndex = -1) const;
        void getSubstring(VString& toString, VString::const_iterator rangeStart, VString::const_iterator rangeEnd) const;
        void substringInPlace(int startIndex/* = 0*/, int endIndex = -1);
        void split(VStringVector& result, const VCodePoint& delimiter, int limit = 0, bool stripTrailingEmpties = true) const;
        VStringVector split(const VCodePoint& delimiter, int limit = 0, bool stripTrailingEmpties = true) const;
        void trim();
        void copyToBuffer(char* toBuffer, int bufferSize) const;
        void copyFromBuffer(const char* fromBuffer, int startIndex, int endIndex);
        void copyFromCString(const char* fromBuffer);
        void copyToPascalString(char* pascalBuffer) const;
        void copyFromPascalString(const char* pascalBuffer);
        void setFourCharacterCode(Vu32 fourCharacterCode);
        Vu32 getFourCharacterCode() const;

#ifdef VAULT_VARARG_STRING_FORMATTING_SUPPORT

        void vaFormat(const char* formatText, va_list args);
#endif

        void preflight(int stringLength);
        void preflightWithSimulatedFailure();
        char* buffer();
        Vu8* getDataBuffer();
        const Vu8* getDataBufferConst() const;
        char* orphanDataBuffer();
        void postflight(int stringLength);

        friend inline bool operator==(const VString& lhs, const VString& rhs);
        friend inline bool operator==(const VString& lhs, const char* rhs);
        friend inline bool operator==(const char* lhs, const VString& rhs);
        friend inline bool operator==(const VString& lhs, char rhs);

        friend inline bool operator!=(const VString& lhs, const VString& rhs);
        friend inline bool operator!=(const VString& lhs, const char* rhs);
        friend inline bool operator!=(const char* lhs, const VString& rhs);
        friend inline bool operator!=(const VString& lhs, char rhs);

        friend inline bool operator<(const VString& lhs, const VString& rhs);
        friend inline bool operator<(const VString& lhs, const char* rhs);
        friend inline bool operator<(const char* lhs, const VString& rhs);

        friend inline bool operator<=(const VString& lhs, const VString& rhs);
        friend inline bool operator<=(const VString& lhs, const char* rhs);
        friend inline bool operator<=(const char* lhs, const VString& rhs);

        friend inline bool operator>=(const VString& lhs, const VString& rhs);
        friend inline bool operator>=(const VString& lhs, const char* rhs);
        friend inline bool operator>=(const char* lhs, const VString& rhs);

        friend inline bool operator>(const VString& lhs, const VString& rhs);
        friend inline bool operator>(const VString& lhs, const char* rhs);
        friend inline bool operator>(const char* lhs, const VString& rhs);

    private:

        void _setLength(int stringLength);
        Vs64 _parseSignedInteger() const;
        Vu64 _parseUnsignedInteger() const;

        void _assertInvariant() const;

#ifdef VAULT_VARARG_STRING_FORMATTING_SUPPORT

        static int _determineSprintfLength(const char* formatText, va_list args);
#endif

        void _assignFromUTF16WideString(const std::wstring& utf16WideString);

#ifdef VAULT_CORE_FOUNDATION_SUPPORT
        void _assignFromCFString(const CFStringRef& s);
#endif

        /*
        New Vault 4.0 feature: SSO (small string optimization).
        Prior to 4.0, VString already optimized empty strings, avoiding heap allocation for that case, and dealing
        with a few special cases around not having a buffer. It also took care to allocate needed heap space in
        chunks so as to avoid excessive re-allocation for strings that grew repeatedly.
        With 4.0, the SSO feature means that for small strings ( <= 6 characters in a 32-bit build, <= 14 characters
        in a 64-bit build) it can store the string data internally inside the VString without allocating a heap buffer,
        and without adding any new size overhead to VString itself. In short, the "buffer size" and "buffer pointer"
        instance variables used to manage the heap buffer have their space inside VString re-purposed for storing
        the characters of the short string. If the string gets too large, then heap allocation is required as before.
        
        Internally, we use a union to overlay the data, and have an internal flag in the union, mUsingInternalBuffer,
        that tells us which buffer (and which part of the union) is in effect. To make most efficient use of space
        and avoid adding overhead, I have carefully examined how the compilers lay out and align the data, and I have
        ordered the union data to avoid bloat. If not for that concern, I would have put mStringLength, mNumCodePoints,
        and mUsingInternalBuffer outside the union since they apply to both parts of the union; however, that would have
        an the effect on union alignment on 64-bit of wasting several bytes. So instead, those instance variables
        are overlaid in both parts of the union, or put in the first part, but only the ones named in the first ("mI")
        part are referenced in the code.
        */
        
        // The internal buffer lengths are carefully chosen to fit within the existing object footprint's unused space.
        // 32-bit and 64-bit builds have different alignment/padding, so they have different amounts of unused space.
        // For testing, you can set the size to 1 to prevent use of the internal buffer other than for empty strings.
        #ifdef VCOMPILER_64BIT
            #define VSTRING_INTERNAL_BUFFER_SIZE 15
        #else
            #define VSTRING_INTERNAL_BUFFER_SIZE 7
        #endif

        // Internal low-level utility functions for bookkeeping the union data.
        
        void _construct();
        const char* _get() const { return mU.mI.mUsingInternalBuffer ? mU.mI.mInternalBuffer : mU.mX.mHeapBufferPtr; }
        char* _set() { return mU.mI.mUsingInternalBuffer ? mU.mI.mInternalBuffer : mU.mX.mHeapBufferPtr; }
        int _getBufferLength() const { return mU.mI.mUsingInternalBuffer ? VSTRING_INTERNAL_BUFFER_SIZE : mU.mX.mHeapBufferLength; }
        void _determineNumCodePoints() const;

        // Finally, the union that defines our internal structure.
        union {

            // When mI.mUsingInternalBuffer == true, we use mI.mInternalBuffer to store the string data.
            struct {
                int         mStringLength;                                  
                mutable int mNumCodePoints;                                 
                bool        mUsingInternalBuffer : 1;                       
                int         mPadBits : 7;                                   
                char        mInternalBuffer[VSTRING_INTERNAL_BUFFER_SIZE];  
            } mI; 
            
            // When mI.mUsingInternalBuffer == false, we use mX.mHeapBufferLength and mX.mHeapBufferPtr to store the string data.
            struct {
                int         mStringLength_Alias;                            
                int         mNumCodePoints_Alias;                           
                int         mHeapBufferLength;                              
                char*       mHeapBufferPtr;                                 
            } mX; 

        } mU; 
        
        friend class VStringUnit; 
};

inline bool operator==(const VString& lhs, const VString& rhs) { return ::strcmp(lhs, rhs) == 0; }      
inline bool operator==(const VString& lhs, const char* rhs) { return ::strcmp(lhs, rhs) == 0; }         
inline bool operator==(const char* lhs, const VString& rhs) { return ::strcmp(lhs, rhs) == 0; }         
inline bool operator==(const VString& lhs, char rhs) { return (lhs.length() == 1) && (lhs.charAt(0) == rhs); }    

inline bool operator!=(const VString& lhs, const VString& rhs) { return !operator==(lhs, rhs); }    
inline bool operator!=(const VString& lhs, const char* rhs) { return !operator==(lhs, rhs); }       
inline bool operator!=(const char* lhs, const VString& rhs) { return !operator==(lhs, rhs); }       
inline bool operator!=(const VString& lhs, char rhs) { return !operator==(lhs, rhs); }              

inline bool operator<(const VString& lhs, const VString& rhs) { return ::strcmp(lhs, rhs) < 0; }    
inline bool operator<(const VString& lhs, const char* rhs) { return ::strcmp(lhs, rhs) < 0; }       
inline bool operator<(const char* lhs, const VString& rhs) { return ::strcmp(lhs, rhs) < 0; }       

inline bool operator<=(const VString& lhs, const VString& rhs) { return !operator>(lhs, rhs); } 
inline bool operator<=(const VString& lhs, const char* rhs) { return !operator>(lhs, rhs); }    
inline bool operator<=(const char* lhs, const VString& rhs) { return !operator>(lhs, rhs); }    

inline bool operator>=(const VString& lhs, const VString& rhs) { return !operator<(lhs, rhs); } 
inline bool operator>=(const VString& lhs, const char* rhs) { return !operator<(lhs, rhs); }    
inline bool operator>=(const char* lhs, const VString& rhs) { return !operator<(lhs, rhs); }    

inline bool operator>(const VString& lhs, const VString& rhs) { return operator<(rhs, lhs); }   
inline bool operator>(const VString& lhs, const char* rhs) { return operator<(rhs, lhs); }      
inline bool operator>(const char* lhs, const VString& rhs) { return operator<(rhs, lhs); }      

inline std::istream& operator>>(std::istream& in, VString& s) { s.readFromIStream(in); return in; }        
inline std::ostream& operator<<(std::ostream& out, const VString& s) { return out << s.chars(); }   
inline VString& operator<<(VString& s, std::istream& in) { s.appendFromIStream(in); return s; }     

inline VString& operator<<(VString& s, const char* in) { s += in; return s; }   
inline VString& operator<<(VString& s, int i) { s += i; return s; }     
inline VString& operator<<(VString& s, Vu8 i) { s += i; return s; }     
inline VString& operator<<(VString& s, Vs8 i) { s += i; return s; }     
inline VString& operator<<(VString& s, Vu16 i) { s += i; return s; }    
inline VString& operator<<(VString& s, Vs16 i) { s += i; return s; }    
inline VString& operator<<(VString& s, Vu32 i) { s += i; return s; }    

#ifndef Vx32_IS_xINT /* don't redefine if types are same */
inline VString& operator<<(VString& s, Vs32 i) { s += i; return s; }    
#endif /* not Vx32_IS_xINT */

inline VString& operator<<(VString& s, Vu64 i) { s += i; return s; }    

#ifndef Vx64_IS_xINT /* don't redefine if types are same */
inline VString& operator<<(VString& s, Vs64 i) { s += i; return s; }    
#endif /* not Vx64_IS_xINT */

inline VString& operator<<(VString& s, VDouble f) { s += f; return s; } 

#endif /* vstring_h */