WeakString.hpp

#pragma once

#include <string>
#include <vector>
#include <list>
#include <queue>
#include <algorithm>
#include <samchon/IndexPair.hpp>

#include <samchon/library/IOperator.hpp>
#include <samchon/library/Math.hpp>

namespace samchon
{
    class WeakString
    {
    private:
        static const std::vector<std::string> SPACE_ARRAY;

    public:
        static const size_t npos = -1;

    private:
        const char *data_;

        size_t size_;

    public:
        /* --------------------------------------------------------------------
            CONSTRUCTORS
        -------------------------------------------------------------------- */
        WeakString()
        {
            this->data_ = nullptr;
            this->size_ = 0;
        };

        WeakString(const char *data, size_t size)
        {
            this->data_ = data;
            this->size_ = size;
        };

        WeakString(const char *begin, const char *end)
            : WeakString(begin, end - begin)
        {
        };

        WeakString(const char *data)
        {
            this->data_ = data;

            if (data == nullptr)
                this->size_ = 0;
            else
                this->size_ = std::char_traits<char>::length(data);
        };

        WeakString(const char &ch)
        {
            this->data_ = &ch;
            this->size_ = 1;
        };

        WeakString(std::initializer_list<char> &il)
        {
            if (il.size() == 0)
                this->data_ = nullptr;
            else
                this->data_ = il.begin();

            this->size_ = il.size();
        };

        WeakString(const std::string &str)
        {
            this->data_ = str.data();
            this->size_ = str.size();
        };

        /* --------------------------------------------------------------------
            ELEMENT ACCESSORS
        -------------------------------------------------------------------- */
        auto data() const -> const char*
        {
            return data_;
        };

        auto size() const -> size_t
        {
            return size_;
        };

        auto empty() const -> bool
        {
            return data_ == nullptr || size_ == 0;
        };

        auto at(size_t index) const -> const char&
        {
            if (index > size_)
                throw std::out_of_range("out of range.");

            return *(data_ + index);
        };

        auto operator[](size_t index) const -> const char&
        {
            return *(data_ + index);
        };

        /* --------------------------------------------------------------------
            FINDERS
        -------------------------------------------------------------------- */
        auto find(const WeakString &delim, size_t startIndex = NULL) const -> size_t
        {
            size_t j = 0;

            for (size_t i = startIndex; i < size_; i++)
                if (data_[i] != delim[j++])
                    j = 0;
                else if (j == delim.size())
                    return i - delim.size() + 1;

            return npos;
        };

        auto rfind(const WeakString &delim, size_t endIndex = SIZE_MAX) const -> size_t
        {
            if (empty() == true || endIndex == 0)
                return npos;

            size_t j = delim.size() - 1;

            for (long long i = std::min<size_t>(endIndex - 1, size_ - 1); i >= 0; i--)
                if (data_[(size_t)i] != delim[j]) //NOT MATCHED
                    j = delim.size() - 1;
                else if (j == 0) //FULLY MATCHED
                    return (size_t)i;
                else //PARTIALLY MATCHED,
                    j--;

            return npos;
        };

        auto finds(const std::vector<std::string> &delims, size_t startIndex = 0) const -> IndexPair<WeakString>
        {
            std::vector<WeakString> wdelims(delims.size());
            for (size_t i = 0; i < delims.size(); i++)
                wdelims[i] = delims[i];

            return finds(wdelims, startIndex);
        };

        auto finds(const std::vector<WeakString> &delims, size_t startIndex = 0) const -> IndexPair<WeakString>
        {
            std::vector<size_t> positionVector;
            positionVector.reserve(delims.size());

            for (size_t i = 0; i < delims.size(); i++)
                positionVector.push_back(find(delims[i], startIndex));

            IndexPair<size_t> &iPair = library::Math::minimum(positionVector);
            return { iPair.get_index(), delims[iPair.getValue()] };
        };

        auto rfinds(const std::vector<std::string> &delims, size_t endIndex = SIZE_MAX) const -> IndexPair<WeakString>
        {
            std::vector<WeakString> wdelims(delims.size());
            for (size_t i = 0; i < delims.size(); i++)
                wdelims[i] = delims[i];

            return rfinds(wdelims, endIndex);
        };
        
        auto rfinds(const std::vector<WeakString> &delims, size_t endIndex = SIZE_MAX) const -> IndexPair<WeakString>
        {
            std::vector<size_t> positionVector;
            positionVector.reserve(delims.size());

            size_t position;

            for (size_t i = 0; i < delims.size(); i++)
            {
                position = rfind(delims[i], endIndex);

                if (position != std::string::npos)
                    positionVector.push_back(position);
            }

            if (positionVector.empty() == true)
                return { std::string::npos, WeakString() };

            IndexPair<size_t> &iPair = library::Math::maximum(positionVector);
            return { iPair.get_index(), delims[iPair.getValue()] };
        };

        /* --------------------------------------------------------------------
            EXTRACTORS
        -------------------------------------------------------------------- */
        auto substr(size_t startIndex, size_t size = SIZE_MAX) const -> WeakString
        {
            if (size > size_ || startIndex + size > size_)
                size = size_ - startIndex;

            return WeakString(data_ + startIndex, size);
        };

        auto substring(size_t startIndex, size_t endIndex = SIZE_MAX) const -> WeakString
        {
            if (startIndex > endIndex)
                std::swap(startIndex, endIndex);

            if (startIndex == endIndex || startIndex > size_ - 1)
                return WeakString();

            if (endIndex > size_)
                endIndex = size_;

            return WeakString(data_ + startIndex, data_ + endIndex);
        };

        auto between(const WeakString &start = {}, const WeakString &end = {}) const -> WeakString
        {
            if (start.empty() == true && end.empty() == true)
                return *this;
            else if (start.empty() == true)
                return substr(0, find(end));
            else if (end.empty() == true)
                return substr(find(start) + start.size());
            else
            {
                size_t startIndex = find(start);

                return substring
                (
                    startIndex + start.size(),
                    find(end, startIndex + start.size())
                );
            }
        };

        auto split(const WeakString &delim) const -> std::vector<WeakString>
        {
            size_t startIndex = 0;
            size_t x;

            //CONSTRUCT THE LIST OF QUOTES
            std::queue<std::pair<size_t, size_t>> quoteList;
            while ((x = find(delim, startIndex)) != npos)
            {
                quoteList.push({ startIndex, x });
                startIndex = x + delim.size();
            }
            quoteList.push({ startIndex, size() });

            //ASSIGN THE STRING_VECTOR BY SUBSTRING
            std::vector<WeakString> vec;
            vec.reserve(quoteList.size());

            while (quoteList.empty() == false)
            {
                vec.push_back(substring(quoteList.front().first, quoteList.front().second));
                quoteList.pop();
            }
            return vec;
        };

        auto betweens(const WeakString &start = {}, const WeakString &end = {}) const -> std::vector<WeakString>
        {
            std::vector<WeakString> vec;

            if (start.empty() == true && end.empty() == true)
                return vec;
            else if (start == end) //NOT EMPTY, BUT EQUALS
            {
                std::queue<std::pair<size_t, size_t>> quoteList;

                size_t x, prevX = -1, n = 0;
                while ((x = find(start, prevX + 1)) != npos)
                {
                    if (++n % 2 == 0) //WHEN THE MATCHED NUMBER IS EVEN
                        quoteList.push({ prevX, x });
                    prevX = x;
                }

                if (quoteList.size() == 0)
                    vec.push_back(*this);
                else
                {
                    vec.reserve(quoteList.size());
                    while (quoteList.empty() == false)
                    {
                        std::pair<size_t, size_t> &quote = quoteList.front();
                        vec.push_back(substring(quote.first + start.size()));

                        quoteList.pop();
                    }
                }
            }
            else //BEGIN AND END IS DIFFER
            {
                vec = split(start);
                vec.erase(vec.begin());

                if (end.empty() == false)
                    for (long long i = (long long)vec.size() - 1; i >= 0; i--)
                        if (vec.at((size_t)i).find(end) == npos)
                            vec.erase(vec.begin() + (size_t)i);
                        else
                            vec[(size_t)i] = vec[(size_t)i].between("", end);
            }
            return vec;
        };

        /* --------------------------------------------------------------------
            TRIMS
        -------------------------------------------------------------------- */
        auto trim() const -> WeakString
        {
            return ltrim().rtrim();
        };
        auto ltrim() const -> WeakString
        {
            static const std::vector<std::string> SPACE_ARRAY = { " ", "\t", "\r", "\n" };

            return ltrim(SPACE_ARRAY);
        };
        auto rtrim() const -> WeakString
        {
            static const std::vector<std::string> SPACE_ARRAY = { " ", "\t", "\r", "\n" };

            return rtrim(SPACE_ARRAY);
        };

        auto trim(const WeakString &delim) const -> WeakString
        {
            return ltrim(delim).rtrim(delim);
        };
        auto ltrim(const WeakString &delim) const -> WeakString
        {
            return ltrim(std::vector<WeakString>({delim}));
        };
        auto rtrim(const WeakString &delim) const -> WeakString
        {
            return rtrim(std::vector<WeakString>({ delim }));
        };

        auto trim(const std::vector<std::string> &delims) const -> WeakString
        {
            return ltrim(delims).rtrim(delims);
        };
        
        auto ltrim(const std::vector<std::string> &delims) const -> WeakString
        {
            std::vector<WeakString> wdelims(delims.size());
            for (size_t i = 0; i < delims.size(); i++)
                wdelims[i] = delims[i];

            return ltrim(wdelims);
        };
        
        auto rtrim(const std::vector<std::string> &delims) const -> WeakString
        {
            std::vector<WeakString> wdelims(delims.size());
            for (size_t i = 0; i < delims.size(); i++)
                wdelims[i] = delims[i];

            return rtrim(wdelims);
        };

        auto trim(const std::vector<WeakString> &delims) const -> WeakString
        {
            return ltrim(delims).rtrim(delims);
        };
        auto ltrim(const std::vector<WeakString> &delims) const -> WeakString
        {
            WeakString str(data_, size_);
            IndexPair<size_t> indexPair = { 0, 0 };

            while (str.empty() == false)
            {
                std::vector<size_t> indexVec;
                indexVec.reserve(delims.size());

                for (size_t i = 0; i < delims.size(); i++)
                    indexVec.push_back(str.find(delims[i]));

                indexPair = library::Math::minimum(indexVec);
                if (indexPair.getValue() == 0)
                {
                    size_t size = delims[indexPair.get_index()].size();

                    str.data_ += size;
                    str.size_ -= size;
                }
                else
                    break;
            }

            return str;
        };
        auto rtrim(const std::vector<WeakString> &delims) const -> WeakString
        {
            WeakString str(data_, size_);
            IndexPair<size_t> pairIndex;

            while (str.empty() == false)
            {
                std::vector<size_t> indexVec;
                indexVec.reserve(delims.size());

                for (size_t i = 0; i < delims.size(); i++)
                {
                    size_t index = str.rfind(delims[i]);
                    if (index != npos)
                        indexVec.push_back(index);
                }
                if (indexVec.empty() == true)
                    break;

                pairIndex = library::Math::maximum(indexVec);
                size_t size = delims[pairIndex.get_index()].size();

                if (pairIndex.getValue() == str.size() - size)
                    str.size_ -= size;
                else
                    break;
            }
            return str;
        };

        /* --------------------------------------------------------------------
            REPLACERS
        -------------------------------------------------------------------- */
        auto replace(const WeakString &before, const WeakString &after) const -> std::string
        {
            size_t index = find(before);
            if (index == npos)
                return str();

            std::string str;
            str.reserve(size() - before.size() + after.size());

            str.append(substr(0, index).str());
            str.append(after.str());
            str.append(substr(index + before.size()).str());

            return str;
        };

        auto replaceAll(const WeakString &before, const WeakString &after) const -> std::string
        {
            return replaceAll({ { before, after } });
        };

        auto replaceAll(const std::vector<std::pair<std::string, std::string>> &pairs) const -> std::string
        {
            std::vector<std::pair<WeakString, WeakString>> wPairs(pairs.size());
            for (size_t i = 0; i < pairs.size(); i++)
                wPairs[i] = { pairs[i].first, pairs[i].second };

            return replaceAll(wPairs);
        };

        auto replaceAll(const std::vector<std::pair<WeakString, WeakString>> &pairs) const -> std::string
        {
            if (pairs.empty() == true)
                return this->str();

            std::list<std::pair<size_t, size_t>> foundPairList;
            //1ST IS STR-INDEX FROM FIND
            //2ND IS PAIR-INDEX

            size_t size = this->size();
            size_t index;
            size_t i;

            //FIND POSITION-INDEX IN ORIGINAL STRING
            for (i = 0; i < pairs.size(); i++)
            {
                index = 0;

                while (true)
                {
                    index = find(pairs[i].first, index);
                    if (index == npos)
                        break;

                    size -= pairs[i].first.size();
                    size += pairs[i].second.size();

                    foundPairList.push_back({ index++, i });
                }
            }

            if (foundPairList.empty() == true)
                return str();

            foundPairList.sort();

            //REPLACE
            std::string str;
            str.reserve((size_t)size);

            index = 0;

            while (foundPairList.empty() == false)
            {
                auto it = foundPairList.begin();
                auto &before = pairs[it->second].first;
                auto &after = pairs[it->second].second;

                str.append(substring(index, it->first).str());
                str.append(after.str());

                index = it->first + before.size();
                foundPairList.pop_front();
            }
            if (index <= this->size() - 1)
                str.append(substr(index).str());

            return str;
        };

        auto toLowerCase() const -> std::string
        {
            std::string &str = this->str();

            for (size_t i = 0; i < str.size(); i++)
                if ('A' <= str[i] && str[i] <= 'Z')
                    str[i] = tolower(str[i]);

            return str;
        };

        auto yoUpperCase() const -> std::string
        {
            std::string &str = this->str();

            for (size_t i = 0; i < str.size(); i++)
                if ('a' <= str[i] && str[i] <= 'z')
                    str[i] = toupper(str[i]);

            return str;
        };

        /* --------------------------------------------------------------------
            COMPARISONS
        -------------------------------------------------------------------- */
        auto operator==(const WeakString &str) const -> bool
        {
            if (size_ != str.size_)
                return false;
            else if (data_ == str.data_)
                return true;

            for (size_t i = 0; i < size(); i++)
                if (data_[i] != str.data_[i])
                    return false;

            return true;
        };

        auto operator<(const WeakString &str) const -> bool
        {
            size_t minSize = std::min<size_t>(size(), str.size());

            for (size_t i = 0; i < minSize; i++)
                if (this->at(i) == str[i])
                    continue;
                else if (this->at(i) < str[i])
                    return true;
                else
                    return false;

            if (this->size() == minSize && this->size() != str.size())
                return true;
            else
                return false;
        };

        OPERATOR_METHODS_INLINE(WeakString)

        /* --------------------------------------------------------------------
            CONVERSIONS
        -------------------------------------------------------------------- */
        auto str() const -> std::string
        {
            return std::string(data_, data_ + size_);
        };

        operator std::string()
        {
            return str();
        };
    };
};