UTString.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program is free software; you can redistribute it and/or modify it under the terms of the
// GNU General Public License as published by the Free Software Foundation, version 2.0 of the
// License.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_STRING_H_
#define _UT_STRING_H_


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTBuffer.h"


//==================================================================================================
//=== Constants
//==================================================================================================
enum line_ending_type_t
{
    eLINEENDING_unix,
    eLINEENDING_dos,
    eLINEENDING_native
};


//==================================================================================================
class UT_EXPORT String_t
//==================================================================================================
: private Buffer_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                  String_t();

    inline                  String_t( byte* buffer, int buffer_size );

                            String_t(stringliteral* string);

                            String_t(const utf8* string);

    inline                  String_t(const String_t& copy);

    inline                  String_t(const wchar_t* string);

    inline int              LengthBytes() const;

    inline int              LengthChars() const;

    inline bool             IsEmpty() const;

    inline void             MakeEmpty();

    inline bool             IsASCII() const;

    void                    ToASCII(    out SimpleTypedBuffer_t<ascii7>* buffer,
                                        bool escape_all,
                                        const ascii7* escape_also ) const;

    inline Status_t         FromEscapedASCII(   const ascii7* ascii,
                                                ascii7 stop_at = 0,
                                                int length = -1 );

    Status_t                AppendFromEscapedASCII( const ascii7* ascii,
                                                    ascii7 stop_at = 0,
                                                    int length = -1 );

    void                    ToWChar(out SimpleTypedBuffer_t<wchar_t>* buffer) const;

    inline const utf8*      UTF8() const;

    inline stringliteral*   ConstChars() const;

    inline                  operator const utf8*() const;

    void                    SetAndBorrow(stringliteral* set);

    inline Status_t         Set(stringliteral* set);

    inline const String_t&  operator =(stringliteral* set);

    Status_t                Set(const utf8* set);

    inline const String_t&  operator =(const utf8* set);

    void                    Set(const String_t& set);

    inline const String_t&  operator =(const String_t& set);

    Status_t                Set(const wchar_t* set);

    inline const String_t&  operator =(const wchar_t* set);

    Status_t                SetLengthLimited( const utf8* set, int num_chars );

    void                    GetLeft( int length_chars, out String_t* left ) const;

    void                    GetRight( int length_chars, out String_t* right ) const;

    String_t                Left(int length_chars) const;

    String_t                Right(int length_chars) const;

    inline bool             Printf( stringliteral* format, ... );

    inline bool             PrintfAppend( stringliteral* format, ... );

    inline bool             VPrintf( stringliteral* format, va_list args );

    inline bool             VPrintfAppend( stringliteral* format, va_list args );

    inline void             PrintByteArray( stringliteral* format,
                                            stringliteral* separator,
                                            const byte* data,
                                            int data_length );

    void                    PrintByteArrayAppend(   stringliteral* format,
                                                    stringliteral* separator,
                                                    const byte* data,
                                                    int data_length );

    inline void             PrintByteArray( stringliteral* format,
                                            stringliteral* separator,
                                            const Buffer_t& buffer );

    inline void             PrintByteArrayAppend(   stringliteral* format,
                                                    stringliteral* separator,
                                                    const Buffer_t& buffer );

    void                    SetLineEndings(line_ending_type_t line_ending_type);

    static bool             DoLineEndingsMatch( const utf8* string,
                                                line_ending_type_t line_ending = eLINEENDING_native,
                                                out bool* ended_with_line_ending = NULL );

    inline Status_t         Append(stringliteral* append);

    inline void             operator +=(stringliteral* append);

    Status_t                Append(const utf8* append);

    inline void             operator +=(const utf8* append);

    void                    Append(const String_t& append);

    inline void             operator +=(const String_t& append);

    inline String_t         operator +(stringliteral* append) const;

    inline String_t         operator +(const utf8* append) const;

    inline String_t         operator +(const String_t& append) const;

    inline Status_t         Prepend(stringliteral* prepend);

    Status_t                Prepend(const utf8* prepend);

    void                    Prepend(const String_t& prepend);

    void                    RemoveLeft(int length_chars);

    void                    RemoveRight(int length_chars);

    inline void             operator -=(int length_chars);

    inline String_t         operator -(int length_char) const;

    void                    Remove( const utf8* position_within_string, int bytes_to_remove );

    inline Status_t         ReplaceLeft( int remove_length_chars, stringliteral* replace );

    Status_t                ReplaceLeft( int remove_length_chars, const utf8* replace_with );

    void                    ReplaceLeft( int remove_length_chars, const String_t& replace_with );

    inline Status_t         ReplaceRight( int remove_length_chars, stringliteral* replace );

    Status_t                ReplaceRight( int remove_length_chars, const utf8* replace_with );

    void                    ReplaceRight( int remove_length_chars, const String_t& replace_with );

    void                    RemoveWhitespace( bool start = true, bool end = true );

    inline bool             Equals(stringliteral* compare) const;

    inline bool             operator ==(stringliteral* compare) const;

    inline bool             operator !=(stringliteral* compare) const;

    bool                    Equals(const utf8* compare) const;

    inline bool             operator ==(const utf8* compare) const;

    inline bool             operator !=(const utf8* compare) const;

    bool                    Equals(const String_t& compare) const;

    inline bool             operator ==(const String_t& compare) const;

    inline bool             operator !=(const String_t& compare) const;

    inline bool             EqualsIgnoreCase(stringliteral* compare) const;

    inline bool             EqualsIgnoreCase(const utf8* compare) const;

    bool                    EqualsIgnoreCase(const String_t& compare) const;

    inline bool             LeftEquals(stringliteral* compare) const;

    bool                    LeftEquals(const utf8* compare) const;

    inline bool             LeftEquals(const String_t& compare) const;

    inline bool             RightEquals(stringliteral* compare) const;

    inline bool             RightEquals(const utf8* compare) const;

    inline bool             RightEquals(const String_t& compare) const;

    inline bool             LeftEqualsIgnoreCase(stringliteral* compare) const;

    bool                    LeftEqualsIgnoreCase(const utf8* compare) const;

    inline bool             LeftEqualsIgnoreCase(const String_t& compare) const;

    inline bool             RightEqualsIgnoreCase(stringliteral* compare) const;

    inline bool             RightEqualsIgnoreCase(const utf8* compare) const;

    inline bool             RightEqualsIgnoreCase(const String_t& compare) const;

    inline int              Compare( stringliteral* compare, int char_limit = -1 ) const;

    int                     Compare( const utf8* compare, int char_limit = -1 ) const;

    inline int              Compare( const String_t& compare, int char_limit = -1 ) const;

    inline int              CompareIgnoreCase(  stringliteral* compare,
                                                int char_limit = -1,
                                                bool numeric_sort_numbers = true ) const;

    inline int              CompareIgnoreCase(  const utf8* compare,
                                                int char_limit = -1,
                                                bool numeric_sort_numbers = true ) const;

    inline int              CompareIgnoreCase(  const String_t& compare,
                                                int char_limit = -1,
                                                bool numeric_sort_numbers = true ) const;

    inline bool             operator <(const String_t& compare) const;

    inline bool             operator <=(const String_t& compare) const;

    inline bool             operator >(const String_t& compare) const;

    inline bool             operator >=(const String_t& compare) const;

    static int              CountUTF8Chars(
                                    const utf8* string,
                                    int stop_at_count = -1,
                                    out int* byte_count = NULL,
                                    bool stop_at_count_is_byte_limit = false
                                    );

    inline int              FindSubstringOffsetChars(   stringliteral* find,
                                                        bool case_sensitive = true,
                                                        int start_at_offset = 0,
                                                        bool front_to_back = true );

    int                     FindSubstringOffsetChars(   const utf8* find,
                                                        bool case_sensitive = true,
                                                        int start_at_offset = 0,
                                                        bool front_to_back = true );

    inline int              FindSubstringOffsetChars(   const String_t& find,
                                                        bool case_sensitive = true,
                                                        int start_at_offset = 0,
                                                        bool front_to_back = true );

    inline int              FindSubstringOffsetBytes(   stringliteral* find,
                                                        bool case_sensitive = true,
                                                        int start_at_offset = 0,
                                                        bool front_to_back = true );

    int                     FindSubstringOffsetBytes(   const utf8* find,
                                                        bool case_sensitive = true,
                                                        int start_at_offset = 0,
                                                        bool front_to_back = true );

    inline int              FindSubstringOffsetBytes(   const String_t& find,
                                                        bool case_sensitive = true,
                                                        int start_at_offset = 0,
                                                        bool front_to_back = true );

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    static int              CountWChars( const wchar_t* string, int stop_at_count );
                                // Counts the wchar_t's in a wchar_t* string.  If stop_at_count is
                                // -1, all characters are counted up to the terminating null
                                // character.  The terminating null character is not included in the
                                // count.  If stop_at_count is not -1, the count will stop at and
                                // return that character count.  If wchar_t is defined to be more
                                // than 21 bits in size, CountWChars will return -1 if a character
                                // is found which is out of bounds.
    bool                    VPrintfUtil( stringliteral* format, va_list args, bool append );
                                // Utility function to handle the common implementation of the
                                // variety (va_list and append) of Printf variants.
    void                    VPrintfIntegerUtil( uint64 value,
                                                uint flags,     // STVP_FLAG_* in String.cpp
                                                uint integer_base,
                                                int minimum_field_width,
                                                uint precision_value );
                                // Utility function used by VPrintfUtil to handle rendering an
                                // integer.
    void                    VPrintfStatusUtil(  const Status_t& status,
                                                out Buffer_t* status_string_buffer );
                                // Utility function used by VPrintfUtil to handle rendering a
                                // Status_t.
    bool                    RightEqualsUtil(    const utf8* compare,
                                                int right_char_count,
                                                bool ignore_case ) const;
                                // Utility function used by the various right comparison functions.
    static int              CompareUTF8IgnoreCase(  const utf8* self,
                                                    const utf8* compare,
                                                    bool stop_at_compare_end,
                                                    int char_limit,
                                                    bool numeric_sort_numbers );
                                // Utility function used by the various case-insensitive comparison
                                // functions.  If char_limit is not -1, the comparison stops and
                                // returns 0 after the specified number of characters.

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    int                     m_length_bytes;
    int                     m_length_chars;
    bool                    m_const;
    static const utf8       ms_empty[1];
};


//==================================================================================================
class UT_EXPORT RefCountedString_t
//==================================================================================================
: public String_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline      RefCountedString_t(const utf8* string);

    inline      RefCountedString_t(stringliteral* string);

    inline      RefCountedString_t(const String_t& copy);

    inline void AddReference();

    inline void RemoveReference();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    int32       m_ref_count;
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class String_t
//===
//==================================================================================================
//==================================================================================================
inline
String_t::String_t()
: Buffer_t( const_cast<byte*>( reinterpret_cast<const byte*>(&ms_empty[0]) ), 1 )
{
    m_length_bytes = 0;
    m_length_chars = 0;
    m_const = true;
}


inline
String_t::String_t( byte* buffer, int buffer_size )
: Buffer_t( buffer, buffer_size )
{
    assert(buffer_size > 0);
    m_length_bytes = 0;
    m_length_chars = 0;
    Buffer(1)[0] = 0;
    m_const = false;
}


inline
String_t::String_t(const String_t& copy)
{
    m_length_bytes = copy.m_length_bytes;
    m_length_chars = copy.m_length_chars;
    m_const = false;

    utf8* dest = reinterpret_cast<utf8*>( Buffer(m_length_bytes+1) );
    memcpy( dest, copy.ReadOnlyBuffer(), m_length_bytes+1 );
}


inline
String_t::String_t(const wchar_t* string)
{
    m_const = false;
    Set(string);
}


inline int
String_t::LengthBytes() const
{
    return m_length_bytes;
}


inline int
String_t::LengthChars() const
{
    return m_length_chars;
}


inline bool
String_t::IsEmpty() const
{
    return (m_length_bytes == 0);
}


inline void
String_t::MakeEmpty()
{
    if(m_length_bytes)
        Set(ms_empty);
}


inline bool
String_t::IsASCII() const
{
    return (m_length_bytes == m_length_chars);
}


inline Status_t
String_t::FromEscapedASCII( const ascii7* ascii,
                            ascii7 stop_at,
                            int length )
{
    MakeEmpty();
    return AppendFromEscapedASCII( ascii, stop_at, length );
}


inline
String_t::operator const utf8*() const
{
    return reinterpret_cast<const utf8*>( ReadOnlyBuffer() );
}


inline const utf8*
String_t::UTF8() const
{
    return reinterpret_cast<const utf8*>( ReadOnlyBuffer() );
}


inline stringliteral*
String_t::ConstChars() const
{
    return reinterpret_cast<stringliteral*>( ReadOnlyBuffer() );
}


inline Status_t
String_t::Set(stringliteral* set)
{
    return Set( reinterpret_cast<const utf8*>(set) );
}


inline const String_t&
String_t::operator =(stringliteral* set)
{
    #if !DEBUG
        Set( reinterpret_cast<const utf8*>(set) );
    #else
        assert( Set( reinterpret_cast<const utf8*>(set) ).Success() );
    #endif
    return *this;
}


inline const String_t&
String_t::operator =(const utf8* set)
{
    #if !DEBUG
        Set(set);
    #else
        assert( Set(set).Success() );
    #endif
    return *this;
}


inline const String_t&
String_t::operator =(const String_t& set)
{
    Set(set);
    return *this;
}


inline const String_t&
String_t::operator =(const wchar_t* set)
{
    Set(set);
    return *this;
}


inline bool
String_t::Printf( stringliteral* format, ... )
{
    va_list args;
    va_start( args, format );

    return VPrintfUtil( format, args, false );
}



inline bool
String_t::PrintfAppend( stringliteral* format, ... )
{
    va_list args;
    va_start( args, format );

    return VPrintfUtil( format, args, true );
}


inline bool
String_t::VPrintf( stringliteral* format, va_list args )
{
    return VPrintfUtil( format, args, false );
}


inline bool
String_t::VPrintfAppend( stringliteral* format, va_list args )
{
    return VPrintfUtil( format, args, true );
}


inline void
String_t::PrintByteArray(   stringliteral* format,
                            stringliteral* separator,
                            const byte* data,
                            int data_length )
{
    MakeEmpty();
    PrintByteArrayAppend( format, separator, data, data_length );
}


inline void
String_t::PrintByteArray(   stringliteral* format,
                            stringliteral* separator,
                            const Buffer_t& buffer )
{
    MakeEmpty();
    PrintByteArrayAppend( format, separator, buffer.ReadOnlyBuffer(), buffer.ValidSize() );
}


inline void
String_t::PrintByteArrayAppend( stringliteral* format,
                                stringliteral* separator,
                                const Buffer_t& buffer )
{
    PrintByteArrayAppend( format, separator, buffer.ReadOnlyBuffer(), buffer.ValidSize() );
}


inline Status_t
String_t::Append(stringliteral* append)
{
    return Append( reinterpret_cast<const utf8*>(append) );
}


inline void
String_t::operator +=(stringliteral* append)
{
    #if !DEBUG
        Append( reinterpret_cast<const utf8*>(append) );
    #else
        assert( Append( reinterpret_cast<const utf8*>(append) ).Success() );
    #endif
}


inline void
String_t::operator +=(const utf8* append)
{
    #if !DEBUG
        Append(append);
    #else
        assert( Append(append).Success() );
    #endif
}


inline void
String_t::operator +=(const String_t& append)
{
    Append(append);
}


inline String_t
String_t::operator +(stringliteral* append) const
{
    String_t local_copy(*this);
    #if !DEBUG
        local_copy.Append(append);
    #else
        assert( local_copy.Append( reinterpret_cast<const utf8*>(append) ).Success() );
    #endif
    return local_copy;
}


inline String_t
String_t::operator +(const utf8* append) const
{
    String_t local_copy(*this);
    #if !DEBUG
        local_copy.Append(append);
    #else
        assert( local_copy.Append(append).Success() );
    #endif
    return local_copy;
}


inline String_t
String_t::operator +(const String_t& append) const
{
    String_t local_copy(*this);
    local_copy.Append(append);
    return local_copy;
}


inline Status_t
String_t::Prepend(stringliteral* prepend)
{
    return Prepend( reinterpret_cast<const utf8*>(prepend) );
}


inline void
String_t::operator -=(int length_chars)
{
    RemoveRight(length_chars);
}


inline String_t
String_t::operator -(int length_char) const
{
    String_t local_copy(*this);
    local_copy -= length_char;
    return local_copy;
}


inline Status_t
String_t::ReplaceLeft( int remove_length_chars, stringliteral* replace )
{
    return ReplaceLeft( remove_length_chars, reinterpret_cast<const utf8*>(replace) );
}


inline Status_t
String_t::ReplaceRight( int remove_length_chars, stringliteral* replace )
{
    return ReplaceRight( remove_length_chars, reinterpret_cast<const utf8*>(replace) );
}


inline bool
String_t::Equals(stringliteral* compare) const
{
    return Equals( reinterpret_cast<const utf8*>(compare) );
}


inline bool
String_t::operator ==(stringliteral* compare) const
{
    return Equals( reinterpret_cast<const utf8*>(compare) );
}


inline bool
String_t::operator !=(stringliteral* compare) const
{
    return !Equals( reinterpret_cast<const utf8*>(compare) );
}


inline bool
String_t::operator ==(const utf8* compare) const
{
    return Equals(compare);
}


inline bool
String_t::operator !=(const utf8* compare) const
{
    return !Equals(compare);
}


inline bool
String_t::operator ==(const String_t& compare) const
{
    return Equals(compare);
}


inline bool
String_t::operator !=(const String_t& compare) const
{
    return !Equals(compare);
}


inline bool
String_t::EqualsIgnoreCase(stringliteral* compare) const
{
    return (CompareUTF8IgnoreCase(  UTF8(),
                                    reinterpret_cast<const utf8*>(compare),
                                    false,
                                    -1,
                                    false ) == 0);
}


inline bool
String_t::EqualsIgnoreCase(const utf8* compare) const
{
    return (CompareUTF8IgnoreCase( UTF8(), compare, false, -1, false ) == 0);
}


inline bool
String_t::LeftEquals(stringliteral* compare) const
{
    return LeftEquals( reinterpret_cast<const utf8*>(compare) );
}


inline bool
String_t::LeftEquals(const String_t& compare) const
{
    return LeftEquals( compare.UTF8() );
}


inline bool
String_t::RightEquals(stringliteral* compare) const
{
    return RightEqualsUtil( reinterpret_cast<const utf8*>(compare),
                            CountUTF8Chars( reinterpret_cast<const utf8*>(compare) ),
                            false );
}


inline bool
String_t::RightEquals(const utf8* compare) const
{
    return RightEqualsUtil( compare, CountUTF8Chars(compare), false );
}


inline bool
String_t::RightEquals(const String_t& compare) const
{
    return RightEqualsUtil( compare.UTF8(), compare.LengthChars(), false );
}


inline bool
String_t::LeftEqualsIgnoreCase(stringliteral* compare) const
{
    return (CompareUTF8IgnoreCase(  UTF8(),
                                    reinterpret_cast<const utf8*>(compare),
                                    true,
                                    -1,
                                    false ) == 0);
}


inline bool
String_t::LeftEqualsIgnoreCase(const String_t& compare) const
{
    return (CompareUTF8IgnoreCase( UTF8(), compare.UTF8(), true, -1, false ) == 0);
}


inline bool
String_t::RightEqualsIgnoreCase(stringliteral* compare) const
{
    return RightEqualsUtil( reinterpret_cast<const utf8*>(compare),
                            CountUTF8Chars( reinterpret_cast<const utf8*>(compare) ),
                            true );
}


inline bool
String_t::RightEqualsIgnoreCase(const utf8* compare) const
{
    return RightEqualsUtil( compare, CountUTF8Chars(compare), true );
}


inline bool
String_t::RightEqualsIgnoreCase(const String_t& compare) const
{
    return RightEqualsUtil( compare.UTF8(), compare.LengthChars(), true );
}


inline int
String_t::Compare( stringliteral* compare, int char_limit ) const
{
    return Compare( reinterpret_cast<const utf8*>(compare), char_limit );
}


inline int
String_t::Compare( const String_t& compare, int char_limit ) const
{
    return Compare( compare.UTF8(), char_limit );
}


inline int
String_t::CompareIgnoreCase(    stringliteral* compare,
                                int char_limit,
                                bool numeric_sort_numbers  ) const
{
    return CompareUTF8IgnoreCase(   UTF8(),
                                    reinterpret_cast<const utf8*>(compare),
                                    false,
                                    char_limit,
                                    numeric_sort_numbers );
}


inline int
String_t::CompareIgnoreCase(    const utf8* compare,
                                int char_limit,
                                bool numeric_sort_numbers ) const
{
    return CompareUTF8IgnoreCase( UTF8(), compare, false, char_limit, numeric_sort_numbers );
}


inline int
String_t::CompareIgnoreCase(    const String_t& compare,
                                int char_limit,
                                bool numeric_sort_numbers ) const
{
    return CompareUTF8IgnoreCase( UTF8(), compare.UTF8(), false, char_limit, numeric_sort_numbers );
}


inline bool
String_t::operator <(const String_t& compare) const
{
    return (CompareUTF8IgnoreCase( UTF8(), compare.UTF8(), false, -1, true ) < 0);
}


inline bool
String_t::operator <=(const String_t& compare) const
{
    return (CompareUTF8IgnoreCase( UTF8(), compare.UTF8(), false, -1, true ) <= 0);
}


inline bool
String_t::operator >(const String_t& compare) const
{
    return (CompareUTF8IgnoreCase( UTF8(), compare.UTF8(), false, -1, true ) > 0);
}


inline bool
String_t::operator >=(const String_t& compare) const
{
    return (CompareUTF8IgnoreCase( UTF8(), compare.UTF8(), false, -1, true ) >= 0);
}


inline int
String_t::FindSubstringOffsetChars( stringliteral* find,
                                    bool case_sensitive,
                                    int start_at_offset,
                                    bool front_to_back )
{
    return FindSubstringOffsetChars(    reinterpret_cast<const utf8*>(find),
                                        case_sensitive,
                                        start_at_offset,
                                        front_to_back );
}


inline int
String_t::FindSubstringOffsetChars( const String_t& find,
                                    bool case_sensitive,
                                    int start_at_offset,
                                    bool front_to_back )
{
    return FindSubstringOffsetChars( find.UTF8(), case_sensitive, start_at_offset, front_to_back );
}


inline int
String_t::FindSubstringOffsetBytes( stringliteral* find,
                                    bool case_sensitive,
                                    int start_at_offset,
                                    bool front_to_back )
{
    return FindSubstringOffsetBytes(    reinterpret_cast<const utf8*>(find),
                                        case_sensitive,
                                        start_at_offset,
                                        front_to_back );
}


inline int
String_t::FindSubstringOffsetBytes( const String_t& find,
                                    bool case_sensitive,
                                    int start_at_offset,
                                    bool front_to_back )
{
    return FindSubstringOffsetBytes( find.UTF8(), case_sensitive, start_at_offset, front_to_back );
}




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations: class RefCountedString_t
//===
//==================================================================================================
//==================================================================================================
inline
RefCountedString_t::RefCountedString_t(const utf8* string)
: String_t(string)
{
    m_ref_count = 1;
}


inline
RefCountedString_t::RefCountedString_t(stringliteral* string)
: String_t(string)
{
    m_ref_count = 1;
}


inline
RefCountedString_t::RefCountedString_t(const String_t& copy)
: String_t(copy)
{
    m_ref_count = 1;
}


inline void
RefCountedString_t::AddReference()
{
    atomic_add( &m_ref_count, 1 );
}


inline void
RefCountedString_t::RemoveReference()
{
    if(atomic_add( &m_ref_count, -1 ) == 0)
        delete this;
}


#endif // _UT_STRING_H_