StringUtil.hpp

#pragma once
#include <samchon/API.hpp>

#include <string>
#include <samchon/WeakString.hpp>

#include <iostream>
#include <sstream>
#include <samchon/IndexPair.hpp>
#include <samchon/library/Math.hpp>

namespace samchon
{
namespace library
{
    class SAMCHON_FRAMEWORK_API StringUtil
    {
    public:
        /* ----------------------------------------------------------------------
            SUBSTITUTE
        ---------------------------------------------------------------------- */
        template <typename T, typename ... _Args>
        static auto substitute(const std::string &format,
            const T& val, const _Args& ... args) -> std::string
        {
            std::string &res = _substitute(format, val);

            return StringUtil::substitute(res, args...);
        };
        template <typename T> static auto substitute(const std::string &format, const T& val) -> std::string
        {
            return _substitute(format, val);
        };

        template <typename T, typename ... _Args >
        static auto substituteSQL(const std::string &format,
            const T& value, const _Args& ... args) -> std::string
        {
            std::string &res = _substituteSQL(format, value);
            return StringUtil::substituteSQL(res, args...);
        };
        template <typename T> static auto substituteSQL(const std::string &format, const T& value) -> std::string
        {
            return _substituteSQL(format, value);
        };

    protected:
        template <typename T> static auto _substitute(const std::string &format, const T& value) -> std::string
        {
            std::vector<std::string> &parenthesisArray = betweens(format, { (char)'{' }, { (char)'}' });
            std::vector<long> vec;

            for (auto it = parenthesisArray.begin(); it != parenthesisArray.end(); it++)
                if (isNumeric(*it) == true)
                    vec.push_back(stoi(*it));

            size_t index = (size_t)Math::minimum(vec).getValue();

            //replaceAll
            std::string &to = toString(value);
            return replaceAll(format, "{" + toString(index) + "}", to);
        };
        template <typename T> static auto _substituteSQL(const std::string &format, const T& value) -> std::string
        {
            std::vector<std::string> &parenthesisArray = betweens(format, "{", "}");
            std::vector<long> vec;

            for (auto it = parenthesisArray.begin(); it != parenthesisArray.end(); it++)
                if (isNumeric(*it) == true)
                    vec.push_back(stoi(*it));

            size_t index = (size_t)Math::minimum(vec).getValue();

            //replaceAll
            std::string &to = toSQL(value);
            return replaceAll(format, "{" + toString(index) + "}", to);
        };

        /* ----------------------------------------------------------------------
            SUBSTITUTE -> TO_STRING
        ---------------------------------------------------------------------- */
        template <typename T>
        static auto toString(const T &val) -> std::string
        {
            std::basic_stringstream<char> stream;
            stream << val;

            return stream.str();
        };
        template<> static auto toString(const WeakString &str) -> std::string;

        template <typename T>
        static auto toSQL(const T &val) -> std::string
        {
            if (val == INT_MIN)
                return "NULL";

            std::basic_stringstream<char> stream;
            stream << val;

            return stream.str();
        };
        template<> static auto toSQL(const bool &flag) -> std::string;
        template<> static auto toSQL(const char &val) -> std::string;
        template<> static auto toSQL(const std::string &str) -> std::string;
        template<> static auto toSQL(const WeakString &str) -> std::string;
        static auto toSQL(const char *) -> std::string;

    public:
        /* ----------------------------------------------------------------------
            NUMBER-FORMAT
                IN MONETARY UNIT, ADD DELIMETER ','
                COLOR-FORMAT

            POSITIVE NUMBER IS RED,
                NEGATIVE NUMBER IS BLUE
                ZERO IS BLACK
        ---------------------------------------------------------------------- */
        static auto isNumeric(const std::string &str) -> bool;

        static auto toNumber(const std::string &str) -> double;

        static auto numberFormat(double val, int precision = 2) -> std::string;

        static auto percentFormat(double val, int precision = 2) -> std::string;

        static auto colorNumberFormat(double value, int precision = 2, double delimiter = 0.0) -> std::string;

        static auto colorPercentFormat(double value, int precision = 2, double delimiter = 0.0) -> std::string;

        /* ----------------------------------------------------------------------
            TRIM -> WITH LTRIM & RTRIM
                IT'S RIGHT, THE TRIM OF ORACLE
        ---------------------------------------------------------------------- */
        static auto trim(const std::string &val, const std::vector<std::string> &delims) -> std::string;

        static auto ltrim(const std::string &val, const std::vector<std::string> &delims) -> std::string;

        static auto rtrim(const std::string &val, const std::vector<std::string> &delims) -> std::string;

        static auto trim(const std::string &str) -> std::string;
        static auto ltrim(const std::string &str) -> std::string;
        static auto rtrim(const std::string &str) -> std::string;

        static auto trim(const std::string &str, const std::string &delim) -> std::string;
        static auto ltrim(const std::string &str, const std::string &delim) -> std::string;
        static auto rtrim(const std::string &str, const std::string &delim) -> std::string;

        /* ----------------------------------------------------------------------
            EXTRACTORS
        ---------------------------------------------------------------------- */
        static auto finds(const std::string &str,
            const std::vector<std::string> &delims, size_t startIndex = 0)->IndexPair<std::string>;

        static auto rfinds(const std::string &str,
            const std::vector<std::string> &delims, size_t endIndex = SIZE_MAX)->IndexPair<std::string>;

        static auto substring(const std::string &str,
            size_t startIndex, size_t endIndex = SIZE_MAX) -> std::string;

        static auto between(const std::string &str,
            const std::string &start = "", const std::string &end = "") -> std::string;

        //TAB
        static auto addTab(const std::string &str, size_t n = 1) -> std::string;

        //MULTIPLE STRINGS
        static auto split(const std::string &str, const std::string &delim) -> std::vector<std::string>;

        static auto betweens
            (
                const std::string &str,
                const std::string &start = "", const std::string &end = ""
            ) -> std::vector<std::string>;

        /* ----------------------------------------------------------------------
            REPLACERS
        ---------------------------------------------------------------------- */
        //ALPHABET-CONVERSION
        static auto toLowerCase(const std::string &str) -> std::string;

        static auto toUpperCase(const std::string &str) -> std::string;

        static auto replaceAll
            (
                const std::string &str, 
                const std::string &before, const std::string &after
            ) -> std::string;

        static auto replaceAll(const std::string &str,
            const std::vector<std::pair<std::string, std::string>> &pairs) -> std::string;

        static auto removeHTMLSpaces(const std::string &) -> std::string;
    };
};
};