ustring.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */


#ifndef INCLUDED_RTL_USTRING_HXX
#define INCLUDED_RTL_USTRING_HXX

#include "sal/config.h"

#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <limits>
#include <new>
#include <ostream>
#include <utility>
#include <vector>

#if defined LIBO_INTERNAL_ONLY
#include <string_view>
#include <type_traits>
#endif

#include "rtl/ustring.h"
#include "rtl/string.hxx"
#include "rtl/stringutils.hxx"
#include "rtl/textenc.h"

#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
#include "config_global.h"
#include "rtl/stringconcat.hxx"
#endif

#ifdef RTL_STRING_UNITTEST
extern bool rtl_string_unittest_invalid_conversion;
#endif

// The unittest uses slightly different code to help check that the proper
// calls are made. The class is put into a different namespace to make
// sure the compiler generates a different (if generating also non-inline)
// copy of the function and does not merge them together. The class
// is "brought" into the proper rtl namespace by a typedef below.
#ifdef RTL_STRING_UNITTEST
#define rtl rtlunittest
#endif

namespace rtl
{

class OUStringBuffer;

#ifdef RTL_STRING_UNITTEST
#undef rtl
#endif

#if defined LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

template<std::size_t N> class SAL_WARN_UNUSED OUStringLiteral {
    static_assert(N != 0);
    static_assert(N - 1 <= std::numeric_limits<sal_Int32>::max(), "literal too long");
    friend class OUString;
    friend class OUStringConstExpr;

public:
#if HAVE_CPP_CONSTEVAL
    consteval
#else
    constexpr
#endif
    OUStringLiteral(char16_t const (&literal)[N]) {
        assertLayout();
        assert(literal[N - 1] == '\0');
        //TODO: Use C++20 constexpr std::copy_n (P0202R3):
        for (std::size_t i = 0; i != N; ++i) {
            more.buffer[i] = literal[i];
        }
    }

    constexpr sal_Int32 getLength() const { return more.length; }

    constexpr sal_Unicode const * getStr() const SAL_RETURNS_NONNULL { return more.buffer; }

    constexpr operator std::u16string_view() const { return {more.buffer, sal_uInt32(more.length)}; }

private:
    static constexpr void assertLayout() {
        // These static_asserts verifying the layout compatibility with rtl_uString cannot be class
        // member declarations, as offsetof requires a complete type, so defer them to here:
        static_assert(std::is_standard_layout_v<OUStringLiteral>);
        static_assert(offsetof(OUStringLiteral, str.refCount) == offsetof(OUStringLiteral, more.refCount));
        static_assert(offsetof(OUStringLiteral, str.length) == offsetof(OUStringLiteral, more.length));
        static_assert(offsetof(OUStringLiteral, str.buffer) == offsetof(OUStringLiteral, more.buffer));
    }

    struct Data {
        Data() = default;

        oslInterlockedCount refCount = 0x40000000; // SAL_STRING_STATIC_FLAG (sal/rtl/strimp.hxx)
        sal_Int32 length = N - 1;
        sal_Unicode buffer[N] = {}; //TODO: drop initialization for C++20 (P1331R2)
    };

    union {
        rtl_uString str;
        Data more = {};
    };
};

#if defined RTL_STRING_UNITTEST
namespace libreoffice_internal {
template<std::size_t N> struct ExceptConstCharArrayDetector<OUStringLiteral<N>> {};
template<std::size_t N> struct ExceptCharArrayDetector<OUStringLiteral<N>> {};
}
#endif

class OUString;
class OUStringConstExpr
{
public:
    template<std::size_t N> constexpr OUStringConstExpr(OUStringLiteral<N> const & literal):
        pData(const_cast<rtl_uString *>(&literal.str)) {}

    // prevent mis-use
    template<std::size_t N> constexpr OUStringConstExpr(OUStringLiteral<N> && literal)
        = delete;

    // no destructor necessary because we know we are pointing at a compile-time
    // constant OUStringLiteral, which bypasses ref-counting.

    constexpr std::u16string_view asView() const { return std::u16string_view(pData->buffer, pData->length); }

    inline operator const OUString&() const;

private:
    rtl_uString* pData;
};

#endif

/* ======================================================================= */

class SAL_WARN_UNUSED SAL_DLLPUBLIC_RTTI OUString
{
public:
    rtl_uString * pData;

    OUString()
    {
        pData = NULL;
        rtl_uString_new( &pData );
    }

    OUString( const OUString & str )
    {
        pData = str.pData;
        rtl_uString_acquire( pData );
    }

#if defined LIBO_INTERNAL_ONLY

    OUString( OUString && str ) noexcept
    {
        pData = str.pData;
        str.pData = nullptr;
        rtl_uString_new( &str.pData );
    }
#endif

    OUString( rtl_uString * str )
    {
        pData = str;
        rtl_uString_acquire( pData );
    }

    OUString( rtl_uString * str, __sal_NoAcquire )
        { pData = str; }

    explicit OUString( sal_Unicode value )
        : pData (NULL)
    {
        rtl_uString_newFromStr_WithLength( &pData, &value, 1 );
    }

#if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST_CONCAT
    // Catch inadvertent conversions to the above ctor (but still allow
    // construction from char literals):
    OUString(int) = delete;
    explicit OUString(char c):
        OUString(sal_Unicode(static_cast<unsigned char>(c)))
    {}
#endif

#if defined LIBO_INTERNAL_ONLY

    template<typename T> explicit OUString(
        T const & value,
        typename libreoffice_internal::CharPtrDetector<T, libreoffice_internal::Dummy>::TypeUtf16
            = libreoffice_internal::Dummy()):
        pData(nullptr)
    { rtl_uString_newFromStr(&pData, value); }

    template<typename T> explicit OUString(
        T & value,
        typename
        libreoffice_internal::NonConstCharArrayDetector<T, libreoffice_internal::Dummy>::TypeUtf16
            = libreoffice_internal::Dummy()):
        pData(nullptr)
    { rtl_uString_newFromStr(&pData, value); }

#else

    OUString( const sal_Unicode * value )
    {
        pData = NULL;
        rtl_uString_newFromStr( &pData, value );
    }

#endif

    OUString( const sal_Unicode * value, sal_Int32 length )
    {
        pData = NULL;
        rtl_uString_newFromStr_WithLength( &pData, value, length );
    }

    template< typename T >
    OUString( T& literal, typename libreoffice_internal::ConstCharArrayDetector< T, libreoffice_internal::Dummy >::Type = libreoffice_internal::Dummy() )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        pData = NULL;
        if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
            rtl_uString_new(&pData);
        } else {
            rtl_uString_newFromLiteral(
                &pData,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length, 0);
        }
#ifdef RTL_STRING_UNITTEST
        rtl_string_unittest_const_literal = true;
#endif
    }

#if defined LIBO_INTERNAL_ONLY

    template<typename T> OUString(
        T & literal,
        typename libreoffice_internal::ConstCharArrayDetector<
            T, libreoffice_internal::Dummy>::TypeUtf16
                = libreoffice_internal::Dummy()):
        pData(nullptr)
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
            rtl_uString_new(&pData);
        } else {
            rtl_uString_newFromStr_WithLength(
                &pData,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
    }
#endif

#if defined LIBO_INTERNAL_ONLY && defined RTL_STRING_UNITTEST

    template< typename T >
    OUString( T&, typename libreoffice_internal::ExceptConstCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
        rtl_string_unittest_invalid_conversion = true;
    }
    template< typename T >
    OUString( const T&, typename libreoffice_internal::ExceptCharArrayDetector< T >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        rtl_uString_newFromLiteral( &pData, "!!br0ken!!", 10, 0 ); // set to garbage
        rtl_string_unittest_invalid_conversion = true;
    }
#endif

#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

    template<std::size_t N> constexpr OUString(OUStringLiteral<N> const & literal):
        pData(const_cast<rtl_uString *>(&literal.str)) {}
    template<std::size_t N> OUString(OUStringLiteral<N> &&) = delete;
#endif

    OUString( const char * value, sal_Int32 length,
              rtl_TextEncoding encoding,
              sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
    {
        pData = NULL;
        rtl_string2UString( &pData, value, length, encoding, convertFlags );
        if (pData == NULL) {
            throw std::bad_alloc();
        }
    }

    explicit OUString(
        sal_uInt32 const * codePoints, sal_Int32 codePointCount):
        pData(NULL)
    {
        rtl_uString_newFromCodePoints(&pData, codePoints, codePointCount);
        if (pData == NULL) {
            throw std::bad_alloc();
        }
    }

#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

    template< typename T1, typename T2 >
    OUString( OUStringConcat< T1, T2 >&& c )
    {
        const sal_Int32 l = c.length();
        pData = rtl_uString_alloc( l );
        if (l != 0)
        {
            sal_Unicode* end = c.addData( pData->buffer );
            pData->length = l;
            *end = '\0';
        }
    }

    template< typename T, std::size_t N >
    OUString( StringNumberBase< sal_Unicode, T, N >&& n )
        : OUString( n.buf, n.length )
    {}
#endif

#if defined LIBO_INTERNAL_ONLY
    explicit OUString(std::u16string_view sv) {
        if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
            throw std::bad_alloc();
        }
        pData = nullptr;
        rtl_uString_newFromStr_WithLength(&pData, sv.data(), sv.size());
    }
#endif

    ~OUString()
    {
        rtl_uString_release( pData );
    }

    static OUString const & unacquired( rtl_uString * const * ppHandle )
        { return * reinterpret_cast< OUString const * >( ppHandle ); }

#if defined LIBO_INTERNAL_ONLY

    static OUString const& unacquired(const OUStringBuffer& str);
#endif

    OUString & operator=( const OUString & str )
    {
        rtl_uString_assign( &pData, str.pData );
        return *this;
    }

#if defined LIBO_INTERNAL_ONLY

    OUString & operator=( OUString && str ) noexcept
    {
        std::swap(pData, str.pData);
        return *this;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, OUString& >::Type operator=( T& literal )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
            rtl_uString_new(&pData);
        } else {
            rtl_uString_newFromLiteral(
                &pData,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length, 0);
        }
        return *this;
    }

#if defined LIBO_INTERNAL_ONLY

    template<typename T>
    typename
        libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
    operator =(T & literal) {
        if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
            rtl_uString_new(&pData);
        } else {
            rtl_uString_newFromStr_WithLength(
                &pData,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return *this;
    }

    template<std::size_t N> OUString & operator =(OUStringLiteral<N> const & literal) {
        rtl_uString_release(pData);
        pData = const_cast<rtl_uString *>(&literal.str);
        return *this;
    }
    template<std::size_t N> OUString & operator =(OUStringLiteral<N> &&) = delete;

    template <typename T, std::size_t N>
    OUString & operator =(StringNumberBase<sal_Unicode, T, N> && n) {
        // n.length should never be zero, so no need to add an optimization for that case
        rtl_uString_newFromStr_WithLength(&pData, n.buf, n.length);
        return *this;
    }

    OUString & operator =(std::u16string_view sv) {
        if (sv.empty()) {
            rtl_uString_new(&pData);
        } else {
            rtl_uString_newFromStr_WithLength(&pData, sv.data(), sv.size());
        }
        return *this;
    }
#endif

#if defined LIBO_INTERNAL_ONLY

    inline OUString & operator+=( const OUStringBuffer & str ) &;
#endif

    OUString & operator+=( const OUString & str )
#if defined LIBO_INTERNAL_ONLY
        &
#endif
    {
        return internalAppend(str.pData);
    }
#if defined LIBO_INTERNAL_ONLY
    void operator+=(OUString const &) && = delete;
#endif

    template<typename T>
    typename libreoffice_internal::ConstCharArrayDetector<T, OUString &>::Type
    operator +=(T & literal)
#if defined LIBO_INTERNAL_ONLY
        &
#endif
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        rtl_uString_newConcatAsciiL(
            &pData, pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return *this;
    }
#if defined LIBO_INTERNAL_ONLY
    template<typename T>
    typename libreoffice_internal::ConstCharArrayDetector<T, OUString &>::Type
    operator +=(T &) && = delete;
#endif

#if defined LIBO_INTERNAL_ONLY

    template<typename T>
    typename
        libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
    operator +=(T & literal) & {
        rtl_uString_newConcatUtf16L(
            &pData, pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return *this;
    }
    template<typename T>
    typename
        libreoffice_internal::ConstCharArrayDetector<T, OUString &>::TypeUtf16
    operator +=(T &) && = delete;

    template<std::size_t N> OUString & operator +=(OUStringLiteral<N> const & literal) & {
        rtl_uString_newConcatUtf16L(&pData, pData, literal.getStr(), literal.getLength());
        return *this;
    }
    template<std::size_t N> void operator +=(OUStringLiteral<N> const &) && = delete;

    OUString & operator +=(std::u16string_view sv) & {
        if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
            throw std::bad_alloc();
        }
        rtl_uString_newConcatUtf16L(&pData, pData, sv.data(), sv.size());
        return *this;
    }
    void operator +=(std::u16string_view) && = delete;
#endif

#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

    template< typename T1, typename T2 >
    OUString& operator+=( OUStringConcat< T1, T2 >&& c ) & {
        sal_Int32 l = c.length();
        if( l == 0 )
            return *this;
        l += pData->length;
        rtl_uString_ensureCapacity( &pData, l );
        sal_Unicode* end = c.addData( pData->buffer + pData->length );
        *end = '\0';
        pData->length = l;
        return *this;
    }
    template<typename T1, typename T2> void operator +=(
        OUStringConcat<T1, T2> &&) && = delete;

    template< typename T, std::size_t N >
    OUString& operator+=( StringNumberBase< sal_Unicode, T, N >&& n ) & {
        sal_Int32 l = n.length;
        if( l == 0 )
            return *this;
        l += pData->length;
        rtl_uString_ensureCapacity( &pData, l );
        sal_Unicode* end = addDataHelper( pData->buffer + pData->length, n.buf, n.length );
        *end = '\0';
        pData->length = l;
        return *this;
    }
    template<typename T, std::size_t N> void operator +=(
        StringNumberBase<sal_Unicode, T, N> &&) && = delete;
#endif

    void clear()
    {
        rtl_uString_new( &pData );
    }

    sal_Int32 getLength() const { return pData->length; }

    bool isEmpty() const
    {
        return pData->length == 0;
    }

    const sal_Unicode * getStr() const SAL_RETURNS_NONNULL { return pData->buffer; }

    sal_Unicode operator [](sal_Int32 index) const {
        // silence spurious -Werror=strict-overflow warnings from GCC 4.8.2
        assert(index >= 0 && static_cast<sal_uInt32>(index) < static_cast<sal_uInt32>(getLength()));
        return getStr()[index];
    }

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 compareTo( std::u16string_view str ) const
    {
        return rtl_ustr_compare_WithLength( pData->buffer, pData->length,
                                            str.data(), str.length() );
    }
#else
    sal_Int32 compareTo( const OUString & str ) const
    {
        return rtl_ustr_compare_WithLength( pData->buffer, pData->length,
                                            str.pData->buffer, str.pData->length );
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 compareTo( std::u16string_view str, sal_Int32 maxLength ) const
    {
        return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length,
                                                     str.data(), str.length(), maxLength );
    }
#else
    sal_Int32 compareTo( const OUString & str, sal_Int32 maxLength ) const
    {
        return rtl_ustr_shortenedCompare_WithLength( pData->buffer, pData->length,
                                                     str.pData->buffer, str.pData->length, maxLength );
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 reverseCompareTo(std::u16string_view sv) const {
        return rtl_ustr_reverseCompare_WithLength(
            pData->buffer, pData->length, sv.data(), sv.size());
    }
#else
    sal_Int32 reverseCompareTo( const OUString & str ) const
    {
        return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
                                                   str.pData->buffer, str.pData->length );
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type reverseCompareTo( T& literal ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return rtl_ustr_asciil_reverseCompare_WithLength(
            pData->buffer, pData->length,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }

    bool equals( const OUString & str ) const
    {
        if ( pData->length != str.pData->length )
            return false;
        if ( pData == str.pData )
            return true;
        return rtl_ustr_reverseCompare_WithLength( pData->buffer, pData->length,
                                                   str.pData->buffer, str.pData->length ) == 0;
    }

#if defined LIBO_INTERNAL_ONLY
    bool equalsIgnoreAsciiCase(std::u16string_view sv) const {
        if ( sal_uInt32(pData->length) != sv.size() )
            return false;
        if ( pData->buffer == sv.data() )
            return true;
        return
            rtl_ustr_compareIgnoreAsciiCase_WithLength(
                pData->buffer, pData->length, sv.data(), sv.size())
            == 0;
    }
#else
    bool equalsIgnoreAsciiCase( const OUString & str ) const
    {
        if ( pData->length != str.pData->length )
            return false;
        if ( pData == str.pData )
            return true;
        return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                           str.pData->buffer, str.pData->length ) == 0;
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 compareToIgnoreAsciiCase(std::u16string_view sv) const {
        return rtl_ustr_compareIgnoreAsciiCase_WithLength(
            pData->buffer, pData->length, sv.data(), sv.size());
    }
#else
    sal_Int32 compareToIgnoreAsciiCase( const OUString & str ) const
    {
        return rtl_ustr_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                           str.pData->buffer, str.pData->length );
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase( T& literal ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return
            (pData->length
             == libreoffice_internal::ConstCharArrayDetector<T>::length)
            && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength(
                    pData->buffer, pData->length,
                    libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                        literal))
                == 0);
    }

#if defined LIBO_INTERNAL_ONLY
    bool match(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
        return
            rtl_ustr_shortenedCompare_WithLength(
                pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size(),
                sv.size())
            == 0;
    }
#else
    bool match( const OUString & str, sal_Int32 fromIndex = 0 ) const
    {
        return rtl_ustr_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                     str.pData->buffer, str.pData->length, str.pData->length ) == 0;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type match( T& literal, sal_Int32 fromIndex = 0 ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return
            rtl_ustr_ascii_shortenedCompare_WithLength(
                pData->buffer+fromIndex, pData->length-fromIndex,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length)
            == 0;
    }

#if defined LIBO_INTERNAL_ONLY
    bool matchIgnoreAsciiCase(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
        return
            rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength(
                pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size(),
                sv.size())
            == 0;
    }
#else
    bool matchIgnoreAsciiCase( const OUString & str, sal_Int32 fromIndex = 0 ) const
    {
        return rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                                    str.pData->buffer, str.pData->length,
                                                                    str.pData->length ) == 0;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type matchIgnoreAsciiCase( T& literal, sal_Int32 fromIndex = 0 ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return matchIgnoreAsciiCaseAsciiL(
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length, fromIndex);
    }

    sal_Int32 compareToAscii( const char* asciiStr ) const
    {
        return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length, asciiStr );
    }

    SAL_DEPRECATED(
        "replace s1.compareToAscii(s2, strlen(s2)) == 0 with s1.startsWith(s2)")
    sal_Int32 compareToAscii( const char * asciiStr, sal_Int32 maxLength ) const
    {
        return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer, pData->length,
                                                           asciiStr, maxLength );
    }

    sal_Int32 reverseCompareToAsciiL( const char * asciiStr, sal_Int32 asciiStrLength ) const
    {
        return rtl_ustr_asciil_reverseCompare_WithLength( pData->buffer, pData->length,
                                                          asciiStr, asciiStrLength );
    }

    bool equalsAscii( const char* asciiStr ) const
    {
        return rtl_ustr_ascii_compare_WithLength( pData->buffer, pData->length,
                                                  asciiStr ) == 0;
    }

    bool equalsAsciiL( const char* asciiStr, sal_Int32 asciiStrLength ) const
    {
        if ( pData->length != asciiStrLength )
            return false;

        return rtl_ustr_asciil_reverseEquals_WithLength(
                    pData->buffer, asciiStr, asciiStrLength );
    }

    bool equalsIgnoreAsciiCaseAscii( const char * asciiStr ) const
    {
        return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
    }

    sal_Int32 compareToIgnoreAsciiCaseAscii( const char * asciiStr ) const
    {
        return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr );
    }

    bool equalsIgnoreAsciiCaseAsciiL( const char * asciiStr, sal_Int32 asciiStrLength ) const
    {
        if ( pData->length != asciiStrLength )
            return false;

        return rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length, asciiStr ) == 0;
    }

    bool matchAsciiL( const char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const
    {
        return rtl_ustr_ascii_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                           asciiStr, asciiStrLength ) == 0;
    }

    // This overload is left undefined, to detect calls of matchAsciiL that
    // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
    // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
    // platforms):
#if SAL_TYPES_SIZEOFLONG == 8
    void matchAsciiL(char const *, sal_Int32, rtl_TextEncoding) const;
#endif

    bool matchIgnoreAsciiCaseAsciiL( const char* asciiStr, sal_Int32 asciiStrLength, sal_Int32 fromIndex = 0 ) const
    {
        return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                                          asciiStr, asciiStrLength ) == 0;
    }

    // This overload is left undefined, to detect calls of
    // matchIgnoreAsciiCaseAsciiL that erroneously use
    // RTL_CONSTASCII_USTRINGPARAM instead of RTL_CONSTASCII_STRINGPARAM (but
    // would lead to ambiguities on 32 bit platforms):
#if SAL_TYPES_SIZEOFLONG == 8
    void matchIgnoreAsciiCaseAsciiL(char const *, sal_Int32, rtl_TextEncoding)
        const;
#endif

#if defined LIBO_INTERNAL_ONLY
    bool startsWith(std::u16string_view sv, OUString * rest = nullptr) const {
        auto const b = match(sv);
        if (b && rest != nullptr) {
            *rest = copy(sv.size());
        }
        return b;
    }
#else
    bool startsWith(OUString const & str, OUString * rest = NULL) const {
        bool b = match(str);
        if (b && rest != NULL) {
            *rest = copy(str.getLength());
        }
        return b;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(
        T & literal, OUString * rest = NULL) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b
            = (libreoffice_internal::ConstCharArrayDetector<T>::length
               <= sal_uInt32(pData->length))
            && rtl_ustr_asciil_reverseEquals_WithLength(
                pData->buffer,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        if (b && rest != NULL) {
            *rest = copy(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }

#if defined LIBO_INTERNAL_ONLY
    bool startsWithIgnoreAsciiCase(std::u16string_view sv, OUString * rest = nullptr) const {
        auto const b = matchIgnoreAsciiCase(sv);
        if (b && rest != nullptr) {
            *rest = copy(sv.size());
        }
        return b;
    }
#else
    bool startsWithIgnoreAsciiCase(OUString const & str, OUString * rest = NULL)
        const
    {
        bool b = matchIgnoreAsciiCase(str);
        if (b && rest != NULL) {
            *rest = copy(str.getLength());
        }
        return b;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    startsWithIgnoreAsciiCase(T & literal, OUString * rest = NULL) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b
            = (libreoffice_internal::ConstCharArrayDetector<T>::length
               <= sal_uInt32(pData->length))
            && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                   pData->buffer,
                   libreoffice_internal::ConstCharArrayDetector<T>::length,
                   libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                       literal),
                   libreoffice_internal::ConstCharArrayDetector<T>::length)
               == 0);
        if (b && rest != NULL) {
            *rest = copy(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }

#if defined LIBO_INTERNAL_ONLY
    bool endsWith(std::u16string_view sv, OUString * rest = nullptr) const {
        auto const b = sv.size() <= sal_uInt32(pData->length)
            && match(sv, pData->length - sv.size());
        if (b && rest != nullptr) {
            *rest = copy(0, (pData->length - sv.size()));
        }
        return b;
    }
#else
    bool endsWith(OUString const & str, OUString * rest = NULL) const {
        bool b = str.getLength() <= getLength()
            && match(str, getLength() - str.getLength());
        if (b && rest != NULL) {
            *rest = copy(0, getLength() - str.getLength());
        }
        return b;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    endsWith(T & literal, OUString * rest = NULL) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b
            = (libreoffice_internal::ConstCharArrayDetector<T>::length
               <= sal_uInt32(pData->length))
            && rtl_ustr_asciil_reverseEquals_WithLength(
                (pData->buffer + pData->length
                 - libreoffice_internal::ConstCharArrayDetector<T>::length),
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        if (b && rest != NULL) {
            *rest = copy(
                0,
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        }
        return b;
    }

    bool endsWithAsciiL(char const * asciiStr, sal_Int32 asciiStrLength)
        const
    {
        return asciiStrLength <= pData->length
            && rtl_ustr_asciil_reverseEquals_WithLength(
                pData->buffer + pData->length - asciiStrLength, asciiStr,
                asciiStrLength);
    }

#if defined LIBO_INTERNAL_ONLY
    bool endsWithIgnoreAsciiCase(std::u16string_view sv, OUString * rest = nullptr) const {
        auto const b = sv.size() <= sal_uInt32(pData->length)
            && matchIgnoreAsciiCase(sv, pData->length - sv.size());
        if (b && rest != nullptr) {
            *rest = copy(0, pData->length - sv.size());
        }
        return b;
    }
#else
    bool endsWithIgnoreAsciiCase(OUString const & str, OUString * rest = NULL) const
    {
        bool b =  str.getLength() <= getLength()
            && matchIgnoreAsciiCase(str, getLength() - str.getLength());
        if (b && rest != NULL) {
            *rest = copy(0, getLength() - str.getLength());
        }
        return b;
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    endsWithIgnoreAsciiCase(T & literal, OUString * rest = NULL) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b
            = (libreoffice_internal::ConstCharArrayDetector<T>::length
               <= sal_uInt32(pData->length))
            && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                    (pData->buffer + pData->length
                     - libreoffice_internal::ConstCharArrayDetector<T>::length),
                    libreoffice_internal::ConstCharArrayDetector<T>::length,
                    libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                        literal),
                    libreoffice_internal::ConstCharArrayDetector<T>::length)
                == 0);
        if (b && rest != NULL) {
            *rest = copy(
                0,
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        }
        return b;
    }

    bool endsWithIgnoreAsciiCaseAsciiL(
        char const * asciiStr, sal_Int32 asciiStrLength) const
    {
        return asciiStrLength <= pData->length
            && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
                    pData->buffer + pData->length - asciiStrLength,
                    asciiStrLength, asciiStr, asciiStrLength)
                == 0);
    }

    friend bool     operator == ( const OUString& rStr1,    const OUString& rStr2 )
                        { return rStr1.equals(rStr2); }

    friend bool     operator != ( const OUString& rStr1,        const OUString& rStr2 )
                        { return !(operator == ( rStr1, rStr2 )); }

    friend bool     operator <  ( const OUString& rStr1,    const OUString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) < 0; }
    friend bool     operator >  ( const OUString& rStr1,    const OUString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) > 0; }
    friend bool     operator <= ( const OUString& rStr1,    const OUString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) <= 0; }
    friend bool     operator >= ( const OUString& rStr1,    const OUString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) >= 0; }

#if defined LIBO_INTERNAL_ONLY

    template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
    operator ==(OUString const & s1, T const & s2) {
        return rtl_ustr_compare_WithLength(s1.getStr(), s1.getLength(), s2, rtl_ustr_getLength(s2))
            == 0;
    }

    template<typename T>
    friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
    operator ==(OUString const & s1, T & s2) {
        return rtl_ustr_compare_WithLength(s1.getStr(), s1.getLength(), s2, rtl_ustr_getLength(s2))
            == 0;
    }

    template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
    operator ==(T const & s1, OUString const & s2) {
        return rtl_ustr_compare_WithLength(s1, rtl_ustr_getLength(s1), s2.getStr(), s2.getLength())
            == 0;
    }

    template<typename T>
    friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
    operator ==(T & s1, OUString const & s2) {
        return rtl_ustr_compare_WithLength(s1, rtl_ustr_getLength(s1), s2.getStr(), s2.getLength())
            == 0;
    }

    template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
    operator !=(OUString const & s1, T const & s2) { return !(s1 == s2); }

    template<typename T>
    friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
    operator !=(OUString const & s1, T & s2) { return !(s1 == s2); }

    template<typename T> friend typename libreoffice_internal::CharPtrDetector<T, bool>::TypeUtf16
    operator !=(T const & s1, OUString const & s2) { return !(s1 == s2); }

    template<typename T>
    friend typename libreoffice_internal::NonConstCharArrayDetector<T, bool>::TypeUtf16
    operator !=(T & s1, OUString const & s2) { return !(s1 == s2); }

#else

    friend bool     operator == ( const OUString& rStr1,    const sal_Unicode * pStr2 )
                        { return rStr1.compareTo( pStr2 ) == 0; }
    friend bool     operator == ( const sal_Unicode * pStr1,    const OUString& rStr2 )
                        { return OUString( pStr1 ).compareTo( rStr2 ) == 0; }

    friend bool     operator != ( const OUString& rStr1,    const sal_Unicode * pStr2 )
                        { return !(operator == ( rStr1, pStr2 )); }
    friend bool     operator != ( const sal_Unicode * pStr1,    const OUString& rStr2 )
                        { return !(operator == ( pStr1, rStr2 )); }

#endif

    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==( const OUString& rString, T& literal )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return rString.equalsAsciiL(
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OUString& rString )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return rString.equalsAsciiL(
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=( const OUString& rString, T& literal )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return !rString.equalsAsciiL(
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=( T& literal, const OUString& rString )
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return !rString.equalsAsciiL(
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }

#if defined LIBO_INTERNAL_ONLY

    template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
    operator ==(OUString const & string, T & literal) {
        return
            rtl_ustr_reverseCompare_WithLength(
                string.pData->buffer, string.pData->length,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length)
            == 0;
    }
    template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
    operator ==(T & literal, OUString const & string) {
        return
            rtl_ustr_reverseCompare_WithLength(
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length,
                string.pData->buffer, string.pData->length)
            == 0;
    }
    template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
    operator !=(OUString const & string, T & literal) {
        return
            rtl_ustr_reverseCompare_WithLength(
                string.pData->buffer, string.pData->length,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length)
            != 0;
    }
    template<typename T> friend typename libreoffice_internal::ConstCharArrayDetector<T, bool>::TypeUtf16
    operator !=(T & literal, OUString const & string) {
        return
            rtl_ustr_reverseCompare_WithLength(
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length,
                string.pData->buffer, string.pData->length)
            != 0;
    }
#endif

    sal_Int32 hashCode() const
    {
        return rtl_ustr_hashCode_WithLength( pData->buffer, pData->length );
    }

    sal_Int32 indexOf( sal_Unicode ch, sal_Int32 fromIndex = 0 ) const
    {
        sal_Int32 ret = rtl_ustr_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
        return (ret < 0 ? ret : ret+fromIndex);
    }

    sal_Int32 lastIndexOf( sal_Unicode ch ) const
    {
        return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
    }

    sal_Int32 lastIndexOf( sal_Unicode ch, sal_Int32 fromIndex ) const
    {
        return rtl_ustr_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
    }

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 indexOf(std::u16string_view sv, sal_Int32 fromIndex = 0) const {
        auto const n = rtl_ustr_indexOfStr_WithLength(
            pData->buffer + fromIndex, pData->length - fromIndex, sv.data(), sv.size());
        return n < 0 ? n : n + fromIndex;
    }
#else
    sal_Int32 indexOf( const OUString & str, sal_Int32 fromIndex = 0 ) const
    {
        sal_Int32 ret = rtl_ustr_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                        str.pData->buffer, str.pData->length );
        return (ret < 0 ? ret : ret+fromIndex);
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type indexOf( T& literal, sal_Int32 fromIndex = 0 ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        sal_Int32 n = rtl_ustr_indexOfAscii_WithLength(
            pData->buffer + fromIndex, pData->length - fromIndex,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return n < 0 ? n : n + fromIndex;
    }

    sal_Int32 indexOfAsciiL(
        char const * str, sal_Int32 len, sal_Int32 fromIndex = 0) const
    {
        sal_Int32 ret = rtl_ustr_indexOfAscii_WithLength(
            pData->buffer + fromIndex, pData->length - fromIndex, str, len);
        return ret < 0 ? ret : ret + fromIndex;
    }

    // This overload is left undefined, to detect calls of indexOfAsciiL that
    // erroneously use RTL_CONSTASCII_USTRINGPARAM instead of
    // RTL_CONSTASCII_STRINGPARAM (but would lead to ambiguities on 32 bit
    // platforms):
#if SAL_TYPES_SIZEOFLONG == 8
    void indexOfAsciiL(char const *, sal_Int32 len, rtl_TextEncoding) const;
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 lastIndexOf(std::u16string_view sv) const {
        return rtl_ustr_lastIndexOfStr_WithLength(
            pData->buffer, pData->length, sv.data(), sv.size());
    }
#else
    sal_Int32 lastIndexOf( const OUString & str ) const
    {
        return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, pData->length,
                                                   str.pData->buffer, str.pData->length );
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    sal_Int32 lastIndexOf(std::u16string_view sv, sal_Int32 fromIndex) const {
        return rtl_ustr_lastIndexOfStr_WithLength(pData->buffer, fromIndex, sv.data(), sv.size());
    }
#else
    sal_Int32 lastIndexOf( const OUString & str, sal_Int32 fromIndex ) const
    {
        return rtl_ustr_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
                                                   str.pData->buffer, str.pData->length );
    }
#endif

    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, sal_Int32 >::Type lastIndexOf( T& literal ) const
    {
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return rtl_ustr_lastIndexOfAscii_WithLength(
            pData->buffer, pData->length,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
    }

    sal_Int32 lastIndexOfAsciiL(char const * str, sal_Int32 len) const
    {
        return rtl_ustr_lastIndexOfAscii_WithLength(
            pData->buffer, pData->length, str, len);
    }

    SAL_WARN_UNUSED_RESULT OUString copy( sal_Int32 beginIndex ) const
    {
        return copy(beginIndex, getLength() - beginIndex);
    }

    SAL_WARN_UNUSED_RESULT OUString copy( sal_Int32 beginIndex, sal_Int32 count ) const
    {
        rtl_uString *pNew = NULL;
        rtl_uString_newFromSubString( &pNew, pData, beginIndex, count );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

#if defined LIBO_INTERNAL_ONLY

    SAL_WARN_UNUSED_RESULT std::u16string_view subView( sal_Int32 beginIndex ) const
    {
        assert(beginIndex >= 0);
        assert(beginIndex <= getLength());
        return subView(beginIndex, getLength() - beginIndex);
    }

    SAL_WARN_UNUSED_RESULT std::u16string_view subView( sal_Int32 beginIndex, sal_Int32 count ) const
    {
        assert(beginIndex >= 0);
        assert(count >= 0);
        assert(beginIndex <= getLength());
        assert(count <= getLength() - beginIndex);
        return std::u16string_view(*this).substr(beginIndex, count);
    }

    SAL_WARN_UNUSED_RESULT std::vector<std::u16string_view> split(const std::u16string &separator = u" ") const
    {
        std::vector<std::u16string_view> output;
        std::u16string_view stringView(*this);
        std::size_t index;

        do
        {
            index = stringView.find(separator);
            if (index != stringView.npos)
            {
                if (index != 0)
                    output.push_back(stringView.substr(0, index));

                if (index != stringView.length() - separator.length())
                    stringView
                        = stringView.substr(index + separator.length(),
                                            stringView.length() - index - separator.length());
                else
                    index = stringView.npos;
            }
            else
                output.push_back(stringView);
        } while (index != stringView.npos);

        return output;
    }
#endif

#ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

    SAL_WARN_UNUSED_RESULT OUString concat( const OUString & str ) const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newConcat( &pNew, pData, str.pData );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }
#endif

#ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    friend OUString operator+( const OUString& rStr1, const OUString& rStr2  )
    {
        return rStr1.concat( rStr2 );
    }
#endif

// hide this from internal code to avoid ambiguous lookup error
#ifndef LIBO_INTERNAL_ONLY

    SAL_WARN_UNUSED_RESULT OUString replaceAt( sal_Int32 index, sal_Int32 count, const OUString& newStr ) const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newReplaceStrAt( &pNew, pData, index, count, newStr.pData );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }
#endif

#ifdef LIBO_INTERNAL_ONLY
    SAL_WARN_UNUSED_RESULT OUString replaceAt( sal_Int32 index, sal_Int32 count, std::u16string_view newStr ) const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newReplaceStrAtUtf16L( &pNew, pData, index, count, newStr.data(), newStr.size() );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }
#endif

    SAL_WARN_UNUSED_RESULT OUString replace( sal_Unicode oldChar, sal_Unicode newChar ) const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newReplace( &pNew, pData, oldChar, newChar );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

#if defined LIBO_INTERNAL_ONLY
    [[nodiscard]] OUString replaceFirst(
        std::u16string_view from, std::u16string_view to, sal_Int32 * index = nullptr) const
    {
        rtl_uString * s = nullptr;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirstUtf16LUtf16L(
            &s, pData, from.data(), from.size(), to.data(), to.size(),
            index == nullptr ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#else
    SAL_WARN_UNUSED_RESULT OUString replaceFirst(
        OUString const & from, OUString const & to, sal_Int32 * index = NULL) const
    {
        rtl_uString * s = NULL;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirst(
            &s, pData, from.pData, to.pData, index == NULL ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    template<typename T> [[nodiscard]]
    typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceFirst(
        T & from, std::u16string_view to, sal_Int32 * index = nullptr) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from));
        rtl_uString * s = nullptr;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirstAsciiLUtf16L(
            &s, pData, libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
            libreoffice_internal::ConstCharArrayDetector<T>::length, to.data(), to.size(),
            index == nullptr ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#else
    template< typename T >
    SAL_WARN_UNUSED_RESULT typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst( T& from, OUString const & to,
                                                                                                        sal_Int32 * index = NULL) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from));
        rtl_uString * s = NULL;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirstAsciiL(
            &s, pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
            libreoffice_internal::ConstCharArrayDetector<T>::length, to.pData,
            index == NULL ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    template<typename T> [[nodiscard]]
    typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceFirst(
        std::u16string_view from, T & to, sal_Int32 * index = nullptr) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to));
        rtl_uString * s = nullptr;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirstUtf16LAsciiL(
            &s, pData, from.data(), from.size(),
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
            libreoffice_internal::ConstCharArrayDetector<T>::length, index == nullptr ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#else
    template< typename T >
    SAL_WARN_UNUSED_RESULT typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceFirst( OUString const & from, T& to,
                                                                                                        sal_Int32 * index = NULL) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to));
        rtl_uString * s = NULL;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirstToAsciiL(
            &s, pData, from.pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
            libreoffice_internal::ConstCharArrayDetector<T>::length,
            index == NULL ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#endif

    template< typename T1, typename T2 >
        SAL_WARN_UNUSED_RESULT typename libreoffice_internal::ConstCharArrayDetector< T1, typename libreoffice_internal::ConstCharArrayDetector< T2, OUString >::Type >::Type
        replaceFirst( T1& from, T2& to, sal_Int32 * index = NULL) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T1>::isValid(from));
        assert(libreoffice_internal::ConstCharArrayDetector<T2>::isValid(to));
        rtl_uString * s = NULL;
        sal_Int32 i = 0;
        rtl_uString_newReplaceFirstAsciiLAsciiL(
            &s, pData,
            libreoffice_internal::ConstCharArrayDetector<T1>::toPointer(from),
            libreoffice_internal::ConstCharArrayDetector<T1>::length,
            libreoffice_internal::ConstCharArrayDetector<T2>::toPointer(to),
            libreoffice_internal::ConstCharArrayDetector<T2>::length,
            index == NULL ? &i : index);
        return OUString(s, SAL_NO_ACQUIRE);
    }

#if defined LIBO_INTERNAL_ONLY
    [[nodiscard]] OUString replaceAll(
        std::u16string_view from, std::u16string_view to, sal_Int32 fromIndex = 0) const
    {
        rtl_uString * s = nullptr;
        rtl_uString_newReplaceAllFromIndexUtf16LUtf16L(
            &s, pData, from.data(), from.size(), to.data(), to.size(), fromIndex);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#else
    SAL_WARN_UNUSED_RESULT OUString replaceAll(
        OUString const & from, OUString const & to, sal_Int32 fromIndex = 0) const
    {
        rtl_uString * s = NULL;
        rtl_uString_newReplaceAllFromIndex(&s, pData, from.pData, to.pData, fromIndex);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    template<typename T> [[nodiscard]]
    typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceAll(
        T & from, std::u16string_view to) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from));
        rtl_uString * s = nullptr;
        rtl_uString_newReplaceAllAsciiLUtf16L(
            &s, pData, libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
            libreoffice_internal::ConstCharArrayDetector<T>::length, to.data(), to.size());
        return OUString(s, SAL_NO_ACQUIRE);
    }
#else
    template< typename T >
    SAL_WARN_UNUSED_RESULT typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceAll( T& from, OUString const & to) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(from));
        rtl_uString * s = NULL;
        rtl_uString_newReplaceAllAsciiL(
            &s, pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(from),
            libreoffice_internal::ConstCharArrayDetector<T>::length, to.pData);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#endif

#if defined LIBO_INTERNAL_ONLY
    template<typename T> [[nodiscard]]
    typename libreoffice_internal::ConstCharArrayDetector<T, OUString >::Type replaceAll(
        std::u16string_view from, T & to) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to));
        rtl_uString * s = nullptr;
        rtl_uString_newReplaceAllUtf16LAsciiL(
            &s, pData, from.data(), from.size(),
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#else
    template< typename T >
    SAL_WARN_UNUSED_RESULT typename libreoffice_internal::ConstCharArrayDetector< T, OUString >::Type replaceAll( OUString const & from, T& to) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(to));
        rtl_uString * s = NULL;
        rtl_uString_newReplaceAllToAsciiL(
            &s, pData, from.pData,
            libreoffice_internal::ConstCharArrayDetector<T>::toPointer(to),
            libreoffice_internal::ConstCharArrayDetector<T>::length);
        return OUString(s, SAL_NO_ACQUIRE);
    }
#endif

    template< typename T1, typename T2 >
    SAL_WARN_UNUSED_RESULT typename libreoffice_internal::ConstCharArrayDetector< T1, typename libreoffice_internal::ConstCharArrayDetector< T2, OUString >::Type >::Type
        replaceAll( T1& from, T2& to ) const
    {
        assert(libreoffice_internal::ConstCharArrayDetector<T1>::isValid(from));
        assert(libreoffice_internal::ConstCharArrayDetector<T2>::isValid(to));
        rtl_uString * s = NULL;
        rtl_uString_newReplaceAllAsciiLAsciiL(
            &s, pData,
            libreoffice_internal::ConstCharArrayDetector<T1>::toPointer(from),
            libreoffice_internal::ConstCharArrayDetector<T1>::length,
            libreoffice_internal::ConstCharArrayDetector<T2>::toPointer(to),
            libreoffice_internal::ConstCharArrayDetector<T2>::length);
        return OUString(s, SAL_NO_ACQUIRE);
    }

    SAL_WARN_UNUSED_RESULT OUString toAsciiLowerCase() const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newToAsciiLowerCase( &pNew, pData );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

    SAL_WARN_UNUSED_RESULT OUString toAsciiUpperCase() const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newToAsciiUpperCase( &pNew, pData );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

    SAL_WARN_UNUSED_RESULT OUString trim() const
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newTrim( &pNew, pData );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

    OUString getToken( sal_Int32 token, sal_Unicode cTok, sal_Int32& index ) const
    {
        rtl_uString * pNew = NULL;
        index = rtl_uString_getToken( &pNew, pData, token, cTok, index );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

    OUString getToken(sal_Int32 count, sal_Unicode separator) const {
        sal_Int32 n = 0;
        return getToken(count, separator, n);
    }

    bool toBoolean() const
    {
        return rtl_ustr_toBoolean( pData->buffer );
    }

    sal_Unicode toChar() const
    {
        return pData->buffer[0];
    }

    sal_Int32 toInt32( sal_Int16 radix = 10 ) const
    {
        return rtl_ustr_toInt32( pData->buffer, radix );
    }

    sal_uInt32 toUInt32( sal_Int16 radix = 10 ) const
    {
        return rtl_ustr_toUInt32( pData->buffer, radix );
    }

    sal_Int64 toInt64( sal_Int16 radix = 10 ) const
    {
        return rtl_ustr_toInt64( pData->buffer, radix );
    }

    sal_uInt64 toUInt64( sal_Int16 radix = 10 ) const
    {
        return rtl_ustr_toUInt64( pData->buffer, radix );
    }

    float toFloat() const
    {
        return rtl_ustr_toFloat( pData->buffer );
    }

    double toDouble() const
    {
        return rtl_ustr_toDouble( pData->buffer );
    }


    OUString intern() const
    {
        rtl_uString * pNew = NULL;
        rtl_uString_intern( &pNew, pData );
        if (pNew == NULL) {
            throw std::bad_alloc();
        }
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

    static OUString intern( const char * value, sal_Int32 length,
                            rtl_TextEncoding encoding,
                            sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS,
                            sal_uInt32 *pInfo = NULL )
    {
        rtl_uString * pNew = NULL;
        rtl_uString_internConvert( &pNew, value, length, encoding,
                                   convertFlags, pInfo );
        if (pNew == NULL) {
            throw std::bad_alloc();
        }
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

    bool convertToString(OString * pTarget, rtl_TextEncoding nEncoding,
                                sal_uInt32 nFlags) const
    {
        return rtl_convertUStringToString(&pTarget->pData, pData->buffer,
                                            pData->length, nEncoding, nFlags);
    }

    sal_uInt32 iterateCodePoints(
        sal_Int32 * indexUtf16, sal_Int32 incrementCodePoints = 1) const
    {
        return rtl_uString_iterateCodePoints(
            pData, indexUtf16, incrementCodePoints);
    }

#if defined LIBO_INTERNAL_ONLY
    static OUString fromUtf8(std::string_view rSource)
    {
        OUString aTarget;
        bool bSuccess = rtl_convertStringToUString(&aTarget.pData,
                                                   rSource.data(),
                                                   rSource.length(),
                                                   RTL_TEXTENCODING_UTF8,
                                                   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR|RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR|RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR);
        (void) bSuccess;
        assert(bSuccess);
        return aTarget;
    }
#else
    static OUString fromUtf8(const OString& rSource)
    {
        OUString aTarget;
        bool bSuccess = rtl_convertStringToUString(&aTarget.pData,
                                                   rSource.getStr(),
                                                   rSource.getLength(),
                                                   RTL_TEXTENCODING_UTF8,
                                                   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR|RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR|RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR);
        (void) bSuccess;
        assert(bSuccess);
        return aTarget;
    }
#endif

    OString toUtf8() const
    {
        OString aTarget;
        bool bSuccess = rtl_convertUStringToString(&aTarget.pData,
                                                   getStr(),
                                                   getLength(),
                                                   RTL_TEXTENCODING_UTF8,
                                                   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR|RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR);
        (void) bSuccess;
        assert(bSuccess);
        return aTarget;
    }

#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

    static OUStringNumber< int > number( int i, sal_Int16 radix = 10 )
    {
        return OUStringNumber< int >( i, radix );
    }
    static OUStringNumber< long long > number( long long ll, sal_Int16 radix = 10 )
    {
        return OUStringNumber< long long >( ll, radix );
    }
    static OUStringNumber< unsigned long long > number( unsigned long long ll, sal_Int16 radix = 10 )
    {
        return OUStringNumber< unsigned long long >( ll, radix );
    }
    static OUStringNumber< unsigned long long > number( unsigned int i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static OUStringNumber< long long > number( long i, sal_Int16 radix = 10)
    {
        return number( static_cast< long long >( i ), radix );
    }
    static OUStringNumber< unsigned long long > number( unsigned long i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static OUStringNumber< float > number( float f )
    {
        return OUStringNumber< float >( f );
    }
    static OUStringNumber< double > number( double d )
    {
        return OUStringNumber< double >( d );
    }
#else

    static OUString number( int i, sal_Int16 radix = 10 )
    {
        sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT32];
        return OUString(aBuf, rtl_ustr_valueOfInt32(aBuf, i, radix));
    }
    static OUString number( unsigned int i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static OUString number( long i, sal_Int16 radix = 10)
    {
        return number( static_cast< long long >( i ), radix );
    }
    static OUString number( unsigned long i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static OUString number( long long ll, sal_Int16 radix = 10 )
    {
        sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFINT64];
        return OUString(aBuf, rtl_ustr_valueOfInt64(aBuf, ll, radix));
    }
    static OUString number( unsigned long long ll, sal_Int16 radix = 10 )
    {
        sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFUINT64];
        return OUString(aBuf, rtl_ustr_valueOfUInt64(aBuf, ll, radix));
    }

    static OUString number( float f )
    {
        sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFFLOAT];
        return OUString(aBuf, rtl_ustr_valueOfFloat(aBuf, f));
    }

    static OUString number( double d )
    {
        sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFDOUBLE];
        return OUString(aBuf, rtl_ustr_valueOfDouble(aBuf, d));
    }
#endif

    SAL_DEPRECATED("use boolean()") static OUString valueOf( sal_Bool b )
    {
        return boolean(b);
    }

    static OUString boolean( bool b )
    {
        sal_Unicode aBuf[RTL_USTR_MAX_VALUEOFBOOLEAN];
        return OUString(aBuf, rtl_ustr_valueOfBoolean(aBuf, b));
    }

    SAL_DEPRECATED("convert to OUString or use directly") static OUString valueOf( sal_Unicode c )
    {
        return OUString( &c, 1 );
    }

    SAL_DEPRECATED("use number()") static OUString valueOf( sal_Int32 i, sal_Int16 radix = 10 )
    {
        return number( i, radix );
    }

    SAL_DEPRECATED("use number()") static OUString valueOf( sal_Int64 ll, sal_Int16 radix = 10 )
    {
        return number( ll, radix );
    }

    SAL_DEPRECATED("use number()") static OUString valueOf( float f )
    {
        return number(f);
    }

    SAL_DEPRECATED("use number()") static OUString valueOf( double d )
    {
        return number(d);
    }

    static OUString createFromAscii( const char * value )
    {
        rtl_uString* pNew = NULL;
        rtl_uString_newFromAscii( &pNew, value );
        return OUString( pNew, SAL_NO_ACQUIRE );
    }

#if defined LIBO_INTERNAL_ONLY
    static OUString createFromAscii(std::string_view value) {
        rtl_uString * p = nullptr;
        rtl_uString_newFromLiteral(&p, value.data(), value.size(), 0); //TODO: check for overflow
        return OUString(p, SAL_NO_ACQUIRE);
    }
 #endif

#if defined LIBO_INTERNAL_ONLY
    operator std::u16string_view() const { return {getStr(), sal_uInt32(getLength())}; }
#endif

#if defined LIBO_INTERNAL_ONLY
    // A wrapper for the first expression in an
    //
    //   OUString::Concat(e1) + e2 + ...
    //
    // concatenation chain, when neither of the first two e1, e2 is one of our rtl string-related
    // classes (so something like
    //
    //   OUString s = "a" + (b ? std::u16string_view(u"c") : std::u16string_view(u"dd"));
    //
    // would not compile):
    template<typename T> [[nodiscard]] static
    OUStringConcat<OUStringConcatMarker, T>
    Concat(T const & value) { return OUStringConcat<OUStringConcatMarker, T>({}, value); }

    // This overload is needed so that an argument of type 'char const[N]' ends up as
    // 'OUStringConcat<rtl::OUStringConcatMarker, char const[N]>' rather than as
    // 'OUStringConcat<rtl::OUStringConcatMarker, char[N]>':
    template<typename T, std::size_t N> [[nodiscard]] static
    OUStringConcat<OUStringConcatMarker, T[N]>
    Concat(T (& value)[N]) { return OUStringConcat<OUStringConcatMarker, T[N]>({}, value); }
#endif

private:
    OUString & internalAppend( rtl_uString* pOtherData )
    {
        rtl_uString* pNewData = NULL;
        rtl_uString_newConcat( &pNewData, pData, pOtherData );
        if (pNewData == NULL) {
            throw std::bad_alloc();
        }
        rtl_uString_assign(&pData, pNewData);
        rtl_uString_release(pNewData);
        return *this;
    }

};

#if defined LIBO_INTERNAL_ONLY
// Can only define this after we define OUString
inline OUStringConstExpr::operator const OUString &() const { return OUString::unacquired(&pData); }
#endif

#if defined LIBO_INTERNAL_ONLY
// Prevent the operator ==/!= overloads with 'sal_Unicode const *' parameter from
// being selected for nonsensical code like
//
//   if (ouIdAttr == nullptr)
//
void operator ==(OUString const &, std::nullptr_t) = delete;
void operator ==(std::nullptr_t, OUString const &) = delete;
void operator !=(OUString const &, std::nullptr_t) = delete;
void operator !=(std::nullptr_t, OUString const &) = delete;
#endif

#if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
inline bool operator ==(OUString const & lhs, StringConcatenation<char16_t> const & rhs)
{ return lhs == std::u16string_view(rhs); }
inline bool operator !=(OUString const & lhs, StringConcatenation<char16_t> const & rhs)
{ return lhs != std::u16string_view(rhs); }
inline bool operator ==(StringConcatenation<char16_t> const & lhs, OUString const & rhs)
{ return std::u16string_view(lhs) == rhs; }
inline bool operator !=(StringConcatenation<char16_t> const & lhs, OUString const & rhs)
{ return std::u16string_view(lhs) != rhs; }
#endif

#if defined LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"

template<>
struct ToStringHelper< OUString >
{
    static std::size_t length( const OUString& s ) { return s.getLength(); }
    sal_Unicode* operator() ( sal_Unicode* buffer, const OUString& s ) const { return addDataHelper( buffer, s.getStr(), s.getLength()); }
};

template<std::size_t N>
struct ToStringHelper< OUStringLiteral<N> >
{
    static std::size_t length( const OUStringLiteral<N>& str ) { return str.getLength(); }
    sal_Unicode* operator()( sal_Unicode* buffer, const OUStringLiteral<N>& str ) const { return addDataHelper( buffer, str.getStr(), str.getLength() ); }
};

template< typename charT, typename traits, typename T1, typename T2 >
inline std::basic_ostream<charT, traits> & operator <<(
    std::basic_ostream<charT, traits> & stream, OUStringConcat< T1, T2 >&& concat)
{
    return stream << OUString( std::move(concat) );
}


#endif

struct OUStringHash
{
    size_t operator()(const OUString& rString) const
        { return static_cast<size_t>(rString.hashCode()); }
};

/* ======================================================================= */

#if defined LIBO_INTERNAL_ONLY
inline OUString OStringToOUString( std::string_view rStr,
                                   rtl_TextEncoding encoding,
                                   sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
{
    return OUString( rStr.data(), rStr.length(), encoding, convertFlags );
}
#else
inline OUString OStringToOUString( const OString & rStr,
                                   rtl_TextEncoding encoding,
                                   sal_uInt32 convertFlags = OSTRING_TO_OUSTRING_CVTFLAGS )
{
    return OUString( rStr.getStr(), rStr.getLength(), encoding, convertFlags );
}
#endif

#if defined LIBO_INTERNAL_ONLY
inline OString OUStringToOString( std::u16string_view rUnicode,
                                  rtl_TextEncoding encoding,
                                  sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
{
    return OString( rUnicode.data(), rUnicode.length(), encoding, convertFlags );
}
#else
inline OString OUStringToOString( const OUString & rUnicode,
                                  rtl_TextEncoding encoding,
                                  sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
{
    return OString( rUnicode.getStr(), rUnicode.getLength(), encoding, convertFlags );
}
#endif

/* ======================================================================= */

template< typename charT, typename traits >
inline std::basic_ostream<charT, traits> & operator <<(
    std::basic_ostream<charT, traits> & stream, OUString const & rString)
{
    return stream <<
        OUStringToOString(rString, RTL_TEXTENCODING_UTF8);
        // best effort; potentially loses data due to conversion failures
        // (stray surrogate halves) and embedded null characters
}

} // namespace

#ifdef RTL_STRING_UNITTEST
namespace rtl
{
typedef rtlunittest::OUString OUString;
}
#endif

// In internal code, allow to use classes like OUString without having to
// explicitly refer to the rtl namespace, which is kind of superfluous given
// that OUString itself is namespaced by its OU prefix:
#if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
using ::rtl::OUString;
using ::rtl::OUStringHash;
using ::rtl::OStringToOUString;
using ::rtl::OUStringToOString;
using ::rtl::OUStringLiteral;
using ::rtl::OUStringChar;
using ::rtl::Concat2View;
#endif


#if defined LIBO_INTERNAL_ONLY
namespace std {

template<>
struct hash<::rtl::OUString>
{
    std::size_t operator()(::rtl::OUString const & s) const
    {
        if constexpr (sizeof(std::size_t) == 8)
        {
            // return a hash that uses the full 64-bit range instead of a 32-bit value
            size_t n = 0;
            for (sal_Int32 i = 0, len = s.getLength(); i < len; ++i)
                n = 31 * n + s[i];
            return n;
        }
        else
            return std::size_t(s.hashCode());
    }
};

}

#endif

#endif /* _RTL_USTRING_HXX */

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */