string.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
/*
 * This file is part of LibreOffice published API.
 */
 
#ifndef INCLUDED_RTL_STRING_HXX
#define INCLUDED_RTL_STRING_HXX
 
#include "sal/config.h"
 
#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <limits>
#include <new>
#include <ostream>
#include <utility>
#include <string.h>
 
#if defined LIBO_INTERNAL_ONLY
#include <algorithm>
#include <string_view>
#include <type_traits>
#endif
 
#include "rtl/math.h"
#include "rtl/textenc.h"
#include "rtl/string.h"
#include "rtl/stringutils.hxx"
 
#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_const_literal;
extern bool rtl_string_unittest_const_literal_function;
#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
{
 
#ifdef RTL_STRING_UNITTEST
#undef rtl
// helper macro to make functions appear more readable
#define RTL_STRING_CONST_FUNCTION rtl_string_unittest_const_literal_function = true;
#else
#define RTL_STRING_CONST_FUNCTION
#endif
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
 
template<std::size_t N> class SAL_WARN_UNUSED OStringLiteral {
    static_assert(N != 0);
    static_assert(N - 1 <= std::numeric_limits<sal_Int32>::max(), "literal too long");
 
public:
#if HAVE_CPP_CONSTEVAL
    consteval
#else
    constexpr
#endif
    OStringLiteral(char const (&literal)[N]) {
        assertLayout();
        assert(literal[N - 1] == '\0');
        std::copy_n(literal, N, more.buffer);
    }
 
#if !(defined _MSC_VER && _MSC_VER >= 1930 && _MSC_VER <= 1939 && defined _MANAGED)
#if HAVE_CPP_CONSTEVAL
    consteval
#else
    constexpr
#endif
    OStringLiteral(char8_t const (&literal)[N]) {
        assertLayout();
        assert(literal[N - 1] == '\0');
        std::copy_n(literal, N, more.buffer);
    }
#endif
 
    constexpr sal_Int32 getLength() const { return more.length; }
 
    constexpr char const * getStr() const SAL_RETURNS_NONNULL { return more.buffer; }
 
    constexpr operator std::string_view() const { return {more.buffer, sal_uInt32(more.length)}; }
 
private:
    static constexpr void assertLayout() {
        // These static_asserts verifying the layout compatibility with rtl_String cannot be class
        // member declarations, as offsetof requires a complete type, so defer them to here:
        static_assert(std::is_standard_layout_v<OStringLiteral>);
        static_assert(offsetof(OStringLiteral, str.refCount) == offsetof(OStringLiteral, more.refCount));
        static_assert(offsetof(OStringLiteral, str.length) == offsetof(OStringLiteral, more.length));
        static_assert(offsetof(OStringLiteral, str.buffer) == offsetof(OStringLiteral, more.buffer));
    }
 
    struct Data {
        Data() = default;
 
        oslInterlockedCount refCount = 0x40000000; // SAL_STRING_STATIC_FLAG (sal/rtl/strimp.hxx)
        sal_Int32 length = N - 1;
        char buffer[N];
    };
 
public:
    // (Data members must be public so that OStringLiteral is a structural type that can be used as
    // a non-type template parameter type for operator ""_ostr and rtl::detail::OStringHolder:)
    union {
        rtl_String str;
        Data more = {};
    };
};
 
namespace detail {
 
template<OStringLiteral L> struct OStringHolder {
    static constexpr auto & literal = L;
};
 
}
 
#endif
 
/* ======================================================================= */
 
// coverity[ missing_move_assignment : SUPPRESS] - don't report the suppressed move assignment
class SAL_WARN_UNUSED SAL_DLLPUBLIC_RTTI OString
{
public:
    rtl_String * pData;
 
#if defined LIBO_INTERNAL_ONLY
    constexpr
#endif
    OString()
    {
#if defined LIBO_INTERNAL_ONLY
        pData = const_cast<rtl_String *>(&empty.str);
#else
        pData = NULL;
        rtl_string_new( &pData );
#endif
    }
 
#if defined LIBO_INTERNAL_ONLY
    constexpr
#endif
    OString( const OString & str )
    {
        pData = str.pData;
#if defined LIBO_INTERNAL_ONLY
        if (std::is_constant_evaluated()) {
            //TODO: We would want to
            //
            //   assert(SAL_STRING_IS_STATIC(pData));
            //
            // here, but that wouldn't work because read of member `str` of OUStringLiteral's
            // anonymous union with active member `more` is not allowed in a constant expression.
        } else
#endif
            rtl_string_acquire( pData );
    }
 
#if defined LIBO_INTERNAL_ONLY
#if !defined(__COVERITY__) // suppress COPY_INSTEAD_OF_MOVE suggestions
    constexpr
    OString( OString && str ) noexcept
    {
        pData = str.pData;
        if (std::is_constant_evaluated()) {
            //TODO: We would want to
            //
            //   assert(SAL_STRING_IS_STATIC(pData));
            //
            // here, but that wouldn't work because read of member `str` of OUStringLiteral's
            // anonymous union with active member `more` is not allowed in a constant expression.
            return;
        }
        str.pData = nullptr;
        rtl_string_new( &str.pData );
    }
#endif
#endif
 
    OString( rtl_String * str )
    {
        pData = str;
        rtl_string_acquire( pData );
    }
 
    OString( rtl_String * str, __sal_NoAcquire )
    {
        pData = str;
    }
 
    explicit OString( char value )
        : pData (NULL)
    {
        rtl_string_newFromStr_WithLength( &pData, &value, 1 );
    }
 
#if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST_CONCAT
    // Catch inadvertent conversions to the above ctor (e.g., from sal_[u]Int8, aka [un]signed
    // char):
    OString(int) = delete;
#endif
 
    template< typename T >
    OString( const T& value, typename libreoffice_internal::CharPtrDetector< T, libreoffice_internal::Dummy >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        rtl_string_newFromStr( &pData, value );
    }
 
    template< typename T >
    OString( T& value, typename libreoffice_internal::NonConstCharArrayDetector< T, libreoffice_internal::Dummy >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        rtl_string_newFromStr( &pData, value );
    }
 
#if __cplusplus > 202002L // C++23 P2266R3 "Simpler implicit move"
    template< typename T >
    OString( T&& value, typename libreoffice_internal::NonConstCharArrayDetector< T, libreoffice_internal::Dummy >::Type = libreoffice_internal::Dummy() )
    {
        pData = NULL;
        rtl_string_newFromStr( &pData, value );
    }
#endif
 
    template< typename T >
    OString( 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_string_new(&pData);
        } else {
            rtl_string_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
    }
 
    OString( const char * value, sal_Int32 length )
    {
        pData = NULL;
        rtl_string_newFromStr_WithLength( &pData, value, length );
    }
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
 
    template<std::size_t N> constexpr OString(OStringLiteral<N> const & literal):
        pData(const_cast<rtl_String *>(&literal.str)) {}
    template<std::size_t N> OString(OStringLiteral<N> &&) = delete;
#endif
 
#if defined LIBO_INTERNAL_ONLY
    // For operator ""_tstr:
    template<OStringLiteral L> constexpr OString(detail::OStringHolder<L> const & holder):
        pData(const_cast<rtl_String *>(&holder.literal.str)) {}
#endif
 
#if defined LIBO_INTERNAL_ONLY
    explicit OString(std::string_view sv) {
        if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max())) {
            throw std::bad_alloc();
        }
        pData = nullptr;
        rtl_string_newFromStr_WithLength(&pData, sv.data(), sv.size());
    }
#endif
 
    OString( const sal_Unicode * value, sal_Int32 length,
             rtl_TextEncoding encoding,
             sal_uInt32 convertFlags = OUSTRING_TO_OSTRING_CVTFLAGS )
    {
        pData = NULL;
        rtl_uString2String( &pData, value, length, encoding, convertFlags );
        if (pData == NULL) {
            throw std::bad_alloc();
        }
    }
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    template< typename T1, typename T2 >
    OString( OStringConcat< T1, T2 >&& c )
    {
        const sal_Int32 l = c.length();
        pData = rtl_string_alloc( l );
        if (l != 0)
        {
            char* end = c.addData( pData->buffer );
            pData->length = l;
            *end = '\0';
        }
    }
 
    template< std::size_t N >
    OString( OStringNumber< N >&& n )
        : OString( n.buf, n.length )
    {}
#endif
 
#ifdef LIBO_INTERNAL_ONLY
    OString(std::nullptr_t) = delete;
#endif
 
#if defined LIBO_INTERNAL_ONLY
    constexpr
#endif
    ~OString()
    {
#if defined LIBO_INTERNAL_ONLY
        if (std::is_constant_evaluated()) {
           //TODO: We would want to
           //
           //   assert(SAL_STRING_IS_STATIC(pData));
           //
           // here, but that wouldn't work because read of member `str` of OUStringLiteral's
           // anonymous union with active member `more` is not allowed in a constant expression.
        } else
#endif
            rtl_string_release( pData );
    }
 
#if defined LIBO_INTERNAL_ONLY
    static OString const & unacquired( rtl_String * const * ppHandle )
        { return * reinterpret_cast< OString const * >( ppHandle ); }
#endif
 
    OString & operator=( const OString & str )
    {
        rtl_string_assign( &pData, str.pData );
        return *this;
    }
 
#if defined LIBO_INTERNAL_ONLY
#if !defined(__COVERITY__) // suppress COPY_INSTEAD_OF_MOVE suggestions
    OString & operator=( OString && str ) noexcept
    {
        rtl_string_release( pData );
        pData = str.pData;
        str.pData = nullptr;
        rtl_string_new( &str.pData );
        return *this;
    }
#endif
#endif
 
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, OString& >::Type operator=( T& literal )
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        if (libreoffice_internal::ConstCharArrayDetector<T>::length == 0) {
            rtl_string_new(&pData);
        } else {
            rtl_string_newFromLiteral(
                &pData,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length, 0);
        }
        return *this;
    }
 
    OString & operator+=( const OString & str )
#if defined LIBO_INTERNAL_ONLY
        &
#endif
    {
        rtl_string_newConcat( &pData, pData, str.pData );
        return *this;
    }
#if defined LIBO_INTERNAL_ONLY
    void operator+=(OString const &) && = delete;
#endif
 
#if defined LIBO_INTERNAL_ONLY
    template<typename T> typename libreoffice_internal::CharPtrDetector<T, OString &>::Type
    operator +=(T const & value) & { return operator +=(std::string_view(value)); }
    template<typename T> typename libreoffice_internal::CharPtrDetector<T, OString &>::Type
    operator +=(T const &) && = delete;
 
    template<typename T>
    typename libreoffice_internal::NonConstCharArrayDetector<T, OString &>::Type
    operator +=(T & value) & { return operator +=(std::string_view(value)); }
    template<typename T>
    typename libreoffice_internal::NonConstCharArrayDetector<T, OString &>::Type operator +=(T &) &&
        = delete;
 
    template<typename T> typename libreoffice_internal::ConstCharArrayDetector<T, OString &>::Type
    operator +=(T & literal) & {
        assert(libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return operator +=(
            std::string_view(
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length));
    }
    template<typename T> typename libreoffice_internal::ConstCharArrayDetector<T, OString &>::Type
    operator +=(T &) && = delete;
 
    template<std::size_t N> OString & operator +=(OStringLiteral<N> const & literal) &
    { return operator +=(std::string_view(literal.getStr(), literal.getLength())); }
    template<std::size_t N> void operator +=(OStringLiteral<N> const &) && = delete;
 
    OString & operator +=(std::string_view sv) & {
        if (sv.empty()) {
            return *this;
        }
        if (sv.size() > sal_uInt32(std::numeric_limits<sal_Int32>::max() - pData->length)) {
            throw std::bad_alloc();
        }
        auto const l = pData->length + sv.size();
        rtl_string_ensureCapacity(&pData, l);
        *addDataHelper(pData->buffer + pData->length, sv.data(), sv.size()) = '\0';
        pData->length = l;
        return *this;
    }
    void operator +=(std::string_view) && = delete;
#endif
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    template< typename T1, typename T2 >
    OString& operator+=( OStringConcat< T1, T2 >&& c ) & {
        sal_Int32 l = c.length();
        if( l == 0 )
            return *this;
        l += pData->length;
        rtl_string_ensureCapacity( &pData, l );
        char* end = c.addData( pData->buffer + pData->length );
        *end = '\0';
        pData->length = l;
        return *this;
    }
    template<typename T1, typename T2> void operator +=(
        OStringConcat<T1, T2> &&) && = delete;
 
    template< std::size_t N >
    OString& operator+=( OStringNumber< N >&& n ) & {
        return operator +=(std::string_view(n.buf, n.length));
    }
    template<std::size_t N> void operator +=(
        OStringNumber<N> &&) && = delete;
#endif
 
    void clear()
    {
        rtl_string_new( &pData );
    }
 
    sal_Int32 getLength() const { return pData->length; }
 
    bool isEmpty() const
    {
        return pData->length == 0;
    }
 
    const char * getStr() const SAL_RETURNS_NONNULL { return pData->buffer; }
 
    char 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];
    }
 
    sal_Int32 compareTo( const OString & str ) const
    {
        return rtl_str_compare_WithLength( pData->buffer, pData->length,
                                           str.pData->buffer, str.pData->length );
    }
 
    sal_Int32 compareTo( const OString & rObj, sal_Int32 maxLength ) const
    {
        return rtl_str_shortenedCompare_WithLength( pData->buffer, pData->length,
                                                    rObj.pData->buffer, rObj.pData->length, maxLength );
    }
 
    sal_Int32 reverseCompareTo( const OString & str ) const
    {
        return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length,
                                                  str.pData->buffer, str.pData->length );
    }
 
    bool equals( const OString & str ) const
    {
        if ( pData->length != str.pData->length )
            return false;
        if ( pData == str.pData )
            return true;
        return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length,
                                                  str.pData->buffer, str.pData->length ) == 0;
    }
 
    bool equalsL( const char* value, sal_Int32 length ) const
    {
        if ( pData->length != length )
            return false;
 
        return rtl_str_reverseCompare_WithLength( pData->buffer, pData->length,
                                                  value, length ) == 0;
    }
 
#if defined LIBO_INTERNAL_ONLY
    bool equalsIgnoreAsciiCase( std::string_view str ) const
    {
        if ( sal_uInt32(pData->length) != str.size() )
            return false;
        if ( pData->buffer == str.data() )
            return true;
        return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                          str.data(), str.size() ) == 0;
    }
#else
    bool equalsIgnoreAsciiCase( const OString & str ) const
    {
        if ( pData->length != str.pData->length )
            return false;
        if ( pData == str.pData )
            return true;
        return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                          str.pData->buffer, str.pData->length ) == 0;
    }
#endif
 
    template< typename T >
    typename libreoffice_internal::CharPtrDetector< T, bool >::Type equalsIgnoreAsciiCase( const T& asciiStr ) const
    {
        return rtl_str_compareIgnoreAsciiCase( pData->buffer, asciiStr ) == 0;
    }
 
    template< typename T >
    typename libreoffice_internal::NonConstCharArrayDetector< T, bool >::Type equalsIgnoreAsciiCase( T& asciiStr ) const
    {
        return rtl_str_compareIgnoreAsciiCase( pData->buffer, asciiStr ) == 0;
    }
 
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type  equalsIgnoreAsciiCase( T& literal ) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return
            (pData->length
             == libreoffice_internal::ConstCharArrayDetector<T>::length)
            && (rtl_str_compareIgnoreAsciiCase_WithLength(
                    pData->buffer, pData->length,
                    libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                        literal),
                    libreoffice_internal::ConstCharArrayDetector<T>::length)
                == 0);
    }
 
    bool equalsIgnoreAsciiCaseL( const char * asciiStr, sal_Int32 asciiStrLength ) const
    {
        if ( pData->length != asciiStrLength )
            return false;
 
        return rtl_str_compareIgnoreAsciiCase_WithLength( pData->buffer, pData->length,
                                                          asciiStr, asciiStrLength ) == 0;
    }
 
#if defined LIBO_INTERNAL_ONLY
    bool match( std::string_view str, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        return rtl_str_shortenedCompare_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                    str.data(), str.size(), str.size() ) == 0;
    }
#else
    bool match( const OString & str, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        return rtl_str_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
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        assert(fromIndex >= 0);
        return
            rtl_str_shortenedCompare_WithLength(
                pData->buffer + fromIndex, pData->length - fromIndex,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length,
                libreoffice_internal::ConstCharArrayDetector<T>::length)
            == 0;
    }
 
    bool matchL(
        char const * str, sal_Int32 strLength, sal_Int32 fromIndex = 0)
        const
    {
        assert(fromIndex >= 0);
        return rtl_str_shortenedCompare_WithLength(
            pData->buffer + fromIndex, pData->length - fromIndex,
            str, strLength, strLength) == 0;
    }
 
    // This overload is left undefined, to detect calls of matchL 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 matchL(char const *, sal_Int32, rtl_TextEncoding) const;
#endif
 
#if defined LIBO_INTERNAL_ONLY
    bool matchIgnoreAsciiCase( std::string_view str, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        return rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                                   str.data(), str.size(),
                                                                   str.size() ) == 0;
    }
#else
    bool matchIgnoreAsciiCase( const OString & str, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        return rtl_str_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
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        assert(fromIndex >= 0);
        return
            rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
                pData->buffer+fromIndex, pData->length-fromIndex,
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                libreoffice_internal::ConstCharArrayDetector<T>::length,
                libreoffice_internal::ConstCharArrayDetector<T>::length)
            == 0;
    }
 
#if defined LIBO_INTERNAL_ONLY
    bool startsWith(std::string_view str) const {
        return match(str);
    }
    bool startsWith(std::string_view str, OString * rest) const {
        assert(rest);
        bool b = startsWith(str);
        if (b) {
            *rest = copy(str.size());
        }
        return b;
    }
    bool startsWith(std::string_view str, std::string_view * rest) const {
        assert(rest);
        bool b = startsWith(str);
        if (b) {
            *rest = subView(str.size());
        }
        return b;
    }
#else
    bool startsWith(OString const & str, OString * rest = NULL) const {
        bool b = match(str);
        if (b && rest != NULL) {
            *rest = copy(str.getLength());
        }
        return b;
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(
        T & literal) const
    {
        RTL_STRING_CONST_FUNCTION
        return match(literal, 0);
    }
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(
        T & literal, OString * rest) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(rest);
        bool b = startsWith(literal);
        if (b) {
            *rest = copy(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(
        T & literal, std::string_view * rest) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(rest);
        bool b = startsWith(literal);
        if (b) {
            *rest = subView(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }
#else
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type startsWith(
        T & literal, OString * rest = NULL) const
    {
        RTL_STRING_CONST_FUNCTION
        bool b = match(literal, 0);
        if (b && rest != NULL) {
            *rest = copy(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }
#endif
 
    bool startsWith(char ch) const
    {
        return !isEmpty() && pData->buffer[0] == ch;
    }
 
    bool startsWith(char ch, OString* rest) const {
        assert(rest);
        bool b = startsWith(ch);
 
        if (b)
            *rest = copy(1);
 
        return b;
    }
 
#if defined LIBO_INTERNAL_ONLY
    bool startsWith(char ch, std::string_view* rest) const {
        assert(rest);
        bool b = startsWith(ch);
 
        if (b)
            *rest = subView(1);
 
        return b;
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    bool startsWithIgnoreAsciiCase(std::string_view str)
        const
    {
        return matchIgnoreAsciiCase(str);
    }
    bool startsWithIgnoreAsciiCase(std::string_view str, OString * rest)
        const
    {
        assert(rest);
        bool b = startsWithIgnoreAsciiCase(str);
        if (b) {
            *rest = copy(str.size());
        }
        return b;
    }
    bool startsWithIgnoreAsciiCase(std::string_view str, std::string_view * rest)
        const
    {
        assert(rest);
        bool b = startsWithIgnoreAsciiCase(str);
        if (b) {
            *rest = subView(str.size());
        }
        return b;
    }
#else
    bool startsWithIgnoreAsciiCase(OString const & str, OString * rest = NULL)
        const
    {
        bool b = matchIgnoreAsciiCase(str);
        if (b && rest != NULL) {
            *rest = copy(str.getLength());
        }
        return b;
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    startsWithIgnoreAsciiCase(T & literal) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return matchIgnoreAsciiCase(literal);
    }
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    startsWithIgnoreAsciiCase(T & literal, OString * rest) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(rest);
        bool b = startsWithIgnoreAsciiCase(literal);
        if (b) {
            *rest = copy(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    startsWithIgnoreAsciiCase(T & literal, std::string_view * rest) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(rest);
        bool b = startsWithIgnoreAsciiCase(literal);
        if (b) {
            *rest = subView(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }
#else
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type
    startsWithIgnoreAsciiCase(T & literal, OString * rest = NULL) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b = matchIgnoreAsciiCase(literal);
        if (b && rest != NULL) {
            *rest = copy(
                libreoffice_internal::ConstCharArrayDetector<T>::length);
        }
        return b;
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    bool endsWith(std::string_view str) const {
        return str.size() <= sal_uInt32(getLength())
            && match(str, getLength() - str.size());
    }
    bool endsWith(std::string_view str, OString * rest) const {
        assert(rest);
        bool b = endsWith(str);
        if (b) {
            *rest = copy(0, getLength() - str.size());
        }
        return b;
    }
    bool endsWith(std::string_view str, std::string_view * rest) const {
        assert(rest);
        bool b = endsWith(str);
        if (b) {
            *rest = subView(0, getLength() - str.size());
        }
        return b;
    }
#else
    bool endsWith(OString const & str, OString * 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
 
#if defined LIBO_INTERNAL_ONLY
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type endsWith(
        T & literal) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b
            = (libreoffice_internal::ConstCharArrayDetector<T>::length
               <= sal_uInt32(getLength()))
            && match(
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        return b;
    }
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type endsWith(
        T & literal, OString * rest) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(rest);
        bool b = endsWith(literal);
        if (b) {
            *rest = copy(
                0,
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        }
        return b;
    }
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type endsWith(
        T & literal, std::string_view * rest) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(rest);
        bool b = endsWith(literal);
        if (b) {
            *rest = subView(
                0,
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        }
        return b;
    }
#else
    template< typename T >
    typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type endsWith(
        T & literal, OString * rest = NULL) const
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        bool b
            = (libreoffice_internal::ConstCharArrayDetector<T>::length
               <= sal_uInt32(getLength()))
            && match(
                libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                    literal),
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        if (b && rest != NULL) {
            *rest = copy(
                0,
                (getLength()
                 - libreoffice_internal::ConstCharArrayDetector<T>::length));
        }
        return b;
    }
#endif
 
    bool endsWithL(char const * str, sal_Int32 strLength) const {
        return strLength <= getLength()
            && matchL(str, strLength, getLength() - strLength);
    }
 
    bool endsWith(char ch) const
    {
        return !isEmpty() && pData->buffer[pData->length - 1] == ch;
    }
 
    bool endsWith(char ch, OString* rest) const {
        assert(rest);
        bool b = endsWith(ch);
 
        if (b)
            *rest = copy(0, pData->length - 1);
 
        return b;
    }
 
#if defined LIBO_INTERNAL_ONLY
    bool endsWith(char ch, std::string_view* rest) const {
        assert(rest);
        bool b = endsWith(ch);
 
        if (b)
            *rest = subView(0, pData->length - 1);
 
        return b;
    }
#endif
 
    friend bool     operator == ( const OString& rStr1, const OString& rStr2 )
                        { return rStr1.equals(rStr2); }
    friend bool     operator != ( const OString& rStr1,     const OString& rStr2 )
                        { return !(operator == ( rStr1, rStr2 )); }
    friend bool     operator <  ( const OString& rStr1,    const OString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) < 0; }
    friend bool     operator >  ( const OString& rStr1,    const OString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) > 0; }
    friend bool     operator <= ( const OString& rStr1,    const OString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) <= 0; }
    friend bool     operator >= ( const OString& rStr1,    const OString& rStr2 )
                        { return rStr1.compareTo( rStr2 ) >= 0; }
 
    template< typename T >
    friend typename libreoffice_internal::CharPtrDetector< T, bool >::Type operator==( const OString& rStr1, const T& value )
    {
        return
            rtl_str_compare_WithLength(
                rStr1.getStr(), rStr1.getLength(), value, rtl_str_getLength(value))
            == 0;
    }
 
    template< typename T >
    friend typename libreoffice_internal::NonConstCharArrayDetector< T, bool >::Type operator==( const OString& rStr1, T& value )
    {
        return
            rtl_str_compare_WithLength(
                rStr1.getStr(), rStr1.getLength(), value, rtl_str_getLength(value))
            == 0;
    }
 
    template< typename T >
    friend typename libreoffice_internal::CharPtrDetector< T, bool >::Type operator==( const T& value, const OString& rStr2 )
    {
        return
            rtl_str_compare_WithLength(
                value, rtl_str_getLength(value), rStr2.getStr(), rStr2.getLength())
            == 0;
    }
 
    template< typename T >
    friend typename libreoffice_internal::NonConstCharArrayDetector< T, bool >::Type operator==( T& value, const OString& rStr2 )
    {
        return
            rtl_str_compare_WithLength(
                value, rtl_str_getLength(value), rStr2.getStr(), rStr2.getLength())
            == 0;
    }
 
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==( const OString& rStr, T& literal )
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return
            (rStr.getLength()
             == libreoffice_internal::ConstCharArrayDetector<T>::length)
            && (rtl_str_compare_WithLength(
                    rStr.pData->buffer, rStr.pData->length,
                    libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                        literal),
                    libreoffice_internal::ConstCharArrayDetector<T>::length)
                == 0);
    }
 
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator==( T& literal, const OString& rStr )
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        return
            (rStr.getLength()
             == libreoffice_internal::ConstCharArrayDetector<T>::length)
            && (rtl_str_compare_WithLength(
                    rStr.pData->buffer, rStr.pData->length,
                    libreoffice_internal::ConstCharArrayDetector<T>::toPointer(
                        literal),
                    libreoffice_internal::ConstCharArrayDetector<T>::length)
                == 0);
    }
 
    template< typename T >
    friend typename libreoffice_internal::CharPtrDetector< T, bool >::Type operator!=( const OString& rStr1, const T& value )
    {
        return !(operator == ( rStr1, value ));
    }
 
    template< typename T >
    friend typename libreoffice_internal::NonConstCharArrayDetector< T, bool >::Type operator!=( const OString& rStr1, T& value )
    {
        return !(operator == ( rStr1, value ));
    }
 
    template< typename T >
    friend typename libreoffice_internal::CharPtrDetector< T, bool >::Type operator!=( const T& value,   const OString& rStr2 )
    {
        return !(operator == ( value, rStr2 ));
    }
 
    template< typename T >
    friend typename libreoffice_internal::NonConstCharArrayDetector< T, bool >::Type operator!=( T& value,   const OString& rStr2 )
    {
        return !(operator == ( value, rStr2 ));
    }
 
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=( const OString& rStr, T& literal )
    {
        return !( rStr == literal );
    }
 
    template< typename T >
    friend typename libreoffice_internal::ConstCharArrayDetector< T, bool >::Type operator!=( T& literal, const OString& rStr )
    {
        return !( literal == rStr );
    }
 
    sal_Int32 hashCode() const
    {
        return rtl_str_hashCode_WithLength( pData->buffer, pData->length );
    }
 
    sal_Int32 indexOf( char ch, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        sal_Int32 ret = rtl_str_indexOfChar_WithLength( pData->buffer+fromIndex, pData->length-fromIndex, ch );
        return (ret < 0 ? ret : ret+fromIndex);
    }
 
    sal_Int32 lastIndexOf( char ch ) const
    {
        return rtl_str_lastIndexOfChar_WithLength( pData->buffer, pData->length, ch );
    }
 
    sal_Int32 lastIndexOf( char ch, sal_Int32 fromIndex ) const
    {
        return rtl_str_lastIndexOfChar_WithLength( pData->buffer, fromIndex, ch );
    }
 
#if defined LIBO_INTERNAL_ONLY
    sal_Int32 indexOf( std::string_view str, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        sal_Int32 ret = rtl_str_indexOfStr_WithLength( pData->buffer+fromIndex, pData->length-fromIndex,
                                                       str.data(), str.size() );
        return (ret < 0 ? ret : ret+fromIndex);
    }
#else
    sal_Int32 indexOf( const OString & str, sal_Int32 fromIndex = 0 ) const
    {
        assert(fromIndex >= 0);
        sal_Int32 ret = rtl_str_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
    {
        RTL_STRING_CONST_FUNCTION
        assert(
            libreoffice_internal::ConstCharArrayDetector<T>::isValid(literal));
        assert(fromIndex >= 0);
        sal_Int32 n = rtl_str_indexOfStr_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 indexOfL(char const * str, sal_Int32 len, sal_Int32 fromIndex = 0)
        const
    {
        assert(fromIndex >= 0);
        sal_Int32 n = rtl_str_indexOfStr_WithLength(
            pData->buffer + fromIndex, pData->length - fromIndex, str, len);
        return n < 0 ? n : n + fromIndex;
    }
 
    // This overload is left undefined, to detect calls of indexOfL 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 indexOfL(char const *, sal_Int32, rtl_TextEncoding) const;
#endif
 
#if defined LIBO_INTERNAL_ONLY
    sal_Int32 lastIndexOf( std::string_view str ) const
    {
        return rtl_str_lastIndexOfStr_WithLength( pData->buffer, pData->length,
                                                  str.data(), str.size() );
    }
#else
    sal_Int32 lastIndexOf( const OString & str ) const
    {
        return rtl_str_lastIndexOfStr_WithLength( pData->buffer, pData->length,
                                                  str.pData->buffer, str.pData->length );
    }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    sal_Int32 lastIndexOf( std::string_view str, sal_Int32 fromIndex ) const
    {
        return rtl_str_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
                                                  str.data(), str.size() );
    }
#else
    sal_Int32 lastIndexOf( const OString & str, sal_Int32 fromIndex ) const
    {
        return rtl_str_lastIndexOfStr_WithLength( pData->buffer, fromIndex,
                                                  str.pData->buffer, str.pData->length );
    }
#endif
 
    SAL_WARN_UNUSED_RESULT OString copy( sal_Int32 beginIndex ) const
    {
        return copy(beginIndex, getLength() - beginIndex);
    }
 
    SAL_WARN_UNUSED_RESULT OString copy( sal_Int32 beginIndex, sal_Int32 count ) const
    {
        rtl_String *pNew = NULL;
        rtl_string_newFromSubString( &pNew, pData, beginIndex, count );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
 
#if defined LIBO_INTERNAL_ONLY
    SAL_WARN_UNUSED_RESULT std::string_view subView( sal_Int32 beginIndex ) const
    {
        assert(beginIndex >= 0);
        assert(beginIndex <= getLength());
        return subView(beginIndex, getLength() - beginIndex);
    }
 
    SAL_WARN_UNUSED_RESULT std::string_view subView( sal_Int32 beginIndex, sal_Int32 count ) const
    {
        assert(beginIndex >= 0);
        assert(count >= 0);
        assert(beginIndex <= getLength());
        assert(count <= getLength() - beginIndex);
        return std::string_view(*this).substr(beginIndex, count);
    }
#endif
 
#ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    SAL_WARN_UNUSED_RESULT OString concat( const OString & str ) const
    {
        rtl_String* pNew = NULL;
        rtl_string_newConcat( &pNew, pData, str.pData );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
#endif
 
#ifndef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    friend OString operator+( const OString & str1, const OString & str2  )
    {
        return str1.concat( str2 );
    }
#endif
 
// hide this from internal code to avoid ambiguous lookup error
#ifndef LIBO_INTERNAL_ONLY
    SAL_WARN_UNUSED_RESULT OString replaceAt( sal_Int32 index, sal_Int32 count, const OString& newStr ) const
    {
        rtl_String* pNew = NULL;
        rtl_string_newReplaceStrAt( &pNew, pData, index, count, newStr.pData );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
#endif
 
#ifdef LIBO_INTERNAL_ONLY
    SAL_WARN_UNUSED_RESULT OString replaceAt( sal_Int32 index, sal_Int32 count, std::string_view newStr ) const
    {
        rtl_String* pNew = NULL;
        rtl_string_newReplaceStrAt_WithLength ( &pNew, pData, index, count, newStr.data(), newStr.size() );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
#endif
 
    SAL_WARN_UNUSED_RESULT OString replace( char oldChar, char newChar ) const
    {
        rtl_String* pNew = NULL;
        rtl_string_newReplace( &pNew, pData, oldChar, newChar );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
 
    SAL_WARN_UNUSED_RESULT OString replaceFirst(
        OString const & from, OString const & to, sal_Int32 * index = NULL) const
    {
        rtl_String * s = NULL;
        sal_Int32 i = 0;
        rtl_string_newReplaceFirst(
            &s, pData, from.pData->buffer, from.pData->length,
            to.pData->buffer, to.pData->length, index == NULL ? &i : index);
        return OString(s, SAL_NO_ACQUIRE);
    }
 
    SAL_WARN_UNUSED_RESULT OString replaceAll(OString const & from, OString const & to) const {
        rtl_String * s = NULL;
        rtl_string_newReplaceAll(
            &s, pData, from.pData->buffer, from.pData->length,
            to.pData->buffer, to.pData->length);
        return OString(s, SAL_NO_ACQUIRE);
    }
 
    SAL_WARN_UNUSED_RESULT OString toAsciiLowerCase() const
    {
        rtl_String* pNew = NULL;
        rtl_string_newToAsciiLowerCase( &pNew, pData );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
 
    SAL_WARN_UNUSED_RESULT OString toAsciiUpperCase() const
    {
        rtl_String* pNew = NULL;
        rtl_string_newToAsciiUpperCase( &pNew, pData );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
 
    SAL_WARN_UNUSED_RESULT OString trim() const
    {
        rtl_String* pNew = NULL;
        rtl_string_newTrim( &pNew, pData );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
 
    OString getToken( sal_Int32 token, char cTok, sal_Int32& index ) const
    {
        rtl_String * pNew = NULL;
        index = rtl_string_getToken( &pNew, pData, token, cTok, index );
        return OString( pNew, SAL_NO_ACQUIRE );
    }
 
    OString getToken(sal_Int32 count, char separator) const {
        sal_Int32 n = 0;
        return getToken(count, separator, n);
    }
 
    bool toBoolean() const
    {
        return rtl_str_toBoolean( pData->buffer );
    }
 
    char toChar() const
    {
        return pData->buffer[0];
    }
 
    sal_Int32 toInt32( sal_Int16 radix = 10 ) const
    {
        return rtl_str_toInt32( pData->buffer, radix );
    }
 
    sal_uInt32 toUInt32( sal_Int16 radix = 10 ) const
    {
        return rtl_str_toUInt32( pData->buffer, radix );
    }
 
    sal_Int64 toInt64( sal_Int16 radix = 10 ) const
    {
        return rtl_str_toInt64( pData->buffer, radix );
    }
 
    sal_uInt64 toUInt64( sal_Int16 radix = 10 ) const
    {
        return rtl_str_toUInt64( pData->buffer, radix );
    }
 
    float toFloat() const
    {
        return rtl_str_toFloat( pData->buffer );
    }
 
    double toDouble() const
    {
        return rtl_str_toDouble( pData->buffer );
    }
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
 
    static auto number( int i, sal_Int16 radix = 10 )
    {
        return OStringNumber<RTL_STR_MAX_VALUEOFINT32>(rtl_str_valueOfInt32, i, radix);
    }
    static auto number( long long ll, sal_Int16 radix = 10 )
    {
        return OStringNumber<RTL_STR_MAX_VALUEOFINT64>(rtl_str_valueOfInt64, ll, radix);
    }
    static auto number( unsigned long long ll, sal_Int16 radix = 10 )
    {
        return OStringNumber<RTL_STR_MAX_VALUEOFUINT64>(rtl_str_valueOfUInt64, ll, radix);
    }
    static auto number( unsigned int i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static auto number( long i, sal_Int16 radix = 10)
    {
        return number( static_cast< long long >( i ), radix );
    }
    static auto number( unsigned long i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
#else
    static OString number( int i, sal_Int16 radix = 10 )
    {
        char aBuf[RTL_STR_MAX_VALUEOFINT32];
        return OString(aBuf, rtl_str_valueOfInt32(aBuf, i, radix));
    }
    static OString number( unsigned int i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static OString number( long i, sal_Int16 radix = 10 )
    {
        return number( static_cast< long long >( i ), radix );
    }
    static OString number( unsigned long i, sal_Int16 radix = 10 )
    {
        return number( static_cast< unsigned long long >( i ), radix );
    }
    static OString number( long long ll, sal_Int16 radix = 10 )
    {
        char aBuf[RTL_STR_MAX_VALUEOFINT64];
        return OString(aBuf, rtl_str_valueOfInt64(aBuf, ll, radix));
    }
    static OString number( unsigned long long ll, sal_Int16 radix = 10 )
    {
        char aBuf[RTL_STR_MAX_VALUEOFUINT64];
        return OString(aBuf, rtl_str_valueOfUInt64(aBuf, ll, radix));
    }
#endif
 
    static OString number( float f )
    {
        rtl_String* pNew = NULL;
        // Same as rtl::str::valueOfFP, used for rtl_str_valueOfFloat
        rtl_math_doubleToString(&pNew, NULL, 0, f, rtl_math_StringFormat_G,
                                RTL_STR_MAX_VALUEOFFLOAT - SAL_N_ELEMENTS("-x.E-xxx") + 1, '.',
                                NULL, 0, true);
        if (pNew == NULL)
            throw std::bad_alloc();
 
        return OString(pNew, SAL_NO_ACQUIRE);
    }
 
    static OString number( double d )
    {
        rtl_String* pNew = NULL;
        // Same as rtl::str::valueOfFP, used for rtl_str_valueOfDouble
        rtl_math_doubleToString(&pNew, NULL, 0, d, rtl_math_StringFormat_G,
                                RTL_STR_MAX_VALUEOFDOUBLE - SAL_N_ELEMENTS("-x.E-xxx") + 1, '.',
                                NULL, 0, true);
        if (pNew == NULL)
            throw std::bad_alloc();
 
        return OString(pNew, SAL_NO_ACQUIRE);
    }
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
    static auto boolean(bool b)
    {
        return OStringNumber<RTL_STR_MAX_VALUEOFBOOLEAN>(rtl_str_valueOfBoolean, b);
    }
#else
    SAL_DEPRECATED("use boolean()") static OString valueOf( sal_Bool b )
    {
        return boolean(b);
    }
 
    static OString boolean( bool b )
    {
        char aBuf[RTL_STR_MAX_VALUEOFBOOLEAN];
        return OString(aBuf, rtl_str_valueOfBoolean(aBuf, b));
    }
#endif
 
    SAL_DEPRECATED("convert to OString or use directly") static OString valueOf( char c )
    {
        return OString( &c, 1 );
    }
 
    SAL_DEPRECATED("use number()") static OString valueOf( sal_Int32 i, sal_Int16 radix = 10 )
    {
        return number( i, radix );
    }
 
    SAL_DEPRECATED("use number()") static OString valueOf( sal_Int64 ll, sal_Int16 radix = 10 )
    {
        return number( ll, radix );
    }
 
    SAL_DEPRECATED("use number()") static OString valueOf( float f )
    {
        return number(f);
    }
 
    SAL_DEPRECATED("use number()") static OString valueOf( double d )
    {
        return number(d);
    }
 
#if defined LIBO_INTERNAL_ONLY
    operator std::string_view() const { return {getStr(), sal_uInt32(getLength())}; }
#endif
 
#if defined LIBO_INTERNAL_ONLY
    // A wrapper for the first expression in an
    //
    //   OString::Concat(e1) + e2 + ...
    //
    // concatenation chain, when neither of the first two e1, e2 is one of our rtl string-related
    // classes (so something like
    //
    //   OString s = "a" + (b ? std::string_view("c") : std::string_view("dd"));
    //
    // would not compile):
    template<typename T> [[nodiscard]] static
    OStringConcat<OStringConcatMarker, T>
    Concat(T const & value) { return OStringConcat<OStringConcatMarker, T>(value); }
 
    // This overload is needed so that an argument of type 'char const[N]' ends up as
    // 'OStringConcat<rtl::OStringConcatMarker, char const[N]>' rather than as
    // 'OStringConcat<rtl::OStringConcatMarker, char[N]>':
    template<typename T, std::size_t N> [[nodiscard]] static
    OStringConcat<OStringConcatMarker, T[N]>
    Concat(T (& value)[N]) { return OStringConcat<OStringConcatMarker, T[N]>(value); }
#endif
 
private:
#if defined LIBO_INTERNAL_ONLY
        static constexpr auto empty = OStringLiteral(""); // [-loplugin:ostr]
#endif
};
 
#if defined LIBO_INTERNAL_ONLY
inline bool operator ==(OString const & lhs, StringConcatenation<char> const & rhs)
{ return lhs == std::string_view(rhs); }
inline bool operator !=(OString const & lhs, StringConcatenation<char> const & rhs)
{ return lhs != std::string_view(rhs); }
inline bool operator ==(StringConcatenation<char> const & lhs, OString const & rhs)
{ return std::string_view(lhs) == rhs; }
inline bool operator !=(StringConcatenation<char> const & lhs, OString const & rhs)
{ return std::string_view(lhs) != rhs; }
#endif
 
/* ======================================================================= */
 
#ifdef LIBO_INTERNAL_ONLY // "RTL_FAST_STRING"
 
template<>
struct ToStringHelper< OString >
{
    static std::size_t length( const OString& s ) { return s.getLength(); }
    char* operator()( char* buffer, const OString& s ) const { return addDataHelper( buffer, s.getStr(), s.getLength()); }
};
 
template<std::size_t N>
struct ToStringHelper< OStringLiteral<N> >
{
    static constexpr std::size_t length( const OStringLiteral<N>& str ) { return str.getLength(); }
    char* operator()( char* buffer, const OStringLiteral<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, OStringConcat< T1, T2 >&& concat)
{
    return stream << OString( std::move(concat) );
}
#endif
 
 
struct OStringHash
{
    size_t operator()( const OString& rString ) const
        { return static_cast<size_t>(rString.hashCode()); }
};
 
struct CStringEqual
{
    bool operator()( const char* p1, const char* p2) const
        { return rtl_str_compare(p1, p2) == 0; }
};
 
struct CStringHash
{
    size_t operator()(const char* p) const
        { return rtl_str_hashCode(p); }
};
 
/* ======================================================================= */
 
template< typename charT, typename traits > std::basic_ostream<charT, traits> &
operator <<(
    std::basic_ostream<charT, traits> & stream, OString const & rString)
{
    return stream << rString.getStr();
        // best effort; potentially loses data due to embedded null characters
}
 
} /* Namespace */
 
#ifdef RTL_STRING_UNITTEST
namespace rtl
{
typedef rtlunittest::OString OString;
}
#undef RTL_STRING_CONST_FUNCTION
#endif
 
#if defined LIBO_INTERNAL_ONLY && !defined RTL_STRING_UNITTEST
using ::rtl::OString;
using ::rtl::OStringChar;
using ::rtl::Concat2View;
using ::rtl::OStringHash;
using ::rtl::OStringLiteral;
using RepeatedChar = ::rtl::RepeatedChar_t<char>;
#endif
 
#if defined LIBO_INTERNAL_ONLY
 
template<
#if defined RTL_STRING_UNITTEST
    rtlunittest::
#endif
    OStringLiteral L>
constexpr
#if defined RTL_STRING_UNITTEST
    rtlunittest::
#endif
    OString
operator ""_ostr() { return L; }
 
template<
#if defined RTL_STRING_UNITTEST
    rtlunittest::
#endif
    OStringLiteral L>
constexpr
#if defined RTL_STRING_UNITTEST
rtlunittest
#else
rtl
#endif
::detail::OStringHolder<L> operator ""_tstr() {
    return
#if defined RTL_STRING_UNITTEST
        rtlunittest
#else
        rtl
#endif
        ::detail::OStringHolder<L>();
}
 
#endif
 
 
#if defined LIBO_INTERNAL_ONLY
namespace std {
 
template<>
struct hash<::rtl::OString>
{
    std::size_t operator()(::rtl::OString 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 = s.getLength();
            for (sal_Int32 i = 0, len = s.getLength(); i < len; ++i)
                n = 37 * n + s[i];
            return n;
        }
        else
            return std::size_t(s.hashCode());
    }
};
 
}
 
#endif
 
#endif // INCLUDED_RTL_STRING_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */