csharp-to-cpp/apireference/string_8h_source.html

#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 { ThrowIfNull(); return *this; }

    String ToString(const SharedPtr<IFormatProvider>&) const { ThrowIfNull(); 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() 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);


    ASPOSECPP_SHARED_API void ThrowIfNull() const;


    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_

System::Collections::Generic::IEnumerable< String >

System::Globalization::CompareInfo
Makes culture-sensitive string comparison. Objects of this class should only be allocated using Syste...
Definition: compare_info.h:24

System::Globalization::TextElementEnumerator
Enumerator to iterate through string elements (characters). Objects of this class should only be allo...
Definition: text_element_enumerator.h:28

System::Globalization::TextInfo
Defines locale-specific text properties. Setter operations are only enabled on non-read-only objects....
Definition: text_info.h:23

System::IComparable
Defines a method that compares two objects. Objects of this class should only be allocated using Syst...
Definition: icomparable.h:17

System::Object
Base class that enables using methods available for System.Object class in C#. All non-trivial classe...
Definition: object.h:51

System::Object::GetType
virtual const TypeInfo & GetType() const
Gets actual type of object. Analog of C# System.Object.GetType() call.

System::Object::ReferenceEquals
static bool ReferenceEquals(ptr const &objA, ptr const &objB)
Compares objects by reference.
Definition: object.h:104

System::ReadOnlySpan
Forward to use within Span class.
Definition: span.h:415

System::SmartPtr
Pointer class to wrap types being allocated on heap. Use it to manage memory for classes inheriting O...
Definition: smart_ptr.h:180

System::String
String class used across the library. Is a substitute for C# System.String when translating code....
Definition: string.h:125

System::String::operator+=
String & operator+=(uint8_t value)
Concatenation assignment operator.

System::String::String
String(const char *str, int length)
Constructs string from character string pointer and explicit length.

System::String::operator[]
char_t operator[](int index) const
Gets character at specified position.

System::String::String
String(const std::wstring &str)
Creates String from widestring.
Definition: string.h:1160

System::String::ToCharArray
ArrayPtr< char_t > ToCharArray(int32_t startIndex=0, int32_t length=INT32_MAX) const
Converts string or substring to array of characters.

System::String::IndexOfAny
int IndexOfAny(const ArrayPtr< char_t > &anyOf) const
Looks for any of passed characters through the whole string. Compares first string character to all c...

System::String::String
String(const String &str)
Copy constructor.

System::String::FromAscii
static String FromAscii(const char *asciiStr, int len)
Creates String from ASCII string.

System::String::IndexOfAny
int IndexOfAny(char_t c, int startIndex=0) const
Character forward lookup.

System::String::PadRight
String PadRight(int totalWidth, char_t c=u' ') const
Adds padding on the right of original string.

System::String::String
String(const T &value, typename std::enable_if< IsStringPointer< T, wchar_t >::value >::type *=nullptr)
Constructs string based on widecharacter string pointer. Treats pointed string as null-terminated,...
Definition: string.h:232

System::String::EndsWith
bool EndsWith(const String &value, bool ignoreCase, const SharedPtr< System::Globalization::CultureInfo > &culture=nullptr) const
Checks if string ends with specified substring.

System::String::String
String(const T &value, typename std::enable_if< IsStringPointer< T, char >::value >::type *=nullptr)
Constructs string based on character string pointer. Treats pointed string as null-terminated in UTF8...
Definition: string.h:179

System::String::ToU16Str
std::u16string ToU16Str() const
Converts string to std::u16string.

System::String::operator<
bool operator<(const String &str) const
Order-compares strings.

System::String::Split
ArrayPtr< String > Split(char_t separatorA, char_t separatorB, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by one of two characters.

System::String::Substring
String Substring(int32_t startIndex, int32_t length) const
Extracts substring.

System::String::IndexOf
int IndexOf(const String &str, int startIndex=0) const
Substring forward lookup.

System::String::TrimEnd
String TrimEnd(const String &anyOf) const
Removes all occurrences of passed characters from end of the string.

System::String::operator+=
String & operator+=(int32_t value)
Concatenation assignment operator.

System::String::operator=
String & operator=(const String &str)
Assignment operator.

System::String::FromUtf8
static String FromUtf8(const std::string &utf8)
Creates String from utf8 string.

System::String::IndexOfAny
int IndexOfAny(const String &str, int startIndex=0) const
Consequently looks for all characters of str in this. If first character is found,...

System::String::ToLower
String ToLower() const
Converts all string's characters to lower case.

System::String::IsNormalized
bool IsNormalized(System::Text::NormalizationForm form) const
Checks if unicode string is normalized using normalization form specified.

System::String::Remove
String Remove(int32_t startIndex, int32_t count=INT32_MAX) const
Extracts everything but substring from current string.

System::String::String
String(const std::u32string &u32str)
Creates String from std::u32string string.

System::String::TrimStart
String TrimStart(const String &anyOf) const
Removes all occurrences of passed characters from beginning of the string.

System::String::reset
String & reset()
Sets string to null. Is analogous to 'string_variable_name = null' in C#.

System::String::Append
String & Append(const char16_t *src, int32_t startIndex, int32_t count)
Puts some characters into string. Changes string size.

System::String::Normalize
String Normalize() const
Normalizes unicode string using normalization form Unicode C.

System::String::operator+=
String & operator+=(T value)
Concatenation assignment operator.
Definition: string.h:447

System::String::m_state
uintptr_t m_state
String state. Contains value 0 if string is null, 1 if string is constructed from string literal.
Definition: string.h:1196

System::String::operator+=
String & operator+=(const String &str)
Concatenation assignment operator.

System::String::Trim
String Trim(const String &anyOf) const
Removes all occurrences of passed characters from both beginning and end of the string.

System::String::~String
~String()
Destructor.

System::String::Equals
bool Equals(const String &str) const
String equality comparison. Uses System::StringComparison::Ordinal comparison mode.

System::String::operator>
bool operator>(const String &str) const
Order-compares strings.

System::String::TrimStart
String TrimStart() const
Removes all whitespace characters from beginning of the string.

System::String::operator+=
String & operator+=(char_t c)
Concatenation assignment operator.

System::String::EndsWith
bool EndsWith(const String &value) const
Checks if string ends with specified substring.

System::String::LastIndexOf
int LastIndexOf(const String &str, System::StringComparison comparison_type) const
Substring backward lookup.

System::String::Clone
String Clone() const
Creates a copy of current string.

System::String::get_Length
int get_Length() const
Gets string length.

System::String::Compare
static int Compare(const String &strA, int indexA, const String &strB, int indexB, int length, bool ignoreCase, const SharedPtr< System::Globalization::CultureInfo > &ci)
Less-equal-greater-compares two substrings.

System::String::operator==
bool operator==(const String &str) const
Equality comparison operator.

System::String::operator+=
String & operator+=(int64_t value)
Concatenation assignment operator.

System::String::IndexOf
int IndexOf(const String &str, System::StringComparison comparison_type) const
Substring forward lookup.

System::String::GetHashCode
int GetHashCode() const
Hashes contained string. Implemented in ICU, doesn't match hashes in C#.

System::String::rbegin
reverse_iterator rbegin() const
Returns reverse iterator to the last character (if any) of actual string buffer.

System::String::ToLower
String ToLower(const SharedPtr< System::Globalization::CultureInfo > &cultureInfo) const
Converts all string's characters to lower case using specific culture.

System::String::Trim
String Trim(char_t ch) const
Removes all occurrences of passed character from both beginning and end of the string.

System::String::String
String(codeporting_icu::UnicodeString &&str) noexcept
Move constructor.

System::String::String
String(const std::u16string &str)
Creates String from utf16 string.
Definition: string.h:1163

System::String::Join
static String Join(const String &separator, const SharedPtr< System::Collections::Generic::IEnumerable< String > > &parts)
Joins array using string as separator.

System::String::LastIndexOf
int LastIndexOf(char_t value, int32_t startIndex, int32_t count) const
Character backward lookup.

System::String::FromAscii
static String FromAscii(const std::string &asciiStr)
Creates String from ASCII string.

System::String::Contains
bool Contains(char16_t value) const
Checks if string contains given character.

System::String::operator=
String & operator=(String &&str) noexcept
Move assignment operator.

System::String::Format
static String Format(const SharedPtr< IFormatProvider > &fp, const String &format, const Args &... args)
Formats string in C# style.
Definition: string.h:1445

System::String::LastIndexOfAny
int LastIndexOfAny(const ArrayPtr< char_t > &anyOf) const
Looks for any of passed characters through whole string backwardly. Compares last string character to...

System::String::m_str
Detail::UnicodeStringHolder m_str
Actual string value.
Definition: string.h:1191

System::String::FromUtf16
static String FromUtf16(const std::u16string &u16str)
Creates String from utf16 string.

System::String::LastIndexOf
int LastIndexOf(const String &str, int startIndex, System::StringComparison comparison_type) const
Substring backward lookup.

System::String::operator+
String operator+(const T &value) const
Adds reference type object string representation to the end of the string.
Definition: string.h:379

System::String::Is
bool Is(const System::TypeInfo &target) const
Checks if string object is of type specified by TypeInfo passed.
Definition: string.h:647

System::String::String
String(String &&str) noexcept
Move constructor.

System::String::ToLowerInvariant
String ToLowerInvariant() const
Converts all string's characters to lower case using invariant culture.

System::String::StartsWith
bool StartsWith(const String &value) const
Checks if string begins with specified substring.

System::String::rend
reverse_iterator rend() const
Returns reverse iterator to the before first character (if any) of actual string buffer.

System::String::String
String(const wchar_t *str, int length)
Constructs string from widecharacter string pointer and explicit length. Conversion from wchar_t is t...

System::String::IndexOf
int IndexOf(const String &str, int startIndex, int count) const
Substring forward lookup.

System::String::Join
static String Join(const String &separator, const ArrayPtr< String > &parts, int startIndex=0, int count=-1)
Joins array using string as separator.

System::String::Equals
static bool Equals(const String &strA, const String &strB)
Equal-compares two strings using Ordial comparison mode.

System::String::LastIndexOfAny
int LastIndexOfAny(const ArrayPtr< char_t > &anyOf, int32_t startindex, int32_t count) const
Looks for any of passed characters through substring backwardly. Compares last string character to al...

System::String::operator+=
String & operator+=(uint32_t value)
Concatenation assignment operator.

System::String::Split
ArrayPtr< String > Split(const String &separator, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by substring.

System::String::String
String(const ArrayPtr< char16_t > &arr)
Converts whole character array to string.

System::String::Empty
static const String Empty
Empty string.
Definition: string.h:921

System::String::operator+=
String & operator+=(int16_t value)
Concatenation assignment operator.

System::String::String
String(const ReadOnlySpan< char16_t > &value)
Initializes a new instance of the System.String class to the Unicode characters indicated in the spec...

System::String::Split
ArrayPtr< String > Split(const String &separator, int count, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by substring.

System::String::String
String(const T &value, typename std::enable_if< std::is_same< T, std::nullptr_t >::value >::type *=nullptr)
Nullptr constructor. Declared as template to resolve priorities with other template constructors.
Definition: string.h:215

System::String::FromUtf8
static String FromUtf8(const uint8_t *utf8)
Creates String from utf8 string.

System::String::ToUpperInvariant
String ToUpperInvariant() const
Converts all string's characters to upper case using invariant culture.

System::String::Copy
static String Copy(const String &str)
Creates string copy.
Definition: string.h:1070

System::String::ASPOSECPP_VALUE_TYPE_IMPLEMENTS_INTERFACES
ASPOSECPP_VALUE_TYPE_IMPLEMENTS_INTERFACES()
String is value type on C++ side which implicitly (without inheritance) implements some interfaces.

System::String::Null
static const String Null
Null string.
Definition: string.h:923

System::String::String
String(const char16_t *str, int length)
Constructs string from character string pointer and explicit length.

System::String::operator==
bool operator==(std::nullptr_t) const
Checks if string is null. Applies same logic as IsNull() call.

System::String::operator+
String operator+(uint32_t i) const
Adds unsigned integer value string representation to the end of the string.

System::String::Equals
static bool Equals(const String &strA, const String &strB, System::StringComparison comparison_type)
Equal-compares two strings.

System::String::String
String(const wchar_t ch, int count=1)
Fill constructor. Conversion from wchar_t is time-consuming on some platforms, so no implicit convers...

System::String::String
String(const char16_t ch, int count)
Fill constructor.

System::String::operator+=
String & operator+=(uint16_t value)
Concatenation assignment operator.

System::String::Compare
static int Compare(const String &strA, int indexA, const String &strB, int indexB, int length, bool ignoreCase=false)
Less-equal-greater-compares two substrings.

System::String::IsNullOrEmpty
static bool IsNullOrEmpty(const String &str)
Checks if passed string is null or empty.

System::String::operator!=
bool operator!=(std::nullptr_t) const
Checks if string is not null. Applies same logic as IsNull() call.

System::String::Compare
static int Compare(const String &strA, int indexA, const String &strB, int indexB, int length, System::StringComparison comparison_type)
Less-equal-greater-compares two strings.

System::String::operator+
String operator+(int i) const
Adds integer value string representation to the end of the string.

System::String::Split
ArrayPtr< String > Split(char_t separator, int32_t count, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by character.

System::String::operator+
String operator+(T arg) const
Adds boolean value string representation to the end of the string.
Definition: string.h:397

System::String::Compare
static int Compare(const String &strA, const String &strB, System::StringComparison comparison_type)
Less-equal-greater-compares two strings.

System::String::EndsWith
bool EndsWith(const String &value, System::StringComparison comparisonType) const
Checks if string ends with specified substring.

System::String::Substring
String Substring(int32_t startIndex) const
Extracts substring.

System::String::operator+
String operator+(const T &arg) const
String concatenation with string literal or character string pointer.
Definition: string.h:349

System::String::TrimEnd
String TrimEnd(char_t ch) const
Removes all occurrences of passed character from end of the string.

System::String::begin
const UChar * begin() const
Returns pointer to the beginning of actual string buffer. Never reallocates anything....

System::String::Split
ArrayPtr< String > Split(const ArrayPtr< String > &separators, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by substring.

System::String::LastIndexOf
int LastIndexOf(const String &str, int startIndex=INT32_MAX) const
Substring backward lookup.

System::String::ToWCS
std::wstring ToWCS() const
Converts string to std::wstring.

System::String::FastToAscii
int FastToAscii(char buffer[], int buffer_size) const
Tries to convert a String to an ASCII string.

System::String::IndexOf
int IndexOf(const String &value, int startIndex, int count, System::StringComparison comparisonType) const
Substring forward lookup.

System::String::TrimStart
String TrimStart(char_t ch) const
Removes all occurrences of passed character from beginning of the string.

System::String::Replace
String Replace(char_t oldValue, char_t newValue) const
Replaces all occurrences of character in the string.

System::String::ToUpper
String ToUpper(const SharedPtr< System::Globalization::CultureInfo > &cultureInfo) const
Converts all string's characters to upper case using specific culture.

System::String::String
String(const T &value, typename std::enable_if< IsStringPointer< T, char16_t >::value >::type *=nullptr)
Constructs string based on character string pointer. Treats pointed string as null-terminated,...
Definition: string.h:161

System::String::operator+
String operator+(double d) const
Adds floating point value string representation to the end of the string.

System::String::String
String(const ArrayPtr< char16_t > &arr, int offset, int len)
Converts character array subrange to string. If parameters are out of array bounds,...

System::String::ToUpper
String ToUpper() const
Converts all string's characters to upper case.

System::String::IndexOf
int IndexOf(char_t c, int startIndex, int count) const
Character forward lookup in substring.

System::String::CopyTo
void CopyTo(int sourceIndex, const ArrayPtr< char_t > &destination, int destinationIndex, int count) const
Copies string characters into existing array elements. No resize is being done.

System::String::Compare
static int Compare(const String &strA, const String &strB, bool ignoreCase=false)
Less-equal-greater-compares two strings.

System::String::LastIndexOfAny
int LastIndexOfAny(const ArrayPtr< char_t > &anyOf, int32_t startindex) const
Looks for any of passed characters through substring backwardly. Compares last string character to al...

System::String::String
String(const char16_t *str, int start, int length)
Constructs string from character string pointer from starting position using length.

System::String::CompareTo
int CompareTo(const String &str) const
Compares two strings in 'less-equals-more' style. Uses current culture.

System::String::PadLeft
String PadLeft(int totalWidth, char_t c=u' ') const
Adds padding on the left of original string.

System::String::TrimStart
String TrimStart(const ArrayPtr< char_t > &anyOf) const
Removes all occurrences of passed characters from beginning of the string.

System::String::IsAsciiString
bool IsAsciiString() const
Indicates if a String contains ASCII symbols only.

System::String::Split
ArrayPtr< String > Split(const ArrayPtr< char_t > &separators, int32_t count, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by one of characters specified.

System::String::Concat
static String Concat(const String &str0, const String &str1, const String &str2, const String &str3)
Concatenates strings.

System::String::operator+
String operator+(const String &str) const
String concatenation operator.

System::String::IsNullOrEmpty
bool IsNullOrEmpty() const
Checks if string is empty or is considered null.

System::String::Concat
static String Concat(const String &str0, const String &str1, const String &str2)
Concatenates strings.

System::String::Join
static String Join(const String &separator, const System::Details::ArrayView< String > &parts, int startIndex=0, int count=-1)
Joins array using string as separator.

System::String::operator+=
String & operator+=(double value)
Concatenation assignment operator.

System::String::CompareOrdinal
static int CompareOrdinal(const String &strA, const String &strB)
Less-equal-greater-compares two strings using ordinal mode.

System::String::String
String(const std::string &utf8str)
Creates String from std::string string presented in format UTF-8.

System::String::ToUtf8String
std::string ToUtf8String() const
Converts string to std::string. Uses UTF-8 encoding.

System::String::FromUtf8
static String FromUtf8(const char *utf8, int len)
Creates String from utf8 string.

System::String::StartsWith
bool StartsWith(const String &value, System::StringComparison comparisonType) const
Checks if string begins with specified substring.

System::String::IsNullOrWhiteSpace
static bool IsNullOrWhiteSpace(const String &str)
Indicates whether a specified string is null, empty, or consists only of white-space characters.

System::String::operator!=
bool operator!=(const String &str) const
Non-equality comparison operator.

System::String::Join
static String Join(const String &separator, const ArrayPtr< SharedPtr< Object > > &parts)
Joins array using string as separator.

System::String::operator+
String operator+(char_t x) const
Adds character to the end of the string.

System::String::TrimEnd
String TrimEnd() const
Removes all whitespace characters from end of the string.

System::String::Split
ArrayPtr< String > Split(const ArrayPtr< char_t > &separators, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by one of characters specified.

System::String::Equals
bool Equals(const String &str, System::StringComparison comparison_type) const
String equality comparison. Several modes provided by StringComparison enumeration are supported.

System::String::end
const UChar * end() const
Returns pointer to the end of actual string buffer. Never reallocates anything. Doesn't guarantee buf...

System::String::ToString
String ToString(const SharedPtr< IFormatProvider > &) const
Wrapper for handling String class in contexts where ToString() is being called on value type objects.
Definition: string.h:513

System::String::u_str
const UChar * u_str() const
Returns ICU-styled null-terminated buffer. May reallocate the string.

System::String::Split
ArrayPtr< String > Split(const ArrayPtr< String > &separators, int count, StringSplitOptions opt=StringSplitOptions::None) const
Splits string by substring. Currently, only supports separators array of zero or one elements.

System::String::Concat
static String Concat(const String &str0, const String &str1)
Concatenates strings.

System::String::ToString
String ToString() const
Wrapper for handling String class in contexts where ToString() is being called on value type objects.
Definition: string.h:510

System::String::Trim
String Trim() const
Removes all whitespace characters from both beginning and end of the string.

System::String::CompareOrdinal
static int CompareOrdinal(const String &strA, int indexA, const String &strB, int indexB, int length)
Less-equal-greater-compares two strings using ordinal mode.

System::String::operator+
String operator+(int64_t v) const
Adds integer value string representation to the end of the string.

System::String::IndexOf
int IndexOf(char_t c, int startIndex=0) const
Character forward lookup.

System::String::ToByteArray
ArrayPtr< uint8_t > ToByteArray(int32_t startIndex=0, int32_t length=INT32_MAX, bool LE=true) const
Converts string or substring to array of bytes.

System::String::ToU32Str
std::u32string ToU32Str() const
Converts string to std::u32string.

System::String::IndexOfAny
int IndexOfAny(const ArrayPtr< char_t > &anyOf, int32_t startindex) const
Looks for any of passed characters through substring. Compares first string character to all characte...

System::String::TrimEnd
String TrimEnd(const ArrayPtr< char_t > &anyOf) const
Removes all occurrences of passed characters from end of the string.

System::String::FromUtf32
static String FromUtf32(const uint32_t *utf32, int32_t length)
Creates String from utf32 string.

System::String::String
String(T &value, typename std::enable_if< IsStringLiteral< T, char >::value >::type *=nullptr)
Constructs string based on string literal. Considers literal a null-terminated string in UTF8,...
Definition: string.h:170

System::String::IndexOf
int IndexOf(const String &str, int startIndex, System::StringComparison comparison_type) const
Substring forward lookup.

System::String::FromWCS
static String FromWCS(const std::wstring &wcs)
Creates String from widestring.

System::String::IsEmpty
bool IsEmpty() const
Checks if string is both non-null and empty.

System::String::IndexOfAny
int IndexOfAny(const ArrayPtr< char_t > &anyOf, int32_t startindex, int32_t count) const
Looks for any of passed characters through substring. Compares first string character to all characte...

System::String::operator+=
String & operator+=(uint64_t value)
Concatenation assignment operator.

System::String::Insert
String Insert(int startIndex, const String &value) const
Inserts substring at specified position.

System::String::Contains
bool Contains(const String &str) const
Checks if str is a substring of current string.

System::String::FromAscii
static String FromAscii(const char *asciiStr)
Creates String from ASCII string.

System::String::SetCharAt
String & SetCharAt(int index, char_t ch)
Sets character at specified position.

System::String::LastIndexOf
int LastIndexOf(char_t value) const
Character backward lookup.

System::String::Split
ArrayPtr< String > Split(char_t separator=u' ', StringSplitOptions opt=StringSplitOptions::None) const
Splits string by character.

System::String::StartsWith
bool StartsWith(const String &value, bool ignoreCase, const SharedPtr< System::Globalization::CultureInfo > &culture=nullptr) const
Checks if string begins with specified substring.

System::String::FromUtf8
static String FromUtf8(const char *utf8)
Creates String from utf8 string.

System::String::IsNull
bool IsNull() const
Checks if string is considered null. String is null and only if it is constructed via String() constr...
Definition: string.h:291

System::String::reverse_iterator
std::reverse_iterator< const char16_t * > reverse_iterator
Reverse iterator type.
Definition: string.h:143

System::String::String
String(T &value, typename std::enable_if< IsStringLiteral< T, wchar_t >::value >::type *=nullptr)
Constructs string based on widestring literal. Considers literal a null-terminated string,...
Definition: string.h:224

System::String::Replace
String Replace(const String &oldValue, const String &newValue) const
Replaces all occurrences of lookup in this string.

System::String::String
String()
Default constructor. Creates string object which is considered null.

System::String::String
String(const codeporting_icu::UnicodeString &str)
Wraps UnicodeString into String.

System::String::Concat
static String Concat(const ArrayPtr< String > &parts)
Concatenates strings.

System::String::Normalize
String Normalize(System::Text::NormalizationForm form) const
Normalizes unicode string using normalization form specified.

System::String::Trim
String Trim(const ArrayPtr< char_t > &anyOf) const
Removes all occurrences of passed characters from both beginning and end of the string.

System::String::Compare
static int Compare(const String &strA, const String &strB, bool ignoreCase, const SharedPtr< System::Globalization::CultureInfo > &ci)
Less-equal-greater-compares two strings.

System::String::LastIndexOf
int LastIndexOf(const String &value, int startIndex, int count, StringComparison comparisonType) const
Substring backward lookup.

System::String::String
String(T &value, typename std::enable_if< IsStringLiteral< T, char16_t >::value >::type *=nullptr)
Constructs string based on string literal. Considers literal a null-terminated string,...
Definition: string.h:154

System::String::ToAsciiString
std::string ToAsciiString() const
Converts string to std::string. Uses ASCII encoding.

System::String::LastIndexOf
int LastIndexOf(char_t value, int32_t startIndex) const
Character backward lookup.

System::Text::RegularExpressions::Regex
Regular expression that follows C#-like syntax. Objects of this class should only be allocated using ...
Definition: regex.h:30

System::Text::StringBuilder
Buffer to accumulate string part by part. This type can be allocated either in stack as value type or...
Definition: string_builder.h:17

System::TypeInfo
Represents a particular type and provides information about it.
Definition: type_info.h:109

System::Drawing::Imaging::ColorAdjustType::Text
@ Text
Defines color adjustment information for text.

System::Text::NormalizationForm
NormalizationForm
Defines how to normalize Unicode string.
Definition: normalization_form.h:9

System
Definition: db_command.h:9

System::PrintTo
void PrintTo(DateTime value, std::ostream *stream)
Prints value to ostream. Mostly used for debug.

System::operator!=
bool operator!=(ArraySegment< T > a, ArraySegment< T > b)
Definition: array_segment.h:173

System::operator+
Decimal operator+(const T &x, const Decimal &d)
Returns a new instance of Decimal class that represents a value that is a sum of the specified value ...
Definition: decimal.h:542

System::operator>>
std::istream & operator>>(std::istream &in, String &str)
Gets a string from the input streamusing UTF-8 encoding.

System::StringComparison
StringComparison
Defines string comparison style.
Definition: string_comparison.h:13

System::StringSplitOptions
StringSplitOptions
Determines string splitting behavior.
Definition: string.h:57

System::StringSplitOptions::None
@ None
Keep empty strings when splitting string.

System::StringSplitOptions::RemoveEmptyEntries
@ RemoveEmptyEntries
Discard empty strings when splitting string.

System::operator<<
std::ostream & operator<<(std::ostream &stream, DateTime date_time)
Insert data into the stream using UTF-8 encoding.
Definition: date_time.h:729

System::operator==
bool operator==(ArraySegment< T > a, ArraySegment< T > b)
Definition: array_segment.h:167

System::BoxedValueDetail::ImplementsInterface
Template predicate that checks if boxed object should implement given interface by itself.
Definition: boxable_traits.h:33

System::CastResult
Template magic to deduce cast results.
Definition: object.h:374

System::CastResult::type
SmartPtr< TTo > type
An alias for a pointer to an instance of TTo.
Definition: object.h:376

System::IsStringByteSequence
Template magic to check if a type is a sequence of string characters.
Definition: string.h:71

System::IsStringLiteral
Template magic to check if a type is a string literal.
Definition: string.h:85

System::IsStringPointer
Template magic to check if a type is a pointer to character string.
Definition: string.h:78