fmt.hpp

#ifndef __$CENXUANTIAN_FMT_HPP__
#define __$CENXUANTIAN_FMT_HPP__
#pragma once

#include <iostream>
#include <sstream>
#include <type_traits>
#include <tuple>

#define FMT_DEBUG 1

#define DBG_DIE(msg)                                                      \
    std::cout << "Error: " << msg << __FILE__ << ':' << __LINE__ << '\n'; \
    exit(-1)

namespace fmt
{

    namespace detail
    {
        // C++ version check
#if __cplusplus >= 202004
#define FMT_IF_CONSTEXPR constexpr
        constexpr int cxx_standard = 20;

#elif __cplusplus >= 201703
#define FMT_IF_CONSTEXPR constexpr
        constexpr int cxx_standard = 17;
#elif __cplusplus >= 201402
#define FMT_IF_CONSTEXPR
        constexpr int cxx_standard = 14;
#else
#error "C++ standard is not supported by fmt"
#endif
        // Traits
        template <class T>
        struct ostream_traits
        {
            static constexpr bool value = true;
        };
        template <class T>
        struct istring_traits
        {
            static constexpr bool value = true;
        };

        constexpr size_t npos = ~(size_t{0});

        template <class InputIter>
        inline size_t find_first_of(
            InputIter beg,
            InputIter end,
            typename std::iterator_traits<InputIter>::value_type const &item)
        {
            size_t cur = 0;
            while (beg != end)
            {
                if (*beg == item)
                {
                    return cur;
                }
                ++beg;
                ++cur;
            }
            return fmt::detail::npos;
        }
    }

    template <
        class OStreamT,
        class IStringT,
        size_t Limit>
    class formatter
    {
    private:
        struct item_pos
        {
            size_t beg; // pos of {
            size_t end; // pos of }
        };

        OStreamT &ostrem_;        // output string
        IStringT const &istring_; // input string
        item_pos items_[Limit];   // stores items' begin and end positions
        size_t num_items_;

        template <class Iter>
        inline void render_plain_text(Iter beg, Iter end)
        {
            while (beg != end)
            {
                auto cur_c = *beg;
                if (cur_c == '{' || cur_c == '}')
                {
                    auto next = beg + 1;
                    if (next != end && *next == cur_c)
                    {
                        // We want to skip this, because we don't want to print {{ or }}
                        ++beg;
                        continue;
                    }
                }
                ostrem_ << *beg;
                ++beg;
            }
        }

        /// @brief
        /// @tparam TupleT Tuple type
        /// @tparam Pos index of this item
        /// @param t the tuple that stores all items
        template <size_t Pos, class TupleT>
        inline void render_one(TupleT &t)
        {
            // get the begin and end positions of text
            size_t text_beg = 0;
            size_t text_end = items_[Pos].beg;
            if FMT_IF_CONSTEXPR (Pos != 0)
            { // In this case the position should be the end of last item + 1
                text_beg = items_[Pos - 1].end + 1;
            }

            // Print text
            render_plain_text(std::begin(istring_) + text_beg, std::begin(istring_) + text_end);

            // Get the begin and end positions of the formatter (item)
            size_t formatter_beg = items_[Pos].beg + 1;
            size_t formatter_end = items_[Pos].end;
            if (formatter_beg == formatter_end)
            { //  In this case there is nothing included in {}
                ostrem_ << std::get<Pos>(t);
            }
            else
            { // Parse the language included in {...}
              // Split the formatter
                const auto split_pos = fmt::detail::find_first_of(
                    std::begin(istring_) + formatter_beg,
                    std::begin(istring_) + formatter_end,
                    ':'
                );
            }
        }
        // TODO: need to check the 0 case
        template <size_t Pos, size_t End, class TupleT, typename std::enable_if<Pos<End>::type * = nullptr> inline void render_all(std::integral_constant<size_t, Pos>, TupleT &t)
        {
            render_one<Pos>(t);
            render_all<Pos + 1, End>(std::integral_constant<size_t, Pos + 1>{}, t);
        }

        template <size_t Pos, size_t End, class TupleT, typename std::enable_if<Pos == End>::type * = nullptr>
        inline void render_all(std::integral_constant<size_t, Pos>, TupleT &t)
        {
            auto beg = std::begin(istring_) + items_[Pos - 1].end + 1;
            auto end = std::end(istring_);
            render_plain_text(beg, end);
        }

    public:
        static_assert(detail::ostream_traits<OStreamT>::value, "OStreamT is not supported");
        static_assert(detail::istring_traits<IStringT>::value, "IStringT is not supported");
        static_assert(Limit > 0, "Limit must greater than 0");

        constexpr explicit formatter(OStreamT &ostrem, IStringT const &istring)
            : ostrem_(ostrem), istring_(istring), items_(), num_items_(0)
        {

            auto beg = std::begin(istring_);
            auto end = std::end(istring_);

            size_t pos = 0;
            size_t temp_beg = ~size_t(0);

            auto record_beg = [&]()
            {
                if (temp_beg == ~size_t(0))
                {
                    temp_beg = pos;
                }
                else
                {
                    // TODO: remove std::string from here
                    std::string what = "invalid input string formatter at pos " + std::to_string(pos) + std::string(__FILE__) + ":" + std::to_string(__LINE__);
                    // throw std::exception(what.c_str());
                    DBG_DIE(what);
                }
            };

            auto record_end = [&]()
            {
                if (temp_beg != ~size_t(0))
                {
                    items_[num_items_].beg = temp_beg;
                    items_[num_items_].end = pos;
                    ++num_items_;
                    temp_beg = ~size_t(0); // reset temp_beg
                }
                else
                {
                    // TODO: remove std::string from here
                    std::string what = "invalid input string formatter at pos " + std::to_string(pos) + std::string(__FILE__) + ":" + std::to_string(__LINE__);
                    // throw std::exception(what.c_str());
                    DBG_DIE(what);
                }
            };

            while (beg != end)
            {
                if (*beg == '{')
                {
                    ++beg;
                    if (beg != end)
                    {
                        const auto next_c = *beg;
                        if (next_c != '{')
                        {
                            // in this case, we need to record this pos
                            record_beg();
                            --beg; // go back
                        }
                        else
                        {
                            // in this case, we need to skip these 2 char
                            // beg will ++ later
                        }
                    }
                    else
                    {
                        // { should not be placed at the end
                        // TODO: remove std::string from here
                        std::string what = "invalid input string formatter at pos " + std::to_string(pos) + std::string(__FILE__) + ":" + std::to_string(__LINE__);
                        // throw std::exception(what.c_str());
                        DBG_DIE(what);
                    }
                }
                else if (*beg == '}')
                {
                    ++beg;
                    if (beg != end)
                    {
                        const auto next_c = *beg;
                        if (next_c != '}')
                        {
                            // in this case, we need to record this pos
                            record_end();
                            --beg; // go back
                        }
                        else
                        {
                            // in this case, we need to skip these 2 char
                            // beg will ++ later
                        }
                    }
                    else
                    {
                        // it's ok to place } at the end, we record this pos and go back
                        // in this case, we need to record this pos
                        record_end();
                        --beg; // go back
                    }
                }
                ++pos;
                ++beg;
            }

#if defined(FMT_DEBUG) && FMT_DEBUG == 1
            for (size_t i = 0; i < num_items_; ++i)
            {
                printf("%lld [%lld, %lld]\n", i, items_[i].beg, items_[i].end);
            }
#endif
        }

        template <class... Args>
        inline void format(Args &&...args)
        {
            constexpr size_t num_args = sizeof...(args);
            if (num_items_ != num_args)
            {
                // TODO: remove std::string from here
                std::string what = "wrong number of arguments, expected " + std::to_string(num_items_) + ", got " + std::to_string(num_args);
                // throw std::exception(what.c_str());
                DBG_DIE(what);
            }
            else
            {
                // TODO: need to remove tuple from here
                std::tuple<Args...> t(std::forward<Args>(args)...);
                render_all<0, num_args>(std::integral_constant<size_t, 0>{}, t);
            }
        }
        inline void format()
        {
            if (num_items_ != 0)
            {
                // TODO: remove std::string from here
                // TODO: maybe use a different error handling method
                std::string what = "wrong number of arguments, expected " + std::to_string(num_items_) + ", got 0";
                // throw std::exception(what.c_str());
                DBG_DIE(what);
            }
        }
    };

    template <
        class OStreamT,
        class IStringT,
        size_t Limit = 20>
    constexpr inline formatter<OStreamT, IStringT, Limit> f(OStreamT &ostrem, IStringT &&istring)
    {
        return formatter<OStreamT, IStringT, Limit>(ostrem, std::forward<IStringT>(istring));
    }
}

#endif