string.h

 
#ifndef _aspose_system_string_h_
#define _aspose_system_string_h_
 
#include <system/text/normalization_form.h>
#include <system/string_comparison.h>
#include <system/shared_ptr.h>
#include <system/details/icu_namespace.h>
#include <system/details/stack_array.h>
#include <system/object.h>
#include <system/boxable_traits.h>
#include <system/icomparable.h>
 
#include <istream>
#include <ostream>
#include <string>
#include <sstream>
#include <system/diagnostics/debug.h>
#include <iterator>
#include <cstdint>
 
#include <fwd.h>
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <unicode/unistr.h>
#endif
ASPOSECPP_3RD_PARTY_ICU_NAMESPACE_START {
    ASPOSECPP_3RD_PARTY_CLASS(UnicodeString);
}
 
ASPOSECPP_3RD_PARTY_TYPEDEF(UChar, char16_t);
 
namespace System { namespace Text { class StringBuilder; } }
namespace System { namespace Text { namespace RegularExpressions { class Regex; } } }
namespace System { namespace Text { namespace RegularExpressions { namespace Detail { class Formatter; } } } }
namespace System { namespace Globalization { class CompareInfo; } }
namespace System { namespace Globalization { class TextElementEnumerator; } }
namespace System { namespace Globalization { class TextInfo; } }
namespace System { namespace Collections { namespace Generic { template <typename T> class IEnumerable; } } }
namespace System { template<typename T> class ReadOnlySpan; }
 
namespace System { namespace Details { template<typename T> class ArrayView; } }
 
namespace System
{
 
namespace Detail {
    ASPOSECPP_3RD_PARTY_TYPE_HOLDER(codeporting_icu::UnicodeString, UnicodeString, 64, size_t, UnicodeStringHolder);
}
 
enum class StringSplitOptions
{
    None = 0,
    RemoveEmptyEntries = 1
};
 
using codeporting_icu::UnicodeString;
 
template <typename T, typename CharT>
struct IsStringByteSequence
    : public std::integral_constant<bool, std::is_same<typename std::remove_const<typename std::remove_pointer<typename std::decay<T>::type>::type>::type, CharT>::value> {};
 
template <typename T, typename CharT>
struct IsStringPointer :
    public std::integral_constant<bool, IsStringByteSequence<T, CharT>::value && std::is_pointer<T>::value> {};
 
template <typename T, typename CharT>
struct IsStringLiteral :
    public std::integral_constant<bool, IsStringByteSequence<T, CharT>::value && std::is_array<T>::value> {};
 
class ASPOSECPP_SHARED_CLASS String
{
    static const uintptr_t state_literal = 0;
    static const uintptr_t state_null = 1;
 
    friend class System::Text::StringBuilder;
    friend class System::Globalization::CompareInfo;
    friend class System::Globalization::TextElementEnumerator;
    friend class System::Text::RegularExpressions::Regex; // Uses private method Append for efficient string construction.
    friend class System::Text::RegularExpressions::Detail::Formatter; // Uses private method Append for efficient string construction.
    friend class System::Globalization::TextInfo;
    friend class System::Object;
 
    using ThisType = String;
 
    RTTI_INFO_VALUE_TYPE(System::String);
public:
    using reverse_iterator = std::reverse_iterator<const char16_t*>;
 
    ASPOSECPP_VALUE_TYPE_IMPLEMENTS_INTERFACES();
 
    ASPOSECPP_SHARED_API String();
 
    template<typename T>
    String(T& value, typename std::enable_if<IsStringLiteral<T, char16_t>::value>::type* = nullptr)
        : String(value, std::extent<T>::value - 1, state_literal)
    {}
 
    template<typename T>
    String(const T& value, typename std::enable_if<IsStringPointer<T, char16_t>::value>::type* = nullptr)
        : String(value, -1)
    {
        m_state = state_literal;
    }
 
    template<typename T>
    explicit String(T& value, typename std::enable_if<IsStringLiteral<T, char>::value>::type* = nullptr)
        : String(value, std::extent<T>::value - 1)
    {
        m_state = state_literal;
    }
 
    template<typename T>
    explicit String(const T& value, typename std::enable_if<IsStringPointer<T, char>::value>::type* = nullptr)
        : String(value, -1)
    {
        m_state = state_literal;
    }
    
    ASPOSECPP_SHARED_API String(const char16_t* str, int length);
 
    ASPOSECPP_SHARED_API String(const ReadOnlySpan<char16_t>& value);
 
    ASPOSECPP_SHARED_API String(const char* str, int length);
 
    ASPOSECPP_SHARED_API String(const char16_t* str, int start, int length);
 
    ASPOSECPP_SHARED_API explicit String(const char16_t ch, int count);
 
    template<typename T>
    String(const T& value,
            typename std::enable_if<std::is_same<T, std::nullptr_t>::value>::type* = nullptr)
        : String()
    {
        ASPOSE_UNUSED(value);
    }
 
    template<typename T>
    explicit String(T& value, typename std::enable_if<IsStringLiteral<T, wchar_t>::value>::type* = nullptr)
            : String(value, std::extent<T>::value - 1)
    {}
 
    template<typename T>
    explicit String(const T& value, typename std::enable_if<IsStringPointer<T, wchar_t>::value>::type* = nullptr)
        : String(value, -1)
    {}
 
    ASPOSECPP_SHARED_API explicit String(const wchar_t* str, int length);
    ASPOSECPP_SHARED_API explicit String(const wchar_t ch, int count = 1);
 
    ASPOSECPP_SHARED_API String(const String& str);
    ASPOSECPP_SHARED_API String(String&& str) noexcept;
 
    ASPOSECPP_SHARED_API String(const ArrayPtr<char16_t>& arr);
    ASPOSECPP_SHARED_API String(const ArrayPtr<char16_t>& arr, int offset, int len);
 
    ASPOSECPP_SHARED_API ~String();
 
    ASPOSECPP_SHARED_API const UChar* u_str() const;
 
    ASPOSECPP_SHARED_API const UChar* begin() const;
    ASPOSECPP_SHARED_API const UChar* end() const;
 
    ASPOSECPP_SHARED_API reverse_iterator rbegin() const;
    ASPOSECPP_SHARED_API reverse_iterator rend() const;
 
    ASPOSECPP_SHARED_API bool IsNullOrEmpty() const;
 
    inline bool IsNull() const { return m_state == state_null; }
 
    ASPOSECPP_SHARED_API bool IsEmpty() const;
 
    ASPOSECPP_SHARED_API std::string ToUtf8String() const;
    ASPOSECPP_SHARED_API std::wstring ToWCS() const;
    ASPOSECPP_SHARED_API std::u16string ToU16Str() const;
    ASPOSECPP_SHARED_API std::u32string ToU32Str() const;
    ASPOSECPP_SHARED_API std::string ToAsciiString() const;
 
    ASPOSECPP_SHARED_API String& reset();
 
    ASPOSECPP_SHARED_API int get_Length() const;
    ASPOSECPP_SHARED_API char_t operator[](int index) const;
    ASPOSECPP_SHARED_API String& SetCharAt(int index, char_t ch);
 
    ASPOSECPP_SHARED_API String& operator=(const String& str);
    ASPOSECPP_SHARED_API String& operator=(String&& str) noexcept;
 
    ASPOSECPP_SHARED_API String operator+(const String& str) const;
    template <typename T, std::enable_if_t<IsStringLiteral<T, char_t>::value>* = nullptr>
    String operator+(const T& arg) const
    {
        return *this + String(arg, std::extent<T>::value - 1);
    }
 
    ASPOSECPP_SHARED_API String operator+(char_t x) const;
    ASPOSECPP_SHARED_API String operator+(int i) const;
    ASPOSECPP_SHARED_API String operator+(uint32_t i) const;
    ASPOSECPP_SHARED_API String operator+(double d) const;
    ASPOSECPP_SHARED_API String operator+(int64_t v) const;
    template <typename T, std::enable_if_t<IsSmartPtr<T>::value>* = nullptr>
    String operator+(const T& value) const
    {
        return value == nullptr ? *this : *this + value->ToString();
    }
    template <typename T, std::enable_if_t<!IsSmartPtr<T>::value && !std::is_scalar<T>::value && !std::is_array<T>::value>* = nullptr>
    String operator+(const T& value) const
    {
        return *this + value.ToString();
    }
    template <typename T, std::enable_if_t<std::is_same<T, bool>::value>* = nullptr>
    String operator+(T arg) const
    {
        return String(*this).AddBoolImpl(arg);
    }
 
    ASPOSECPP_SHARED_API String& operator+=(char_t c);
    ASPOSECPP_SHARED_API String& operator+=(const String& str);
    ASPOSECPP_SHARED_API String& operator+=(double value);
    ASPOSECPP_SHARED_API String& operator+=(uint8_t value);
    ASPOSECPP_SHARED_API String& operator+=(int16_t value);
    ASPOSECPP_SHARED_API String& operator+=(uint16_t value);
    ASPOSECPP_SHARED_API String& operator+=(int32_t value);
    ASPOSECPP_SHARED_API String& operator+=(uint32_t value);
    ASPOSECPP_SHARED_API String& operator+=(int64_t value);
    ASPOSECPP_SHARED_API String& operator+=(uint64_t value);
    template <typename T, std::enable_if_t<std::is_same<T, bool>::value>* = nullptr>
    String& operator+=(T value)
    {
        return AddBoolImpl(value);
    }
 
    ASPOSECPP_SHARED_API bool operator==(const String& str) const;
    ASPOSECPP_SHARED_API bool operator==(std::nullptr_t) const;
 
 
    ASPOSECPP_SHARED_API bool operator!=(const String& str) const;
    ASPOSECPP_SHARED_API bool operator!=(std::nullptr_t) const;
 
    ASPOSECPP_SHARED_API bool operator<(const String& str) const;
 
    ASPOSECPP_SHARED_API bool operator>(const String& str) const;
 
    explicit operator std::string() const
    {
        return ToUtf8String();
    }
    explicit operator std::wstring() const
    {
        return ToWCS();
    }
    explicit operator std::u16string() const
    {
        return ToU16Str();
    }
    explicit operator std::u32string() const
    {
        return ToU32Str();
    }
 
    ASPOSECPP_SHARED_API String Clone() const;
 
    String ToString() const { return *this; }
    String ToString(const SharedPtr<IFormatProvider>&) const { return *this; }
 
    ASPOSECPP_SHARED_API int GetHashCode() const;
    ASPOSECPP_SHARED_API bool Equals(const String& str, System::StringComparison comparison_type) const;
    ASPOSECPP_SHARED_API bool Equals(const String& str) const;
 
    ASPOSECPP_SHARED_API bool Contains(const String& str) const;
    ASPOSECPP_SHARED_API bool Contains(char16_t value) const;
    ASPOSECPP_SHARED_API int CompareTo(const String& str) const;
    ASPOSECPP_SHARED_API void CopyTo(int sourceIndex, const ArrayPtr<char_t>& destination, int destinationIndex, int count) const;
    ASPOSECPP_SHARED_API String Normalize(System::Text::NormalizationForm form) const;
    ASPOSECPP_SHARED_API bool IsNormalized(System::Text::NormalizationForm form) const;
 
    ASPOSECPP_SHARED_API bool StartsWith(const String& value) const;
    ASPOSECPP_SHARED_API bool StartsWith(const String& value, System::StringComparison comparisonType) const;
    ASPOSECPP_SHARED_API bool StartsWith(const String& value, bool ignoreCase, const SharedPtr<System::Globalization::CultureInfo>& culture = nullptr) const;
 
    ASPOSECPP_SHARED_API bool EndsWith(const String& value) const;
    ASPOSECPP_SHARED_API bool EndsWith(const String& value, System::StringComparison comparisonType) const;
    ASPOSECPP_SHARED_API bool EndsWith(const String& value, bool ignoreCase, const SharedPtr<System::Globalization::CultureInfo>& culture = nullptr) const;
 
    ASPOSECPP_SHARED_API ArrayPtr<char_t> ToCharArray(int32_t startIndex = 0, int32_t length = INT32_MAX) const;
    ASPOSECPP_SHARED_API ArrayPtr<uint8_t> ToByteArray(int32_t startIndex = 0, int32_t length = INT32_MAX, bool LE = true) const;
 
    ASPOSECPP_SHARED_API operator ReadOnlySpan<char16_t>() const;
 
    ASPOSECPP_SHARED_API String ToUpper() const;
    ASPOSECPP_SHARED_API String ToLower() const;
 
    ASPOSECPP_SHARED_API String ToLower(const SharedPtr<System::Globalization::CultureInfo>& cultureInfo) const;
    ASPOSECPP_SHARED_API String ToUpper(const SharedPtr<System::Globalization::CultureInfo>& cultureInfo) const;
 
    ASPOSECPP_SHARED_API String ToUpperInvariant() const;
    ASPOSECPP_SHARED_API String ToLowerInvariant() const;
 
    ASPOSECPP_SHARED_API String Substring(int32_t startIndex) const;
    ASPOSECPP_SHARED_API String Substring(int32_t startIndex, int32_t length) const;
    ASPOSECPP_SHARED_API String Remove(int32_t startIndex, int32_t count = INT32_MAX) const;
 
    bool Is(const System::TypeInfo &target) const
    {
        return GetType() == target;
    }
 
    // Finds
 
    ASPOSECPP_SHARED_API int IndexOf(const String& str, System::StringComparison comparison_type) const;
    ASPOSECPP_SHARED_API int IndexOf(char_t c, int startIndex = 0) const;
    ASPOSECPP_SHARED_API int IndexOf(char_t c, int startIndex, int count) const;
    ASPOSECPP_SHARED_API int IndexOf(const String& str, int startIndex = 0) const;
    ASPOSECPP_SHARED_API int IndexOf(const String& str, int startIndex, System::StringComparison comparison_type) const;
    ASPOSECPP_SHARED_API int IndexOf(const String& value, int startIndex, int count, System::StringComparison comparisonType) const;
    ASPOSECPP_SHARED_API int IndexOf(const String& str, int startIndex, int count) const;
 
    ASPOSECPP_SHARED_API int IndexOfAny(char_t c, int startIndex = 0) const;
    ASPOSECPP_SHARED_API int IndexOfAny(const String& str, int startIndex = 0) const;
    ASPOSECPP_SHARED_API int IndexOfAny(const ArrayPtr<char_t>& anyOf) const;
    ASPOSECPP_SHARED_API int IndexOfAny(const ArrayPtr<char_t>& anyOf, int32_t startindex) const;
    ASPOSECPP_SHARED_API int IndexOfAny(const ArrayPtr<char_t>& anyOf, int32_t startindex, int32_t count) const;
                
    ASPOSECPP_SHARED_API int LastIndexOf(const String& str, int startIndex = INT32_MAX) const;
    ASPOSECPP_SHARED_API int LastIndexOf(const String& str, System::StringComparison comparison_type) const;
    ASPOSECPP_SHARED_API int LastIndexOf(const String& str, int startIndex, System::StringComparison comparison_type) const;
    ASPOSECPP_SHARED_API int LastIndexOf(const String& value, int startIndex, int count, StringComparison comparisonType) const;
 
    ASPOSECPP_SHARED_API int LastIndexOf(char_t value) const;
    ASPOSECPP_SHARED_API int LastIndexOf(char_t value, int32_t startIndex) const;
    ASPOSECPP_SHARED_API int LastIndexOf(char_t value, int32_t startIndex, int32_t count) const;
 
    ASPOSECPP_SHARED_API int LastIndexOfAny(const ArrayPtr<char_t>& anyOf) const;
    ASPOSECPP_SHARED_API int LastIndexOfAny(const ArrayPtr<char_t>& anyOf, int32_t startindex) const;
    ASPOSECPP_SHARED_API int LastIndexOfAny(const ArrayPtr<char_t>& anyOf, int32_t startindex, int32_t count) const;
 
    // Trim
 
    ASPOSECPP_SHARED_API String Trim() const;
    ASPOSECPP_SHARED_API String Trim(char_t ch) const;
    ASPOSECPP_SHARED_API String Trim(const String& anyOf) const;
    ASPOSECPP_SHARED_API String Trim(const ArrayPtr<char_t>& anyOf) const;
 
    ASPOSECPP_SHARED_API String TrimStart() const;
    ASPOSECPP_SHARED_API String TrimStart(char_t ch) const;
    ASPOSECPP_SHARED_API String TrimStart(const String& anyOf) const;
    ASPOSECPP_SHARED_API String TrimStart(const ArrayPtr<char_t>& anyOf) const;
 
    ASPOSECPP_SHARED_API String TrimEnd() const;
    ASPOSECPP_SHARED_API String TrimEnd(char_t ch) const;
    ASPOSECPP_SHARED_API String TrimEnd(const String& anyOf) const;
    ASPOSECPP_SHARED_API String TrimEnd(const ArrayPtr<char_t>& anyOf) const;
 
    ASPOSECPP_SHARED_API String PadLeft(int totalWidth, char_t c = u' ') const;
    ASPOSECPP_SHARED_API String PadRight(int totalWidth, char_t c = u' ') const;
 
    // Replace
 
    ASPOSECPP_SHARED_API String Replace(char_t oldValue, char_t newValue) const;
    ASPOSECPP_SHARED_API String Replace(const String& oldValue, const String& newValue) const;
 
    // Insert
 
    ASPOSECPP_SHARED_API String Insert(int startIndex, const String& value) const;
 
    // Split
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(char_t separator = u' ', StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(char_t separator, int32_t count, StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(char_t separatorA, char_t separatorB, StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const ArrayPtr<char_t>& separators, StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const ArrayPtr<char_t>& separators, int32_t count, StringSplitOptions opt = StringSplitOptions::None) const;
 
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& separator, StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const String& separator, int count, StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const ArrayPtr<String>& separators, StringSplitOptions opt = StringSplitOptions::None) const;
    ASPOSECPP_SHARED_API ArrayPtr<String> Split(const ArrayPtr<String>& separators, int count, StringSplitOptions opt = StringSplitOptions::None) const;
 
    // static members
 
    static const ASPOSECPP_SHARED_API String Empty;
    static const ASPOSECPP_SHARED_API String Null;
 
    static ASPOSECPP_SHARED_API bool IsNullOrEmpty(const String& str);
    static ASPOSECPP_SHARED_API bool IsNullOrWhiteSpace(const String& str);
    static ASPOSECPP_SHARED_API bool Equals(const String& strA, const String& strB);
    static ASPOSECPP_SHARED_API bool Equals(const String& strA, const String& strB, System::StringComparison comparison_type);
 
    static ASPOSECPP_SHARED_API int Compare(const String& strA, int indexA, const String& strB, int indexB,
                                            int length, bool ignoreCase = false);
 
    static ASPOSECPP_SHARED_API int Compare(const String& strA, int indexA, const String& strB, int indexB,
                                            int length, bool ignoreCase,
                                            const SharedPtr<System::Globalization::CultureInfo>& ci);
 
    static ASPOSECPP_SHARED_API int Compare(const String& strA, const String& strB, System::StringComparison comparison_type);
    static ASPOSECPP_SHARED_API int Compare(const String& strA, int indexA, const String& strB, int indexB,
                                            int length, System::StringComparison comparison_type);
 
    static ASPOSECPP_SHARED_API int Compare(const String& strA, const String& strB, bool ignoreCase = false);
    static ASPOSECPP_SHARED_API int Compare(const String& strA, const String& strB, bool ignoreCase,
                                            const SharedPtr<System::Globalization::CultureInfo>& ci);
 
    static ASPOSECPP_SHARED_API int CompareOrdinal(const String& strA, const String& strB);
    static ASPOSECPP_SHARED_API int CompareOrdinal(const String& strA, int indexA, const String& strB, int indexB, int length);
 
    static ASPOSECPP_SHARED_API String Join(const String& separator, const ArrayPtr<String>& parts, int startIndex = 0, int count = -1);
 
    static ASPOSECPP_SHARED_API String Join(const String& separator, const System::Details::ArrayView<String>& parts, int startIndex = 0, int count = -1);
 
    static ASPOSECPP_SHARED_API String Join(const String& separator, const SharedPtr<System::Collections::Generic::IEnumerable<String> >& parts);
 
    static ASPOSECPP_SHARED_API String Join(const String& separator, const ArrayPtr<SharedPtr<Object>>& parts);
 
    static ASPOSECPP_SHARED_API String Concat(const ArrayPtr<String>& parts);
    static ASPOSECPP_SHARED_API String Concat(const String & str0, const String & str1);
    static ASPOSECPP_SHARED_API String Concat(const String & str0, const String & str1, const String & str2);
 
    static ASPOSECPP_SHARED_API String Concat(const String& str0, const String& str1, const String& str2, const String& str3);
 
    static String Copy(const String& str) { return str; }
 
    template<class... Args>
    static String Format(const SharedPtr<IFormatProvider>& fp, const String& format, const Args&... args);
 
    template<class... Args>
    static String Format(std::nullptr_t, const String& format, const Args&... args);
 
    template<std::size_t N, class... Args>
    static String Format(std::nullptr_t, const char16_t(&format)[N], const Args&... args);
 
    template<class... Args>
    static String Format(const String& format, const Args&... args);
 
    template<class T>
    static String Format(const String& format, const System::ArrayPtr<T>& args);
 
    static ASPOSECPP_SHARED_API String FromUtf8(const char* utf8);
    static ASPOSECPP_SHARED_API String FromUtf8(const char* utf8, int len);
    static ASPOSECPP_SHARED_API String FromUtf8(const uint8_t* utf8);
    static ASPOSECPP_SHARED_API String FromUtf8(const std::string& utf8);
    static ASPOSECPP_SHARED_API String FromWCS(const std::wstring& wcs);
    static ASPOSECPP_SHARED_API String FromUtf32(const uint32_t *utf32, int32_t length);
    static ASPOSECPP_SHARED_API String FromUtf16(const std::u16string& u16str);
    static ASPOSECPP_SHARED_API String FromAscii(const char* asciiStr);
    static ASPOSECPP_SHARED_API String FromAscii(const char* asciiStr, int len);
    static ASPOSECPP_SHARED_API String FromAscii(const std::string& asciiStr);
 
    explicit ASPOSECPP_SHARED_API String(const codeporting_icu::UnicodeString& str);
    explicit ASPOSECPP_SHARED_API String(codeporting_icu::UnicodeString&& str) noexcept;
    explicit String(const std::wstring& str) : String(str.data(), ASPOSECPP_CHECKED_CAST(int, str.length())) {};
    explicit String(const std::u16string& str) : String(str.data(), ASPOSECPP_CHECKED_CAST(int, str.length())) {};
    explicit ASPOSECPP_SHARED_API String(const std::string& utf8str);
    explicit ASPOSECPP_SHARED_API String(const std::u32string& u32str);
 
    bool ASPOSECPP_SHARED_API IsAsciiString() const;
 
    int ASPOSECPP_SHARED_API FastToAscii(char buffer[], int buffer_size) const;
 
protected:
    ASPOSECPP_SHARED_API String& Append(const char16_t *src,
        int32_t startIndex,
        int32_t count);
 
    mutable Detail::UnicodeStringHolder m_str; // mutable because of u_str
 
    uintptr_t m_state;
 
#if defined(_DEBUG) && (defined(_MSC_VER) || defined(__GNUC__))
        union IcuDebugHelper
        {
            struct
            {
                int16_t fLengthAndFlags;
                char16_t fBuffer[(int32_t)(64 - sizeof(void *) - 2) / 2];
            } fStackFields;
            struct
            {
                int16_t fLengthAndFlags;
                int32_t fLength;
                int32_t fCapacity;
                char16_t *fArray;
            } fFields;
        } static icuDebugHelper;
#endif
 
private:
    static bool StartsWithImpl(const String& that, const String& other, System::StringComparison comparisonType,
                               const SharedPtr<Globalization::CultureInfo>& culture);
 
    static bool EndsWithImpl(const String& that, const String& other, System::StringComparison comparisonType,
                             const SharedPtr<Globalization::CultureInfo>& culture);
 
    static int32_t CompareImpl(const String& strA, int32_t indexA, const String& strB, int32_t indexB,
                               int32_t length, StringComparison comparisonType,
                               const SharedPtr<Globalization::CultureInfo>& culture);
 
    static int LastIndexOfOrdinalIgnoreCaseImpl(const String& source, const String& value, int startIndex, int count);
    static int IndexOfOrdinalIgnoreCaseImpl(const String& source, const String& value, int startIndex, int count);
 
    ASPOSECPP_SHARED_API String& AddBoolImpl(bool value);
 
    static SharedPtr<Text::StringBuilder> GetBuilder();
 
    // Special ctor for literals
    ASPOSECPP_SHARED_API String(const char16_t* str, int length, uintptr_t state);
 
    inline void SetState()
    {
        m_state = reinterpret_cast<uintptr_t>(this);
    }
 
}; // class String
 
template<typename T>
typename std::enable_if<IsStringLiteral<T, char_t>::value, String>::type  inline operator+(T&  left, const String& right)
{
    return String(left, std::extent<T>::value - 1) + right;
}
 
template<typename T>
typename std::enable_if<IsStringPointer<T, char_t>::value, String>::type  inline operator+(T&  left, const String& right)
{
    return String(left) + right;
}
 
 
String inline operator+(const char_t left, const String& right)
{
    return String(left, 1) + right;
}
 
template<class Chars, typename std::enable_if<IsStringLiteral<Chars, char_t>::value>::type* = nullptr>
bool inline operator==(Chars& left, const String& right)
{
    return String(left, std::extent<Chars>::value - 1) == right;
}
 
template<class T, typename std::enable_if<IsStringPointer<T, char_t>::value>::type* = nullptr>
bool inline operator==(T& left, const String& right)
{
    return String(left) == right;
}
 
template<class Chars, typename std::enable_if<IsStringLiteral<Chars, char_t>::value>::type* = nullptr>
bool inline operator!=(Chars& left, const String& right)
{
    return !(String(left, std::extent<Chars>::value - 1) == right);
}
 
template<class T, typename std::enable_if<IsStringPointer<T, char_t>::value>::type* = nullptr>
bool inline operator!=(T& left, const String& right)
{
    return !(String(left) == right);
}
 
ASPOSECPP_SHARED_API bool operator==(const SharedPtr<Object>& left, const String& right);
ASPOSECPP_SHARED_API bool operator!=(const SharedPtr<Object>& left, const String& right);
 
ASPOSECPP_SHARED_API bool operator==(std::nullptr_t, const String& str);
ASPOSECPP_SHARED_API bool operator!=(std::nullptr_t, const String& str);
 
ASPOSECPP_SHARED_API std::ostream& operator<<(std::ostream& os, const String& str);
ASPOSECPP_SHARED_API std::wostream& operator<<(std::wostream& os, const String& str);
 
ASPOSECPP_SHARED_API std::istream& operator>>(std::istream &in, String &str);
ASPOSECPP_SHARED_API std::wistream& operator>>(std::wistream &in, String &str);
 
template <>
struct CastResult<String>
{
    typedef String type;
};
 
template <>
inline bool Object::ReferenceEquals(String const& str, std::nullptr_t)
{
    return str.IsNull();
}
 
template <>
inline bool Object::ReferenceEquals(String const& str1, String const& str2)
{
    return str1.m_state == str2.m_state && (str1.m_state == String::state_null || str1 == str2);
}
 
namespace BoxedValueDetail {
template<>
struct ImplementsInterface<String, IComparable<String>> : std::true_type {};
}
 
ASPOSECPP_SHARED_API void PrintTo(const System::String& value, std::ostream* os);
 
 
} // namespace System
 
// boost::hash specialization for System::String
 
namespace std
{
    template <>
    struct hash<System::String>
    {
        std::size_t operator()(const System::String& str) const
        {
            return static_cast<std::size_t>(str.GetHashCode());
        }
    };
}
 
typedef char16_t* system_char_array;
typedef char16_t const* const_system_char_array;
 
#include <system/details/format_builder.h>
 
namespace System {
 
template<class... Args>
String String::Format(const SharedPtr<IFormatProvider>& fp, const String& format, const Args&... args)
{
    System::Details::FormatBuilder builder(format, fp);
    System::Details::FormatBuilder::AddArguments(builder, args...);
 
    return builder.BuildResult();
}
 
template<class... Args>
String String::Format(std::nullptr_t, const String& format, const Args&... args)
{
    System::Details::FormatBuilder builder(format);
    System::Details::FormatBuilder::AddArguments(builder, args...);
 
    return builder.BuildResult();
}
 
template<std::size_t N, class... Args>
String String::Format(std::nullptr_t, const char16_t (&format)[N], const Args&... args)
{
    System::Details::FormatBuilder builder(format);
    System::Details::FormatBuilder::AddArguments(builder, args...);
 
    return builder.BuildResult();
}
 
 
template<class... Args>
String String::Format(const String& format, const Args&... args)
{
    System::Details::FormatBuilder builder(format);
    System::Details::FormatBuilder::AddArguments(builder, args...);
 
    return builder.BuildResult();
}
 
template<class T>
String String::Format(const String& format, const System::ArrayPtr<T>& args)
{
    System::Details::FormatBuilder builder(format);
    System::Details::FormatBuilder::AddArguments(builder, args);
 
    return builder.BuildResult();
}
} // namespace System
 
#endif // _aspose_system_string_h_