it_bus/string.h

#ifndef _IT_BUS_STRING_H_
#define _IT_BUS_STRING_H_

//  @Copyright (c) 2004 IONA Technologies PLC. All Rights Reserved.
//

#include <stdio.h>
#include <it_cal/types.h>
#include <it_dsa/string.h>
#include <it_bus/api_defines.h>

namespace IT_Bus
{
    class StringBody;          // Private implementation details.
    
    class IT_AFC_API String
    {
      public:
        
        enum { npos = ULONG_MAX };
        enum { icu_npos = LONG_MAX };

        typedef char*       iterator;
        typedef const char* const_iterator;

        typedef IT_UShort UChar;

        // The empty string.
        // 
        static const String EMPTY;

        // Constructors
        //
        String(
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String(
            const char*          cb,
            size_t               n = npos,
            const char*          encoding = 0,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String(
            const char*          cb,
            bool                 c_str,
            size_t               n,
            const char*          encoding = 0,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String(
            size_t               n,
            char                 c,
            const char*          encoding = 0,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String(
            const String&    s,
            size_t               pos = 0,
            size_t               n   = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );
        String(
            const IT_String&     s,
            size_t               pos = 0,
            size_t               n   = npos,
            const char*          encoding = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );

        String(
            const char*          str,
            IT_StringRep::Policy policy,
            size_t               n = npos,
            const char*          encoding = 0,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        String(
            const UChar*         uchars,
            IT_StringRep::Policy policy,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
            
        String(
            const UChar*      sb,
            const IT_String&      encoding,            
            size_t                n = npos,
            IT_StringRep::Policy  policy = IT_StringRep::COPY,
            IT_ExceptionHandler&  eh = IT_EXCEPTION_HANDLER
        );

        String(
            const wchar_t*        wb,            
            size_t                n = npos,
            IT_StringRep::Policy  policy = IT_StringRep::COPY,
            IT_ExceptionHandler&  eh = IT_EXCEPTION_HANDLER
        );
        
        ~String();
        
        // Capacity
        //
        size_t size() const;
        size_t length() const;
        size_t max_size() const;

        void
        resize(
            size_t               n,
            char                 c  = '\0',
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        size_t 
        capacity() const;
        
        void
        reserve(
            size_t               res_arg = 0,
            IT_ExceptionHandler& eh      = IT_EXCEPTION_HANDLER
        );
        
        IT_Bool
        empty() const;
        
        // Copy and swap
        //
        size_t
        copy(
            char*                s,
            size_t               n,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;

        void
        swap(
            String& s
        );
        
        // char* operations
        //
        const char* c_str(
            const char* encoding = 0
        ) const;  // NUL-terminated
        
        const char* c_str(
            const char* encoding,
            size_t& len
        ) const;  // NUL-terminated

        const char*
        data() const;   // might not be NUL-terminated
        
        // IT_String operations
        //
        IT_String 
        get_it_string() const;

        operator IT_String() const;
                
        // utf16 buffer operations
        //
        const UChar*
        utf16_str() const;

        // Deprecated, for backwards compatibility.
        const UChar*
        utf16_str();
        
        // wchar_t* operations
        //
        const wchar_t*
        wchar_t_str() const;
        
        // Char encoding access
        //
        IT_String
        get_encoding() const;

        IT_Bool
        is_unicode() const;
        
        // Element access
        //
        char operator[](size_t index) const;
        char& operator[](size_t index);
        char at(size_t index) const;
        inline char& at(size_t index);
        
        // char* Iterators
        //
        iterator begin();
        const_iterator begin() const;
        iterator end();
        const_iterator end() const;
        
        // Assignment
        //
        String&
        operator=(
            const String& other
        );
        String&
        operator=(
            const IT_String& other
        );
        String&
        operator=(
            const char* str
        );
        String&
        operator=(
            char c
        );
        String&
        assign(
            const IT_String&     s,
            size_t               pos = 0,
            size_t               n   = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );
        String&
        assign(
            const String&     s,
            size_t               pos = 0,
            size_t               n   = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );
        String&
        assign(
            const char*          s,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        assign(
            size_t               n,
            char                 c,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        // Insertion
        //
        String&
        insert(
            size_t               pos,
            const String&     s,
            size_t               pos2 = 0,
            size_t               n    = npos,
            IT_ExceptionHandler& eh   = IT_EXCEPTION_HANDLER
        );
        String&
        insert(
            size_t               pos,
            const IT_String&     s,
            size_t               pos2 = 0,
            size_t               n    = npos,
            IT_ExceptionHandler& eh   = IT_EXCEPTION_HANDLER
        );
        String&
        insert(
            size_t               pos,
            const char*          s,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        insert(
            size_t               pos,
            size_t               n,
            char                 c,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        iterator
        insert(
            iterator             p,
            char                 c  = '\0',
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        void
        insert(
            iterator             p,
            size_t               n,
            char                 c,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        String&
        insert(
            size_t               pos,
            const UChar*         uchars,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        // Modifiers
        //
        String&
        operator+=(
            const IT_String& other
        );
        String&
        operator+=(
            const String& other
        );
        String&
        operator+=(
            const char* str
        );
        String&
        operator+=(
            char c
        );      
        String&
        append(
            const IT_String&     s,
            size_t               pos = 0,
            size_t               n   = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );
        String&
        append(
            const String&     s,
            size_t               pos = 0,
            size_t               n   = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );
        String&
        append(
            const char*          cb,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        append(
            size_t               n,
            char                 c,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        String&
        append(
            const UChar*         uchars,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        // Erasure
        //
        String&
        erase(
            size_t               pos = 0,
            size_t               n   = String::npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        );
        iterator
        erase(
            iterator             p,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        iterator
        erase(
            iterator             first,
            iterator             last,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        // Replacement
        //
        String&
        replace(
            size_t               pos,
            size_t               n,
            const String&    s,
            size_t               pos2 = 0,
            size_t               n2   = npos,
            IT_ExceptionHandler& eh   = IT_EXCEPTION_HANDLER
        );
        String&
        replace(
            size_t               pos,
            size_t               n,
            const char*          s,
            size_t               n2 = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        replace(
            size_t               pos,
            size_t               n,
            size_t               n2,
            char                 c,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        replace(
            iterator             i1,
            iterator             i2,
            const String&     s,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        replace(
            iterator             i1,
            iterator             i2,
            const char*          s,
            size_t               n  = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        String&
        replace(
            iterator             i1,
            iterator             i2,
            size_t               n,
            char                 c,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );

        String&
        replace(
            size_t               pos,
            size_t               n,
            const UChar*         uchars,
            size_t               n2 = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        );
        
        // Search
        //
        size_t
        find(
            const String& s,
            size_t           pos = 0
        ) const;
        size_t
        find(
            const char*          s,
            size_t               pos,
            size_t               n,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find(
            const char*          s,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find(
            char                 c,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;

        size_t
        rfind(
            const String& s,
            size_t           pos = npos
        ) const;
        size_t
        rfind(
            const char*          s,
            size_t               pos,
            size_t               n,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        rfind(
            const char*          s,
            size_t               pos = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        rfind(
            char                 c,
            size_t               pos = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        
        // Character set searching
        //
        size_t
        find_first_of(
            const String& s,
            size_t           pos = 0
        ) const;
        size_t
        find_first_of(
            const char*          s,
            size_t               pos,
            size_t               n,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_first_of(
            const char*          s,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_first_of(
            char                 c,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_last_of(
            const String& s,
            size_t           pos = npos
        ) const;
        size_t
        find_last_of(
            const char*          s,
            size_t               pos,
            size_t               n,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_last_of(
            const char*          s,
            size_t               pos = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_last_of(
            char                 c,
            size_t               pos = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_first_not_of(
            const String& s,
            size_t           pos = 0
        ) const;
        size_t
        find_first_not_of(
            const char*          s,
            size_t               pos,
            size_t               n,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_first_not_of(
            const char*          s,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_first_not_of(
            char                 c,
            size_t               pos = 0,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_last_not_of(
            const String& s,
            size_t           pos = npos
        ) const;
        size_t
        find_last_not_of(
            const char*          s,
            size_t               pos,
            size_t               n,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_last_not_of(
            const char*          s,
            size_t               pos = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        size_t
        find_last_not_of(
            char                 c,
            size_t               pos = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        
        // Substring
        //
        String
        substr(
            size_t               pos = 0,
            size_t               n   = npos,
            IT_ExceptionHandler& eh  = IT_EXCEPTION_HANDLER
        ) const;
        
        // Comparison / Predicates
        //
        int
        compare(
            const String& s
        ) const;
        
        int
        compare(
            size_t               pos1,
            size_t               n1,
            const String&    s,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;
        
        int
        compare(
            size_t               pos1,
            size_t               n1,
            const String&    s,
            size_t               pos2,
            size_t               n2,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;

        int
        compare(
            const char*          s,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;

        int
        compare(
            size_t               pos1,
            size_t               n1,
            const char*          s,
            size_t               n2 = npos,
            IT_ExceptionHandler& eh = IT_EXCEPTION_HANDLER
        ) const;        

        IT_ExceptionHandler&
        it_eh() const;
        
      private:

        char*
        c_ptr(
            const char* encoding = 0
        ) const;

        char*
        c_ptr(
            const char* encoding,
            size_t& len
        ) const;

        wchar_t*
        wchar_t_ptr() const;

        StringBody* m_body;
    };

    inline size_t
    String::max_size() const
    {
        return npos;
    }

    inline char
    String::operator[](
        size_t index
    ) const
    {
        return at(index);
    }

    inline char&
    String::at(
        size_t index
    )
    {
        return operator[](index);
    }

    inline String&
    String::operator=(
        const String& str
    )
    {
        return assign(str, 0, npos, it_eh());
    }

    inline String&
    String::operator=(
        const IT_String& str
    )
    {
        return assign(str, 0, npos, it_eh());
    }

    inline String&
    String::operator=(
        const char* str
    )
    {
        return assign(str, npos, it_eh());
    }

    inline String&
    String::operator=(
        char c
    )
    {
        return assign(1, c, it_eh());
    }

    inline String::iterator
    String::insert(
        String::iterator p,
        char                 c,
        IT_ExceptionHandler& eh
    )
    {
        insert(size_t(p - begin()), 1, c, eh);
        return p;
    }

    inline void
    String::insert(
        IT_String::iterator  p,
        size_t               n,
        char                 c,
        IT_ExceptionHandler& eh
    )
    {
        insert(size_t(p - begin()), n, c, eh);
    }

    inline String::iterator
    String::erase(
        String::iterator  p,
        IT_ExceptionHandler& eh
    )
    {
        erase(size_t(p - begin()), 1, eh);
        return p;
    }

    inline String::iterator
    String::erase(
        String::iterator first,
        String::iterator last,
        IT_ExceptionHandler& eh
    )
    {
        erase(size_t(first - begin()), size_t(last - first + 1), eh);
        return first;
    }

    inline String&
    String::operator+=(
        const String& str
    )
    {
        return append(str, 0, npos, it_eh());
    }

    inline String&
    String::operator+=(
        const IT_String& str
    )
    {
        return append(str, 0, npos, it_eh());
    }

    inline String&
    String::operator+=(
        const char* str
    )
    {
        return append(str, npos, it_eh());
    }

    inline String&
    String::operator+=(
        char c
    )
    {
        return append(1, c, it_eh());
    }

    inline int
    String::compare(
        size_t               pos1,
        size_t               n1,
        const String&    s,
        IT_ExceptionHandler& eh
    ) const
    {
        String s1(*this, pos1, n1, eh);
        return s1.compare(s);
    }

    inline int
    String::compare(
        size_t               pos1,
        size_t               n1,
        const String&    s,
        size_t               pos2,
        size_t               n2,
        IT_ExceptionHandler& eh
    ) const
    {
        String s1(*this, pos1, n1, eh), s2(s, pos2, n2, eh);
        return s1.compare(s2);
    }


    inline IT_Bool
    operator==(
        const String& s1,
        const String& s2
    )
    {
        return s1.compare(s2) == 0;
    }

    inline IT_Bool
    operator==(
        const String& s1,
        const char*   s2
    )
    {
        if(s1.is_unicode())
        {
            return s1.compare(String(s2, String::npos, "", s1.it_eh())) == 0;
        }
        else
        {
            return s1.compare(String(s2, String::npos, 0, s1.it_eh())) == 0;
        }
    }

    inline IT_Bool
    operator==(
        const char*   s1,
        const String& s2
    )
    {
        return s2 == s1;
    }

    inline IT_Bool
    operator==(
        const String&    s1,
        const IT_String& s2
    )
    {
        if(s1.is_unicode())
        {
            return s1.compare(String(s2, 0, String::npos, "",s1.it_eh())) == 0;
        }
        else
        {
            return s1.compare(String(s2, 0, String::npos, 0, s1.it_eh())) == 0;
        }
    }

    inline IT_Bool
    operator==(
        const IT_String& s1,
        const String&    s2
    )
    {
        return s2 == s1;
    }

    inline IT_Bool
    operator!=(
        const String& s1,
        const String& s2
    )
    {
        return !(s1 == s2);
    }

    inline IT_Bool
    operator!=(
        const String& s1,
        const char*   s2
    )
    {
        return !(s1 == s2);
    }

    inline IT_Bool
    operator!=(
        const char*   s1,
        const String& s2
    )
    {
        return !(s1 == s2);
    }

    inline IT_Bool
    operator!=(
        const String&    s1,
        const IT_String& s2
    )
    {
        return !(s1 == s2);
    }
    
    inline IT_Bool
    operator!=(
        const IT_String& s1,
        const String&    s2
    )
    {
        return !(s1 == s2);
    }
    

    inline String
    operator+(
        const String& s1,
        const String& s2
    )
    {
        String newstr(s1, 0, String::npos, s1.it_eh());
        newstr += s2;
        return newstr;
    }

    inline String
    operator+(
        const char*   s1,
        const String& s2
    )
    {
        if(s2.is_unicode())
        {
            String newstr(s1, String::npos, "", s2.it_eh());
            newstr += s2;
            return newstr;
        }
        else
        {
            String newstr(s1, String::npos, 0, s2.it_eh());
            newstr += s2;
            return newstr;
        }
    }

    inline String
    operator+(
        const String& s1,
        const char*   s2
    )
    {
        String newstr(s1, 0, String::npos, s1.it_eh());
        
        if(s1.is_unicode())
        {
            newstr += String(s2, String::npos, "", s1.it_eh());
        }
        else
        {
            newstr += String(s2, String::npos, 0, s1.it_eh());
        }
        return newstr;
    }

    inline String
    operator+(
        char          c,
        const String& s2
    )
    {
        if(s2.is_unicode())
        {
            String newstr(1, c, "", s2.it_eh());
            newstr += s2;
            return newstr;
        }
        else
        {
            String newstr(1, c, 0, s2.it_eh());
            newstr += s2;
            return newstr;
        }
    }

    inline String
    operator+(
        const String& s,
        char          c
    )
    {
        String newstr(s, 0, String::npos, s.it_eh());
        
        if(s.is_unicode())
        {
            newstr += String(1, c, "", s.it_eh());
        }
        else
        {
            newstr += String(1, c, 0, s.it_eh());
        }
        return newstr;
    }

    inline String
    operator+(
        const IT_String& s1,
        const String& s2
    )
    {
        if(s2.is_unicode())
        {
            String newstr(s1, 0, String::npos, "", s1.it_eh());
            newstr += s2;
            return newstr;
        }
        else
        {
            String newstr(s1, 0, String::npos, 0, s1.it_eh());
            newstr += s2;
            return newstr;
        }
    }

    inline String
    operator+(
        const String& s1,
        const IT_String&   s2
    )
    {
        String newstr(s1, 0, String::npos, s1.it_eh());
        
        if(s1.is_unicode())
            newstr += String(s2, 0, String::npos, "", s1.it_eh());
        else
            newstr += String(s2, 0, String::npos, 0, s1.it_eh());
        return newstr;
    }
}


#ifndef IT_IOSTREAMS_FREE
inline IT_ostream& 
operator<<(
    IT_ostream& os, 
    const IT_Bus::String& buffer
)
{
    return os << (const char*) buffer.c_str();
}  
#endif 

#endif 

---