SqMod/module/Library/Utils/String.hpp

#pragma once

// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"

// ------------------------------------------------------------------------------------------------
#include <Poco/String.h>

// ------------------------------------------------------------------------------------------------
#include <string>
#include <random>
#include <iterator>
#include <algorithm>

// ------------------------------------------------------------------------------------------------
namespace SqMod {

/* ------------------------------------------------------------------------------------------------
 * Wrapper around a std::string.
*/
struct SqString
{
    /* --------------------------------------------------------------------------------------------
     * String instance.
    */
    String mS{};

    /* --------------------------------------------------------------------------------------------
     * Default constructor.
    */
    SqString() = default;

    /* --------------------------------------------------------------------------------------------
     * Construct with initial capacity. No element is created.
    */
    explicit SqString(SQInteger n)
        : mS()
    {
        mS.reserve(ClampL< SQInteger, size_t >(n));
    }

    /* --------------------------------------------------------------------------------------------
     * Construct with initial string.
    */
    explicit SqString(StackStrF & s)
        : mS(s.mPtr, s.GetSize())
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Construct with initial size. Filled with copies of specified element.
    */
    SqString(SQInteger n, String::value_type v)
        : mS()
    {
        mS.resize(ClampL< SQInteger, size_t >(n), v);
    }

    /* --------------------------------------------------------------------------------------------
     * Construct with forwarded native arguments.
    */
    template < class... Args > explicit SqString(SqInPlace SQ_UNUSED_ARG(x), Args&&... args)
        : mS(std::forward< Args >(args)...)
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Copy constructor from reference.
    */
    explicit SqString(const String & s) // NOLINT(modernize-pass-by-value)
        : mS(s)
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Move constructor from reference.
    */
    explicit SqString(String && s) noexcept
        : mS(std::move(s))
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Construct with character range.
    */
    SqString(String::iterator f, String::iterator l)
        : mS(f, l)
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Construct with character range.
    */
    SqString(String::const_iterator f, String::const_iterator l)
        : mS(f, l)
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Copy constructor.
    */
    SqString(const SqString & s) = default;

    /* --------------------------------------------------------------------------------------------
     * Move constructor.
    */
    SqString(SqString &&) noexcept = default;

    /* --------------------------------------------------------------------------------------------
     * Destroys the Statement.
    */
    ~SqString() = default;

    /* --------------------------------------------------------------------------------------------
     * Assignment operator.
    */
    SqString & operator = (const SqString &) = default;

    /* --------------------------------------------------------------------------------------------
     * Move assignment.
    */
    SqString & operator = (SqString &&) noexcept = default;

    /* --------------------------------------------------------------------------------------------
     * Make sure an index is within range and return the container.
    */
    SQMOD_NODISCARD String & ValidIdx(SQInteger i)
    {
        if (static_cast< size_t >(i) >= mS.size())
        {
            STHROWF("Invalid string container index({})", i);
        }
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Make sure an index is within range and return the container.
    */
    SQMOD_NODISCARD const String & ValidIdx(SQInteger i) const
    {
        if (static_cast< size_t >(i) >= mS.size())
        {
            STHROWF("Invalid string container index({})", i);
        }
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Make sure a container instance is referenced and is populated, then return it.
    */
    SQMOD_NODISCARD String & ValidPop()
    {
        if (mS.empty())
        {
            STHROWF("String container is empty");
        }
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Make sure a container instance is referenced and is populated, then return it.
    */
    SQMOD_NODISCARD const String & ValidPop() const
    {
        if (mS.empty())
        {
            STHROWF("String container is empty");
        }
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the internal string container.
    */
    SQMOD_NODISCARD String & ToString()
    {
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the internal string container.
    */
    SQMOD_NODISCARD const String & ToString() const
    {
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the internal string container.
    */
    SQMOD_NODISCARD const String & GetString() const
    {
        return mS;
    }

    /* --------------------------------------------------------------------------------------------
     * Modify the internal string container.
    */
    SQMOD_NODISCARD SqString & SetString(StackStrF & str)
    {
        mS.assign(str.mPtr, static_cast< size_t >(str.mLen));
        return *this; // Allow chaining
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve a value from the container.
    */
    SQMOD_NODISCARD SQInteger Get(SQInteger i) const
    {
        return ValidIdx(i)[ClampL< SQInteger, size_t >(i)];
    }

    /* --------------------------------------------------------------------------------------------
     * Modify a value from the container.
    */
    void Set(SQInteger i, String::value_type v)
    {
        ValidIdx(i)[i] = v;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the first element in the container.
    */
    SQMOD_NODISCARD SQInteger Front() const
    {
        return ValidPop().front();
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the last element in the container.
    */
    SQMOD_NODISCARD SQInteger Back() const
    {
        return ValidPop().back();
    }

    /* --------------------------------------------------------------------------------------------
     * Check if the container has no elements.
    */
    SQMOD_NODISCARD bool Empty() const
    {
        return mS.empty();
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the number of elements in the container.
    */
    SQMOD_NODISCARD SQInteger Size() const
    {
        return static_cast< SQInteger >(mS.size());
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the number of elements that the container has currently allocated space for.
    */
    SQMOD_NODISCARD SQInteger Capacity() const
    {
        return static_cast< SQInteger >(mS.capacity());
    }

    /* --------------------------------------------------------------------------------------------
     * Resize the container to contain a specific amount of elements.
    */
    void Resize(SQInteger n)
    {
        mS.resize(ClampL< SQInteger, size_t >(n));
    }

    /* --------------------------------------------------------------------------------------------
     * Resize the container to contain a specific amount of elements.
    */
    SqString & ResizeEx(SQInteger n, String::value_type v)
    {
        mS.resize(ClampL< SQInteger, size_t >(n), v);
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Increase the capacity of the container to a value that's greater or equal to the one specified.
    */
    SqString & Reserve(SQInteger n)
    {
        mS.reserve(ClampL< SQInteger, size_t >(n));
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Request the removal of unused capacity.
    */
    void Compact()
    {
        mS.shrink_to_fit();
    }

    /* --------------------------------------------------------------------------------------------
     * Erase all elements from the container.
    */
    void Clear()
    {
        mS.clear();
    }

    /* --------------------------------------------------------------------------------------------
     * Push a value at the back of the container.
    */
    void Push(String::value_type v)
    {
        mS.push_back(v);
    }

    /* --------------------------------------------------------------------------------------------
     * Push copies of a value at the back of the container.
    */
    void Append(SQInteger n, String::value_type v)
    {
        mS.append(static_cast< size_t >(n), v);
    }

    /* --------------------------------------------------------------------------------------------
     * Extends the Container by appending all the items in the given container.
    */
    void Extend(StackStrF & s)
    {
        mS.append(s.mPtr, s.GetSize());
    }

    /* --------------------------------------------------------------------------------------------
     * Pop the last element in the container.
    */
    void Pop()
    {
        ValidPop().pop_back();
    }

    /* --------------------------------------------------------------------------------------------
     * Erase the element at a certain position.
    */
    void EraseAt(SQInteger i)
    {
        mS.erase(ValidIdx(i).begin() + static_cast< size_t >(i));
    }

    /* --------------------------------------------------------------------------------------------
     * Erase a certain amount of elements starting from a specific position.
    */
    void EraseFrom(SQInteger i, SQInteger n)
    {
        mS.erase(ValidIdx(i).begin() + static_cast< size_t >(i),
                  ValidIdx(i + n).begin() + static_cast< size_t >(i + n));
    }

    /* --------------------------------------------------------------------------------------------
     * Erase all occurrences of value from the container.
    */
    void EraseValue(String::value_type v)
    {
        mS.erase(std::remove(mS.begin(), mS.end(), v), mS.end());
    }

    /* --------------------------------------------------------------------------------------------
     * Insert a specific value starting from a certain position.
    */
    void InsertAt(SQInteger i, String::value_type v)
    {
        mS.insert(ValidIdx(i).begin() + static_cast< size_t >(i), v);
    }

    /* --------------------------------------------------------------------------------------------
     * Insert a certain amount of copies of a value starting from a specific position.
    */
    void Insert(SQInteger i, SQInteger n, String::value_type v)
    {
        mS.insert(ValidIdx(i).begin() + static_cast< size_t >(i), ClampL< SQInteger, size_t >(n), v);
    }

    /* --------------------------------------------------------------------------------------------
     * Count the occurrences of a value in the container.
    */
    SQMOD_NODISCARD SQInteger Count(String::value_type v) const
    {
        return static_cast< SQInteger >(std::count(mS.begin(), mS.end(), v));
    }

    /* --------------------------------------------------------------------------------------------
     * See if values are the same as another container.
    */
    SQMOD_NODISCARD bool Equal(SqString & o) const { return mS == o.mS; }

    /* --------------------------------------------------------------------------------------------
     * Retrieve a portion of this container.
    */
    SQMOD_NODISCARD LightObj Slice(SQInteger p, SQInteger n) const
    {
        return LightObj(SqTypeIdentity< SqString >{}, SqVM(),
                        ValidIdx(p).begin() + static_cast< size_t >(p),
                        ValidIdx(p + n).begin() + static_cast< size_t >(p + n));
    }

    /* --------------------------------------------------------------------------------------------
     * Iterate all values through a functor.
    */
    void Each(Function & fn) const
    {
        for (const auto & e : mS)
        {
            fn.Execute(e);
        }
    }

    /* --------------------------------------------------------------------------------------------
     * Iterate values in range through a functor.
    */
    void EachRange(SQInteger p, SQInteger n, Function & fn) const
    {
        std::for_each(ValidIdx(p).begin() + static_cast< size_t >(p),
                      ValidIdx(p + n).begin() + static_cast< size_t >(p + n),
        [&](String::const_reference e) {
            fn.Execute(e);
        });
    }

    /* --------------------------------------------------------------------------------------------
     * Iterate all values through a functor until stopped (i.e false is returned).
    */
    void While(Function & fn) const
    {
        for (const auto & e : mS)
        {
            auto ret = fn.Eval(e);
            // (null || true) == continue & false == break
            if (!ret.IsNull() || !ret.template Cast< bool >())
            {
                break;
            }
        }
    }

    /* --------------------------------------------------------------------------------------------
     * Iterate values in range through a functor until stopped (i.e false is returned).
    */
    void WhileRange(SQInteger p, SQInteger n, Function & fn) const
    {
        auto itr = ValidIdx(p).begin() + static_cast< size_t >(p);
        auto end = ValidIdx(p + n).begin() + static_cast< size_t >(p + n);
        for (; itr != end; ++itr)
        {
            auto ret = fn.Eval(*itr);
            // (null || true) == continue & false == break
            if (!ret.IsNull() || !ret.template Cast< bool >())
            {
                break;
            }
        }
    }

    /* --------------------------------------------------------------------------------------------
     * Reverse the order of elements in the container.
    */
    SqString & Reverse()
    {
        std::reverse(mS.begin(), mS.end());
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Generate new elements at the back of the container.
    */
    SqString & Generate(LightObj & ctx, Function & fn)
    {
        for (;;)
        {
            auto ret = fn.Eval(ctx);
            // null == break
            if (ret.IsNull())
            {
                break;
            }
            // Extract the value from object
            mS.push_back(ret.Cast< String::value_type >());
        }
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Generate new elements at the back of the container.
    */
    SqString & GenerateSome(SQInteger n, LightObj & ctx, Function & fn)
    {
        while (n--)
        {
            auto ret = fn.Eval(ctx);
            // Extract the value from object
            mS.push_back(ret.Cast< String::value_type >());
        }
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Generate new elements at specified position.
    */
    SqString & GenerateFrom(SQInteger p, SQInteger n, LightObj & ctx, Function & fn)
    {
        if (static_cast< size_t >(p) >= mS.size())
        {
            STHROWF("Invalid container index ({} >= {})", p, mS.size());
        }
        for (auto i = static_cast< size_t >(p); n--; ++i)
        {
            auto ret = fn.Eval(ctx);
            // Extract the value from object and insert it
            mS.insert(mS.begin() + i, ret.Cast< String::value_type >());
        }
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Generate new elements at specified position.
    */
    SqString & GenerateBetween(SQInteger p, SQInteger n, LightObj & ctx, Function & fn)
    {
        if (static_cast< size_t >(p) >= mS.size())
        {
            STHROWF("Invalid container index ({} >= {})", p, mS.size());
        }
        else if (static_cast< size_t >(p + n) >= mS.size())
        {
            STHROWF("Invalid container index ({} >= {})", p + n, mS.size());
        }
        for (n = (p + n); p <= n; ++p)
        {
            auto ret = fn.Eval(ctx);
            // Extract the value from object and assign it
            mS.at(static_cast< size_t >(p)) = ret.Cast< String::value_type >();
        }
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Sort the elements from the container.
    */
    SqString & Sort()
    {
        std::sort(mS.begin(), mS.end());
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Check if the elements from the container are sorted.
    */
    SQMOD_NODISCARD bool IsSorted()
    {
        return std::is_sorted(mS.begin(), mS.end());
    }

    /* --------------------------------------------------------------------------------------------
     * Shuffle the elements from the container.
    */
    SqString & Shuffle()
    {
        std::random_device rd;
        std::mt19937 g(rd());
        std::shuffle(mS.begin(), mS.end(), g);
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Remove white-space at the start of the string.
    */
    SqString & TrimLeft()
    {
        mS.erase(mS.begin(), std::find_if(mS.begin(), mS.end(), [](auto c) { return !std::isspace(c); }));
        // Allow chaining
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Remove white-space at the end of the string.
    */
    SqString & TrimRight()
    {
        mS.erase(std::find_if(mS.rbegin(), mS.rend(), [](auto c) { return !std::isspace(c); }).base(), mS.end());
        // Allow chaining
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Remove white-space either side of the string.
    */
    SqString & Trim()
    {
        return TrimLeft().TrimRight();
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the string with white space trimmed from either side of the string.
    */
    SQMOD_NODISCARD LightObj Trimmed()
    {
        const auto sb = mS.find_first_not_of(" \n\t\v\b\r\f\a");
        // Is it all white-space?
        if (sb != String::npos)
        {
            const auto se = mS.find_last_not_of(" \n\t\v\b\r\f\a");
            // Return the portion of the string that isn't surrounded by white-space
            return LightObj(mS.data() + sb, se - sb);
        }
        // Return an empty string
        return LightObj(_SC(""), SQInteger(0));
    }

    /* --------------------------------------------------------------------------------------------
     * Convert the string to lower-case.
    */
    SqString & ToLower()
    {
        std::transform(mS.begin(), mS.end(), mS.begin(), [](auto c) { return std::tolower(c); });
        // Allow chaining
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Convert the string to upper-case.
    */
    SqString & ToUpper()
    {
        std::transform(mS.begin(), mS.end(), mS.begin(), [](auto c) { return std::toupper(c); });
        // Allow chaining
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the string as lower-case.
    */
    SQMOD_NODISCARD LightObj GetLower() const
    {
        SqString s(mS);
        std::transform(s.mS.begin(), s.mS.end(), s.mS.begin(), [&](auto c) { return std::tolower(c); });
        return LightObj(s.mS.data(), static_cast< SQInteger >(s.mS.size()));
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the string as upper-case.
    */
    SQMOD_NODISCARD LightObj GetUpper() const
    {
        SqString s(mS);
        std::transform(s.mS.begin(), s.mS.end(), s.mS.begin(), [&](auto c) { return std::toupper(c); });
        return LightObj(s.mS.data(), static_cast< SQInteger >(s.mS.size()));
    }

    /* --------------------------------------------------------------------------------------------
     * Swap the letter case.
    */
    SqString & SwapCase()
    {
        std::transform(mS.begin(), mS.end(), mS.begin(), [](auto c) {
            return std::islower(c) ? std::toupper(c) : std::tolower(c);
        });
        // Allow chaining
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Perform a case-sensitive comparison against another string.
    */
    SQMOD_NODISCARD SQInteger Compare(SqString & o) const
    {
        return mS.compare(o.mS);
    }

    /* --------------------------------------------------------------------------------------------
     * Perform a case-insensitive comparison against another string.
    */
    SQMOD_NODISCARD SQInteger CompareI(SqString & o) const
    {
        return Poco::icompare(mS, mS);
    }

    /* --------------------------------------------------------------------------------------------
     * Check if string contains another sub-string.
    */
    SQMOD_NODISCARD bool Contains(StackStrF & s) const
    {
        return mS.find(s.mPtr, 0, s.GetSize()) != String::npos;
    }

    /* --------------------------------------------------------------------------------------------
     * Checks if the string begins with the given prefix.
    */
    SQMOD_NODISCARD bool StartsWith(StackStrF & s) const
    {
        return mS.size() >= s.GetSize() && mS.compare(0, s.GetSize(), s.mPtr) == 0;
    }

    /* --------------------------------------------------------------------------------------------
     * Checks if the string ends with the given suffix.
    */
    SQMOD_NODISCARD bool EndsWith(StackStrF & s) const
    {
        return mS.size() >= s.GetSize() && mS.compare(mS.size() - s.GetSize(), s.GetSize(), s.mPtr) == 0;
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the first substring equal to s.
    */
    SQMOD_NODISCARD SQInteger Find(StackStrF & s) const { return FindFrom(0, s); }
    SQMOD_NODISCARD SQInteger FindFrom(SQInteger p, StackStrF & s) const
    {
        return static_cast< SQInteger >(mS.find(s.mPtr, static_cast< size_t >(p), s.GetSize()));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the first character equal c (treated as a single-character substring).
    */
    SQMOD_NODISCARD SQInteger Locate(String::value_type c) const { return LocateFrom(c, 0); }
    SQMOD_NODISCARD SQInteger LocateFrom(String::value_type c, SQInteger p) const
    {
        return static_cast< SQInteger >(mS.find(c, static_cast< size_t >(p)));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the last substring equal to s.
    */
    SQMOD_NODISCARD SQInteger RFind(StackStrF & s) const { return RFindFrom(0, s); }
    SQMOD_NODISCARD SQInteger RFindFrom(SQInteger p, StackStrF & s) const
    {
        return static_cast< SQInteger >(mS.rfind(s.mPtr, static_cast< size_t >(p), s.GetSize()));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the last character equal to c. (treated as a single-character substring).
    */
    SQMOD_NODISCARD SQInteger RLocate(String::value_type c) const { return RLocateFrom(c, 0); }
    SQMOD_NODISCARD SQInteger RLocateFrom(String::value_type c, SQInteger p) const
    {
        return static_cast< SQInteger >(mS.rfind(c, static_cast< size_t >(p)));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the first character equal to one of the characters in s.
    */
    SQMOD_NODISCARD SQInteger FindFirstOf(StackStrF & s) const { return FindFirstOfFrom(0, s); }
    SQMOD_NODISCARD SQInteger FindFirstOfFrom(SQInteger p, StackStrF & s) const
    {
        return static_cast< SQInteger >(mS.find_first_of(s.mPtr, static_cast< size_t >(p), s.GetSize()));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the first character equal to c.
    */
    SQMOD_NODISCARD SQInteger LocateFirstOf(String::value_type c) const { return LocateFirstOfFrom(c, 0); }
    SQMOD_NODISCARD SQInteger LocateFirstOfFrom(String::value_type c, SQInteger p) const
    {
        return static_cast< SQInteger >(mS.find_first_of(c, static_cast< size_t >(p)));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the first character equal to none of characters in s.
    */
    SQMOD_NODISCARD SQInteger FindFirstNotOf(StackStrF & s) const { return FindFirstNotOfFrom(0, s); }
    SQMOD_NODISCARD SQInteger FindFirstNotOfFrom(SQInteger p, StackStrF & s) const
    {
        return static_cast< SQInteger >(mS.find_first_not_of(s.mPtr, static_cast< size_t >(p), s.GetSize()));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the first character not equal to c.
    */
    SQMOD_NODISCARD SQInteger LocateFirstNotOf(String::value_type c) const { return LocateFirstNotOfFrom(c, 0); }
    SQMOD_NODISCARD SQInteger LocateFirstNotOfFrom(String::value_type c, SQInteger p) const
    {
        return static_cast< SQInteger >(mS.find_first_not_of(c, static_cast< size_t >(p)));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the last character equal to one of characters in s.
    */
    SQMOD_NODISCARD SQInteger FindLastOf(StackStrF & s) const { return FindLastOfFrom(0, s); }
    SQMOD_NODISCARD SQInteger FindLastOfFrom(SQInteger p, StackStrF & s) const
    {
        return static_cast< SQInteger >(mS.find_last_of(s.mPtr, static_cast< size_t >(p), s.GetSize()));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the last character equal to c.
    */
    SQMOD_NODISCARD SQInteger LocateLastOf(String::value_type c) const { return LocateLastOfFrom(c, 0); }
    SQMOD_NODISCARD SQInteger LocateLastOfFrom(String::value_type c, SQInteger p) const
    {
        return static_cast< SQInteger >(mS.find_last_of(c, static_cast< size_t >(p)));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the last character equal to none of characters in s.
    */
    SQMOD_NODISCARD SQInteger FindLastNotOf(StackStrF & s) const { return FindLastNotOfFrom(0, s); }
    SQMOD_NODISCARD SQInteger FindLastNotOfFrom(SQInteger p, StackStrF & s) const
    {
        return static_cast< SQInteger >(mS.find_last_not_of(s.mPtr, static_cast< size_t >(p), s.GetSize()));
    }

    /* --------------------------------------------------------------------------------------------
     * Finds the last character not equal to c.
    */
    SQMOD_NODISCARD SQInteger LocateLastNotOf(String::value_type c) const { return LocateLastNotOfFrom(c, 0); }
    SQMOD_NODISCARD SQInteger LocateLastNotOfFrom(String::value_type c, SQInteger p) const
    {
        return static_cast< SQInteger >(mS.find_last_not_of(c, static_cast< size_t >(p)));
    }

    /* --------------------------------------------------------------------------------------------
     * Duplicate the string a certain amount of times.
    */
    SqString & Repeat(SQInteger n)
    {
        if (!mS.empty())
        {
            const size_t len = mS.size();
            // Replicate the same string n times
            while (n--)
            {
                mS.append(mS.data(), len);
            }
        }
        return *this; // Allow chaining
    }

    /* --------------------------------------------------------------------------------------------
     * Duplicate the string a certain amount of times with a specific delimiter.
    */
    SqString & Repeat_(SQInteger n, StackStrF & d)
    {
        const size_t len = mS.size();
        // Replicate the same string n times
        while (n--)
        {
            mS.append(mS.data(), len);
            // If there's no string then the delimiter will be repeated
            mS.append(d.mPtr, static_cast< size_t >(d.mLen));
        }
        return *this; // Allow chaining
    }

    /* --------------------------------------------------------------------------------------------
     * Replace all occurrences of `from` with `to`, starting at position p.
    */
    SqString & Replace(StackStrF & f, StackStrF & t) { return Replace_(0, f, t); }
    SqString & Replace_(SQInteger p, StackStrF & f, StackStrF & t)
    {
        if (!f.mLen)
        {
            STHROWF("Cannot replace empty string");
        }
        else if (!mS.empty())
        {
            Poco::replaceInPlace(mS, f.mPtr, t.mPtr, static_cast< size_t >(p));
        }
        return *this; // Allow chaining
    }


    /* --------------------------------------------------------------------------------------------
     * Replace all occurrences of `from` with `to`, starting at position p.
    */
    SqString & Change(String::value_type f, String::value_type t) { return Change_(0, f, t); }
    SqString & Change_(SQInteger p, String::value_type f, String::value_type t)
    {
        Poco::replaceInPlace(mS, f, t, static_cast< size_t >(p));
        return *this; // Allow chaining
    }

    /* --------------------------------------------------------------------------------------------
     * Remove all occurrences of characters from s.
    */
    SqString & Remove(StackStrF & s)
    {
        if (!s.mLen)
        {
            STHROWF("Cannot remove empty string");
        }
        for (SQInteger i = 0; !mS.empty() && i < s.mLen; ++i)
        {
            mS.erase(std::remove(mS.begin(), mS.end(), s.mPtr[i]), mS.end());
        }
        return *this; // Allow chaining
    }

    /* --------------------------------------------------------------------------------------------
     * Remove all occurrences of character c.
    */
    SqString & Eliminate(String::value_type c)
    {
        if (!mS.empty() )
        {
            mS.erase(std::remove(mS.begin(), mS.end(), c), mS.end());
        }
        return *this; // Allow chaining
    }

    /* --------------------------------------------------------------------------------------------
     * Generate a hash of the string using the 32-bit using the Fnv1a algorithm.
    */
    SQMOD_NODISCARD SQInteger GetFnv1a32() const
    {
        return static_cast< SQInteger >(FnvHash32(reinterpret_cast< FnvHashData >(mS.data()), mS.size()));
    }

    /* --------------------------------------------------------------------------------------------
     * Generate a hash of the string using the 64-bit using the Fnv1a algorithm.
    */
    SQMOD_NODISCARD SQInteger GetFnv1a64() const
    {
        return static_cast< SQInteger >(FnvHash64(reinterpret_cast< FnvHashData >(mS.data()), mS.size()));
    }

    /* --------------------------------------------------------------------------------------------
     * Compute the Levenshtein distance between two strings.
    */
    SQMOD_NODISCARD SQInteger GetLevenshtein(SqString & o) const;
};

} // Namespace:: SqMod