String.cpp

Go to the documentation of this file.

#include "pch.h"
#include "System/String.h"
#include "System/Array.h"
#include "System/Utils/StringConvert.h"
#include "System/ArgumentException.h"
#include "System/ArgumentOutOfRangeException.h"
#include "System/NotImplementedException.h"
#include "System/OverflowException.h"
#include "System/FormatException.h"
#include <set>
#include <vector>
#include <initializer_list>
#include <sstream>
#include <type_traits>
#include <algorithm>
#include <iostream>
#include <string>
 
 
namespace DotNetDupe {
    namespace System {
 
        struct String::StringImpl {
            std::string s;
            StringImpl() = default;
            StringImpl(const char* str) : s(str) {}
            StringImpl(const std::string& str) : s(str) {}
            StringImpl(std::string&& str) : s(std::move(str)) {}
 
        };
 
 
        namespace {
            template <typename T>
            inline String ToStringHelper(const T& val) {
                using DecayedT = std::decay_t<T>;
                if constexpr (std::is_same_v<DecayedT, String>) {
                    return val;
                }
                else if constexpr (std::is_same_v<DecayedT, std::string>) {
                    return String(val.c_str());
                }
                else if constexpr (std::is_same_v<DecayedT, std::nullptr_t>) {
                    return String("");
                }
                else if constexpr (std::is_same_v<DecayedT, bool>) {
                    return val ? "True" : "False";
                }
                else {
                    std::ostringstream ss;
                    ss << val;
                    return String(ss.str().c_str());
                }
            }
        }
 
        void ThrowArgumentException(const char* msg) {
            throw ArgumentException(msg);
        }
 
        void ThrowFormatException(const char* msg) {
            throw FormatException(msg);
        }
        String::String() { m_pImpl = new StringImpl("");  }
        String::~String() { delete m_pImpl; }
 
        static void AppendExplicitArg(const std::string& sFmt, size_t i, size_t end, const String* pArgs, int iArgCount, std::string& sRes) {
            std::string num = sFmt.substr(i + 1, end - i - 1);
            size_t idx = 0;
            int argIdx = std::stoi(num, &idx);
            if (idx != num.length() || argIdx < 0 || argIdx >= iArgCount) throw FormatException("Index out of bounds");

            sRes += pArgs[argIdx].GetRawString() ? pArgs[argIdx].GetRawString() : "";
        }
 
        static void FormatOpenBrace(const std::string& sFmt, size_t& i, int& iAutoIndex, const String* pArgs, int iArgCount, std::string& sRes) {
            if (i + 1 < sFmt.length() && sFmt[i+1] == '{') {
                sRes += '{'; i++;
            } else if (i + 1 < sFmt.length() && sFmt[i+1] == '}') {
                if (iAutoIndex >= iArgCount) throw FormatException("Index out of bounds");
                sRes += pArgs[iAutoIndex].GetRawString() ? pArgs[iAutoIndex].GetRawString() : "";
                iAutoIndex++; i++;
            } else {
                size_t end = sFmt.find('}', i + 1);
                if (end == std::string::npos) throw FormatException("Unclosed brace");
                AppendExplicitArg(sFmt, i, end, pArgs, iArgCount, sRes);
                i = end;
            }
        }
 
        static void FormatClosingBrace(const std::string& sFmt, size_t& i, std::string& sRes) {
            if (i + 1 < sFmt.length() && sFmt[i+1] == '}') {
                sRes += '}'; i++;
            } else {
                throw FormatException("Unescaped closing brace");
            }
        }
 
        String String::InternalFormat(const char* pFormat, const String* pArgs, int iArgCount) {
            if (!pFormat) throw ArgumentException("Format string cannot be null.");
            if (iArgCount == 0 || !pArgs) return String(pFormat);

            std::string sFmt = pFormat;
            std::string sRes;
            int iAutoIndex = 0;
            for (size_t i = 0; i < sFmt.length(); ++i) {
                if (sFmt[i] == '{') {
                    FormatOpenBrace(sFmt, i, iAutoIndex, pArgs, iArgCount, sRes);
                } else if (sFmt[i] == '}') {
                    FormatClosingBrace(sFmt, i, sRes);
                } else {
                    sRes += sFmt[i];
                }
            }

            return String(sRes.c_str());
        }
 
        void* String::operator new(size_t size) {
            return ::operator new(size);
        }
 
        void String::operator delete(void* p) {
            ::operator delete(p);
        }
 
        void* String::operator new[](size_t size) {
            return ::operator new[](size);
        }
 
        void String::operator delete[](void* p) {
            ::operator delete[](p);
        }
 
        String String::operator+(const char* pStr) const {
            String sNewStr = *this;
            if (pStr) {
                sNewStr.m_pImpl->s.append(pStr);
            }
            return sNewStr;
        }
 
        String String::operator+(char ch) const {
            String sNewStr = *this;
            sNewStr.m_pImpl->s.push_back(ch);
            return sNewStr;
        }
 
        String& String::operator+=(const String& sStr) {
            m_pImpl->s.append(sStr.GetRawString());
            return *this;
        }
 
        String& String::operator+=(const char* pStr) {
            if (pStr) {
                m_pImpl->s.append(pStr);
            }
            return *this;
        }
 
        String& String::operator+=(char ch) {
            m_pImpl->s.push_back(ch);
            return *this;
        }
 
        String operator+(const char* pStr, const String& sStr) {
            String newStr(pStr ? pStr : "");
            return newStr + sStr;
        }
 
        String operator+(char ch, const String& sStr) {
            char buf[2] = { ch, 0 };
            String newStr(buf);
            return newStr + sStr;
        }
 
 
        String::String(const char* pStr) {
            if (pStr == nullptr) throw ArgumentException("Invalid input pointer");
            m_pImpl = new StringImpl();
            m_pImpl->s = pStr;
        }
 
        String::String(const String& sStr) { m_pImpl = new StringImpl(sStr.m_pImpl->s);  }
 
        String& String::operator=(const String& sStr) {
            if (this != &sStr) {
                m_pImpl->s = sStr.m_pImpl->s;
            }
            return *this;
        }
 
        String::String(String&& sStr) noexcept { m_pImpl = new StringImpl(std::move(sStr.m_pImpl->s));  }
        String& String::operator=(String&& sStr) noexcept {
            if (this != &sStr) {
                m_pImpl->s = std::move(sStr.m_pImpl->s);
            }
            return *this;
        }
        String::String(const wchar_t* pStr) {
            if (pStr == nullptr) throw ArgumentException("Invalid input pointer");
            m_pImpl = new StringImpl();
 
            m_pImpl->s = Utils::StringConvert::WCharToUtf8(pStr);
        }
 
        String& String::operator=(const wchar_t* pStr) {
            if (pStr == nullptr) throw ArgumentException("Invalid input pointer");
 
            m_pImpl->s = Utils::StringConvert::WCharToUtf8(pStr);
 
            return *this;
        }
 
        String& String::operator=(const char* pStr) {
            if (pStr == nullptr) throw ArgumentException("Invalid input pointer");
            m_pImpl->s = pStr;
            return *this;
        }
        const char* String::GetRawString() const {
            return m_pImpl->s.c_str();
        }
        const char* String::GetChars() const {
            return GetRawString();
        }
        int String::GetHashCode() const {
            const char* p = GetRawString();
            if (!p) return 0;
            unsigned int hash = 2166136261u;
            while (*p) {
                hash ^= (unsigned char)(*p);
                hash *= 16777619u;
                ++p;
            }
            return (int)hash;
        }
        int String::GetLength() const {
            return static_cast<int>(m_pImpl->s.length());
        }
 
        String String::Clone() const {
            return String(GetRawString());
        }
 
 
        char String::operator[](int iIndex) const {
            if (iIndex >= (int)m_pImpl->s.size()) throw ArgumentOutOfRangeException("Invalid iIndex");
            return GetRawString() [iIndex];
        }
        static std::string ToLowerString(const std::string& s) {
            std::string res = s;
            std::transform(res.begin(), res.end(), res.begin(), [](char ch) {
                return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
            });
            return res;
        }
 
        int String::Compare(const String& sStr1, int iIndex1, const String& sStr2, int iIndex2, int iLength, bool bIgnoreCase) {
            if (!bIgnoreCase) {
                return sStr1.m_pImpl->s.compare(iIndex1, iLength, sStr2.m_pImpl->s, iIndex2, iLength);
            }
            auto s1 = ToLowerString(sStr1.m_pImpl->s.substr(iIndex1, iLength));
            auto s2 = ToLowerString(sStr2.m_pImpl->s.substr(iIndex2, iLength));
            return s1.compare(s2);
        }
 
        int String::CompareTo(const String& sStr) const {
            return m_pImpl->s.compare(sStr.GetRawString());
        }
        String String::Concat(
            const std::initializer_list<String> sStrs) const {
            String sNewStr = *this;
            for (auto sStr : sStrs) {
                sNewStr.m_pImpl->s.append(sStr.GetRawString());
            }
            return sNewStr;
        }
        String String::operator+(
            const String& sStr) const {
            return Concat({ sStr });
        }
        bool String::Contains(char ch) const {
            return m_pImpl->s.find(ch) != std::string::npos;
        }
        bool String::Contains(const String& sStr) const {
            return m_pImpl->s.find(sStr.m_pImpl->s) != std::string::npos;
        }
 
        void String::CopyTo(int iSourceIndex, char* pDestination,
                            int iDestinationIndex, int iDestArraySize,
                            int iCount) const {
            if (nullptr == pDestination)
                throw ArgumentException("Invalid destination buffer");
            int iLen = GetLength();
            if (iSourceIndex < 0 || iSourceIndex >= iLen)
                throw ArgumentOutOfRangeException("Invalid iSourceIndex");
            if (iCount > iLen)
                throw ArgumentOutOfRangeException(
                    "Source array size is smaller than iCount");
            if (iCount > iDestArraySize)
                throw ArgumentOutOfRangeException(
                    "Destination array is smaller than iCount");
            m_pImpl->s.copy(pDestination + iDestinationIndex, iCount, iSourceIndex);
        }
        bool String::EndsWith(char ch, bool bIgnoreCase) const {
            auto iLen = m_pImpl->s.length();
            if (iLen == 0) return false;
            if (bIgnoreCase) {
                return std::tolower(static_cast<unsigned char>(m_pImpl->s [iLen - 1])) == std::tolower(static_cast<unsigned char>(ch));
            }
            return m_pImpl->s [iLen - 1] == ch;
        }
        bool String::EndsWith(const String& sSuffix,
                              bool bIgnoreCase) const {
            int iLen = GetLength();
            int iSuffixLen = sSuffix.GetLength();
            if (iSuffixLen > iLen) return false;
 
            if (bIgnoreCase) {
                return Compare(*this, iLen - iSuffixLen, sSuffix, 0, iSuffixLen, true) == 0;
            }
            return m_pImpl->s.compare(static_cast<size_t>(iLen - iSuffixLen), static_cast<size_t>(iSuffixLen), sSuffix.m_pImpl->s) == 0;
        }
        bool String::Equals(const String& sStr1,
                            const String& sStr2) {
            return sStr1 == sStr2;
        }
        bool String::Equals(const String& sStr) const {
            return *this == sStr;
        }
        int String::IndexOf(const String& sSubstring) const {
            return IndexOf(sSubstring, 0, false);
        }
        int String::IndexOf(const String& sSubstring,
                            bool bIgnoreCase) const {
            return IndexOf(sSubstring, 0, bIgnoreCase);
        }
        int String::IndexOf(const String& sSubstring,
                            int iStartIndex, bool bIgnoreCase) const {
            if (iStartIndex < 0 || iStartIndex > GetLength())
                throw ArgumentOutOfRangeException("Invalid iStartIndex");
 
            if (sSubstring.IsEmpty()) return iStartIndex;
 
            if (!bIgnoreCase) {
                auto pos = m_pImpl->s.find(sSubstring.m_pImpl->s, iStartIndex);
                return (pos == std::string::npos) ? -1 : (int)pos;
            }
 
            // Case-insensitive search
            auto it = std::search(
                m_pImpl->s.begin() + iStartIndex, m_pImpl->s.end(),
                sSubstring.m_pImpl->s.begin(), sSubstring.m_pImpl->s.end(),
                [](char c1, char c2) { return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2)); }
            );
 
            return (it == m_pImpl->s.end()) ? -1 : (int)std::distance(m_pImpl->s.begin(), it);
        }
        int String::IndexOfAny(int iStartIndex,
                               std::initializer_list<char> chChars) {
            if (iStartIndex < 0 || iStartIndex > GetLength())
                throw ArgumentOutOfRangeException("Invalid iStartIndex");
 
            auto pos = m_pImpl->s.find_first_of(std::string(chChars.begin(), chChars.end()), iStartIndex);
            return (pos == std::string::npos) ? -1 : (int)pos;
        }
 
 
 
        String& String::Append(const char ch) {
            m_pImpl->s += ch;
            return *this;
        }
        String& String::Append(
            const String& sStr) {
            m_pImpl->s.append(sStr.GetRawString());
            return *this;
        }
        String& String::Insert(
            int iIndex, const String& sStr) {
            int iLen = GetLength();
            if (iIndex < 0 || iIndex > iLen)
                throw ArgumentOutOfRangeException("Invalid iIndex");
 
            m_pImpl->s.insert(iIndex, sStr.GetRawString(), sStr.GetLength());
            return *this;
        }
        bool String::IsEmpty() const {
            return m_pImpl->s.empty();
        }
 
        String String::Join(
            char chSeparator, std::initializer_list<String> sStrings) {
            return Join(chSeparator, sStrings, 0, (int)sStrings.size());
        }
        String String::Join(
            char chSeparator, std::initializer_list<String> sStrings,
            int iStartIndex, int iCount) {
            if (iStartIndex < 0 || iStartIndex > (int)sStrings.size())
                throw ArgumentOutOfRangeException("Invalid iStartIndex");
            if (iCount < 0 || (iStartIndex + iCount) > (int)sStrings.size())
                throw ArgumentOutOfRangeException("Invalid iCount");
 
            const String* pStrs = sStrings.begin();
            String sJoinStr("");
 
            for (int i = iStartIndex; i < iStartIndex + iCount; i++) {
                sJoinStr.Append(pStrs[i]);
                if (i != iStartIndex + iCount - 1) {
                    sJoinStr.Append(chSeparator);
                }
            }
            return sJoinStr;
        }
        String String::Join(
            const String& sSeparator,
            std::initializer_list<String> sStrings) {
            return Join(sSeparator, sStrings, 0, (int)sStrings.size());
        }
        String String::Join(
            const String& sSeparator,
            std::initializer_list<String> sStrings, int iStartIndex,
            int iCount) {
            if (iStartIndex < 0 || iStartIndex > (int)sStrings.size())
                throw ArgumentOutOfRangeException("Invalid iStartIndex");
            if (iCount < 0 || (iStartIndex + iCount) > (int)sStrings.size())
                throw ArgumentOutOfRangeException("Invalid iCount");
 
            const String* pStrs = sStrings.begin();
            String sJoinStr("");
 
            for (int i = iStartIndex; i < iStartIndex + iCount; i++) {
                sJoinStr.Append(pStrs[i]);
                if (i != iStartIndex + iCount - 1) {
                    sJoinStr.Append(sSeparator);
                }
            }
            return sJoinStr;
        }
        int String::LastIndexOf(const String& sStr,
                                bool bIgnoreCase) {
            if (sStr.IsEmpty()) return GetLength();
 
            if (!bIgnoreCase) {
                auto pos = m_pImpl->s.rfind(sStr.m_pImpl->s);
                return (pos == std::string::npos) ? -1 : (int)pos;
            }
 
            auto it = std::find_end(
                m_pImpl->s.begin(), m_pImpl->s.end(),
                sStr.m_pImpl->s.begin(), sStr.m_pImpl->s.end(),
                [](char c1, char c2) { return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2)); }
            );
 
            return (it == m_pImpl->s.end()) ? -1 : (int)std::distance(m_pImpl->s.begin(), it);
        }
 
        static int FindLastCharIndex(const std::string& s, int iStartIndex, char ch, bool bIgnoreCase) {
            for (int i = static_cast<int>(s.length()) - 1; i >= iStartIndex; --i) {
                bool match = bIgnoreCase 
                    ? std::tolower(static_cast<unsigned char>(s[i])) == std::tolower(static_cast<unsigned char>(ch))
                    : (s[i] == ch);
                if (match) return i;
            }
            return -1;
        }
 
        int String::LastIndexOfAny(int iStartIndex, std::initializer_list<char> chChars, bool bIgnoreCase) {
            if (iStartIndex < 0 || iStartIndex > GetLength()) throw ArgumentOutOfRangeException("Invalid iStartIndex");
            if (IsEmpty()) return -1;
 
            for (auto ch : chChars) {
                int idx = FindLastCharIndex(m_pImpl->s, iStartIndex, ch, bIgnoreCase);
                if (idx != -1) return idx;
            }
            return -1;
        }
        String String::PadLeft(int iTotalWidth) {
            return PadLeft(iTotalWidth, (char)' ');
        }
        String String::PadLeft(int iTotalWidth,
                               char ch) {
            if (iTotalWidth < 0) {
                throw ArgumentException("Invalid iTotalWidth");
            }
            int iLen = GetLength();
            if (iTotalWidth <= iLen) {
                return *this;
            }
            std::string sPadding(iTotalWidth - iLen, ch);
            m_pImpl->s.insert(0, sPadding);
            return *this;
        }
        String String::PadRight(int iTotalWidth) {
            return PadRight(iTotalWidth, (char)' ');
        }
        String String::PadRight(int iTotalWidth,
                                char ch) {
            if (iTotalWidth < 0) {
                throw ArgumentException("Invalid iTotalWidth");
            }
            int iLen = GetLength();
            if (iTotalWidth <= iLen) {
                return *this;
            }
            m_pImpl->s.append(iTotalWidth - iLen, ch);
            return *this;
        }
        String String::Remove(int iStartIndex) const {
            return Remove(iStartIndex, GetLength() - iStartIndex);
        }
        String String::Remove(int iStartIndex,
                              int iCount) const {
            int iLen = GetLength();
            if (iStartIndex < 0 || iStartIndex > iLen || iCount < 0 || (iStartIndex + iCount) > iLen) {
                throw ArgumentOutOfRangeException("Invalid iStartIndex or iCount");
            }
 
            std::string sRet = m_pImpl->s;
            sRet.erase(iStartIndex, iCount);
            return String(sRet.c_str());
        }
        String String::Replace(char chOriginalChar,
                               char chReplaceChar) const {
            std::string sRet = m_pImpl->s;
            std::replace(sRet.begin(), sRet.end(), chOriginalChar, chReplaceChar);
            return String(sRet.c_str());
        }
        String String::Replace(
            const String& sOriginalStr,
            const String& sReplaceStr) const {
            if (sOriginalStr.IsEmpty()) return *this;
 
            std::string sRet = m_pImpl->s;
            size_t pos = 0;
            while ((pos = sRet.find(sOriginalStr.m_pImpl->s, pos)) != std::string::npos) {
                sRet.replace(pos, sOriginalStr.GetLength(), sReplaceStr.m_pImpl->s);
                pos += sReplaceStr.GetLength();
            }
            return String(sRet.c_str());
        }
        Array<String> String::Split(char chSeparator) const {
            std::vector<String> vTempResult;
            std::stringstream ss(m_pImpl->s);
            std::string sToken;
            while (std::getline(ss, sToken, chSeparator)) {
                vTempResult.push_back(String(sToken.c_str()));
            }
 
            Array<String> result((int)vTempResult.size());
            for (int i = 0; i < (int)vTempResult.size(); i++) result [i] = vTempResult [i];
            return result;
        }
 
        static void AddSplitToken(const std::string& sCurrent, StringSplitOptions eOptions, std::vector<String>& vResult) {
            String s(sCurrent.c_str());
            if (eOptions == StringSplitOptions::TrimEntries) s = s.Trim();
            if (eOptions != StringSplitOptions::RemoveEmptyEntries || !s.IsEmpty()) {
                vResult.push_back(s);
            }
        }
 
        static std::set<char> PopulateSplitCharSet(const String* pSeparator, int iCount) {
            std::set<char> charSet;
            if (!pSeparator || iCount <= 0) return charSet;
            for (int i = 0; i < iCount; ++i) {
                const char* raw = pSeparator[i].GetRawString();
                if (raw) { while (*raw) charSet.insert(*raw++); }
            }
            return charSet;
        }
 
        static std::vector<String> SplitByCharSet(const std::string& sText, const std::set<char>& charSet, StringSplitOptions eOptions) {
            std::vector<String> vResult;
            std::string sCurrent;
            for (char c : sText) {
                if (charSet.find(c) == charSet.end()) {
                    sCurrent += c;
                } else {
                    AddSplitToken(sCurrent, eOptions, vResult);
                    sCurrent.clear();
                }
            }
            AddSplitToken(sCurrent, eOptions, vResult);
            return vResult;
        }
 
        Array<String> String::Split(const Array<String>& arrSeparators, StringSplitOptions eOptions) const {
            return Split(arrSeparators.GetData(), arrSeparators.GetLength(), eOptions);
        }
 
        Array<String> String::Split(const String* pSeparator, int iCount, StringSplitOptions eOptions) const {
            std::set<char> charSet = PopulateSplitCharSet(pSeparator, iCount);
            std::vector<String> vTempResult = SplitByCharSet(m_pImpl->s, charSet, eOptions);
            Array<String> result(static_cast<int>(vTempResult.size()));
            for (int i = 0; i < result.GetLength(); i++) result[i] = vTempResult[i];
            return result;
        }
 
        bool String::StartsWith(const String& sPrefix) const {
            return StartsWith(sPrefix, false);
        }
 
        bool String::StartsWith(const String& sPrefix, bool bIgnoreCase) const {
            if (sPrefix.GetLength() > GetLength()) return false;
 
            if (!bIgnoreCase) {
                return m_pImpl->s.compare(0, sPrefix.GetLength(), sPrefix.m_pImpl->s) == 0;
            }
 
            return Compare(*this, 0, sPrefix, 0, sPrefix.GetLength(), true) == 0;
        }
 
        String String::FromInt(int iValue) {
            return ValueOf(iValue);
        }
 
        String String::ValueOf(int iValue) {
            return ToStringHelper(iValue);
        }
 
 
        String String::ValueOf(long long llValue) {
            return ToStringHelper(llValue);
        }
 
        String String::ValueOf(double dValue) {
            std::ostringstream ss;
            ss << dValue;
            return String(ss.str().c_str());
        }
 
        String String::ToString(int iValue) {
            return ToStringHelper(iValue);
        }
 
        String String::ToString(long long llValue) {
            return ToStringHelper(llValue);
        }
 
        String String::ToString(double dValue) {
            return ToStringHelper(dValue);
        }
 
        String String::ToString(bool bValue) {
            return ToStringHelper(bValue);
        }
 
        String String::Substring(int iStartIndex) const {
            return Substring(iStartIndex, GetLength() - iStartIndex);
        }
 
        String String::Substring(int iStartIndex, int iLength) const {
            int iLen = GetLength();
            if (iStartIndex < 0 || iStartIndex > iLen || iLength < 0 || (iStartIndex + iLength) > iLen) {
                throw ArgumentOutOfRangeException("Invalid iStartIndex or iLength");
            }
            return String(m_pImpl->s.substr(iStartIndex, iLength).c_str());
        }
 
 
        String String::ToLower() const {
            std::string sRet = m_pImpl->s;
            std::transform(sRet.begin(), sRet.end(), sRet.begin(), [](char ch) -> char {
                return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
                           });
            return String(sRet.c_str());
        }
 
        String String::ToUpper() const {
            std::string sRet = m_pImpl->s;
            std::transform(sRet.begin(), sRet.end(), sRet.begin(), [](char ch) -> char {
                return static_cast<char>(std::toupper(static_cast<unsigned char>(ch)));
                           });
            return String(sRet.c_str());
        }
 
        String String::Trim() const {
            return TrimStart().TrimEnd();
        }
 
        String String::TrimStart() const {
            auto it = std::find_if(m_pImpl->s.begin(), m_pImpl->s.end(), [](char ch) {
                return !std::isspace(static_cast<unsigned char>(ch));
                                   });
            if (it == m_pImpl->s.end()) return "";
            return String(m_pImpl->s.substr(std::distance(m_pImpl->s.begin(), it)).c_str());
        }
 
        String String::TrimEnd() const {
            auto it = std::find_if(m_pImpl->s.rbegin(), m_pImpl->s.rend(), [](char ch) {
                return !std::isspace(static_cast<unsigned char>(ch));
                                   });
            if (it == m_pImpl->s.rend()) return "";
            return String(m_pImpl->s.substr(0, m_pImpl->s.length() - std::distance(m_pImpl->s.rbegin(), it)).c_str());
        }
    }  // namespace System
}  // namespace DotNetDupe