fmt_options.hpp

Go to the documentation of this file.

#ifndef BSL_FMT_OPTIONS_HPP
#define BSL_FMT_OPTIONS_HPP

#include "char_type.hpp"
#include "cstr_type.hpp"
#include "cstdint.hpp"
#include "cstring.hpp"
#include "npos.hpp"

// TODO
// - Once Clang/LLVM supports C++20's consteval, we should determine if
//   consteval can be used with this class's constructors, which would
//   ensure that all format strings are parsed at compile-time. We
//   should also add error logic to the parsers as errors can then be
//   detected at compile-time, preventing the possibility of format string
//   errors.
//

namespace bsl
{
    namespace details
    {
        enum class fmt_fsm : bsl::uint32
        {
            fmt_fsm_align = 0U,
            fmt_fsm_sign = 1U,
            fmt_fsm_alternate_form = 2U,
            fmt_fsm_sign_aware = 3U,
            fmt_fsm_width = 4U,
            fmt_fsm_type = 5U,
        };
    }

    enum class fmt_align : bsl::uint32
    {
        fmt_align_default = 0U,
        fmt_align_left = 1U,
        fmt_align_right = 2U,
        fmt_align_center = 3U
    };

    enum class fmt_sign : bsl::uint32
    {
        fmt_sign_neg_only = 0U,
        fmt_sign_pos_neg = 1U,
        fmt_sign_space_for_pos = 3U,
    };

    enum class fmt_type : bsl::uint32
    {
        fmt_type_default = 0U,
        fmt_type_b = 1U,
        fmt_type_c = 2U,
        fmt_type_d = 3U,
        fmt_type_s = 4U,
        fmt_type_x = 5U,
    };

    class fmt_options final
    {
        char_type m_fill{' '};
        fmt_align m_align{};
        fmt_sign m_sign{};
        bool m_alternate_form{};
        bool m_sign_aware{};
        bsl::uintmax m_width{};
        fmt_type m_type{};

    public:
        constexpr fmt_options(cstr_type const f) noexcept    // NOLINT
        {
            details::fmt_fsm fsm{};

            bsl::uintmax idx{};
            bsl::uintmax const len{bsl::builtin_strlen(f)};

            while (idx < len) {
                switch (fsm) {
                    case details::fmt_fsm::fmt_fsm_align: {
                        this->fmt_options_impl_align(f, idx, len);
                        fsm = details::fmt_fsm::fmt_fsm_sign;
                        break;
                    }

                    case details::fmt_fsm::fmt_fsm_sign: {
                        this->fmt_options_impl_sign(f, idx);
                        fsm = details::fmt_fsm::fmt_fsm_alternate_form;
                        break;
                    }

                    case details::fmt_fsm::fmt_fsm_alternate_form: {
                        this->fmt_options_impl_alternate_form(f, idx);
                        fsm = details::fmt_fsm::fmt_fsm_sign_aware;
                        break;
                    }

                    case details::fmt_fsm::fmt_fsm_sign_aware: {
                        this->fmt_options_impl_sign_aware(f, idx);
                        fsm = details::fmt_fsm::fmt_fsm_width;
                        break;
                    }

                    case details::fmt_fsm::fmt_fsm_width: {
                        this->fmt_options_impl_width(f, idx, len);
                        fsm = details::fmt_fsm::fmt_fsm_type;
                        break;
                    }

                    case details::fmt_fsm::fmt_fsm_type: {
                        this->fmt_options_impl_type(f, idx);
                        break;
                    }
                }
            }
        }

        [[nodiscard]] constexpr char_type
        fill() const noexcept
        {
            return m_fill;
        }

        constexpr void
        set_fill(char_type const val) noexcept
        {
            m_fill = val;
        }

        [[nodiscard]] constexpr fmt_align
        align() const noexcept
        {
            return m_align;
        }

        constexpr void
        set_align(fmt_align const val) noexcept
        {
            m_align = val;
        }

        [[nodiscard]] constexpr fmt_sign
        sign() const noexcept
        {
            return m_sign;
        }

        constexpr void
        set_sign(fmt_sign const val) noexcept
        {
            m_sign = val;
        }

        [[nodiscard]] constexpr bool
        alternate_form() const noexcept
        {
            return m_alternate_form;
        }

        constexpr void
        set_alternate_form(bool const val) noexcept
        {
            m_alternate_form = val;
        }

        [[nodiscard]] constexpr bool
        sign_aware() const noexcept
        {
            return m_sign_aware;
        }

        constexpr void
        set_sign_aware(bool const val) noexcept
        {
            m_sign_aware = val;
        }

        [[nodiscard]] constexpr bsl::uintmax
        width() const noexcept
        {
            return m_width;
        }

        constexpr void
        set_width(bsl::uintmax const val) noexcept
        {
            m_width = val;
        }

        [[nodiscard]] constexpr fmt_type
        type() const noexcept
        {
            return m_type;
        }

        constexpr void
        set_type(fmt_type const val) noexcept
        {
            m_type = val;
        }

    private:
        constexpr void
        fmt_options_impl_align(
            cstr_type const f, bsl::uintmax &idx, bsl::uintmax const len) noexcept
        {
            char_type f_fill{' '};
            char_type f_align{};
            bsl::uintmax idx_inc{1U};

            if ((idx + 1U) < len) {
                f_fill = f[idx];
                f_align = f[idx + 1U];
                idx_inc = 2U;
            }
            else {
                f_align = f[idx];
            }

            switch (f_align) {
                case '<': {
                    m_fill = f_fill;
                    m_align = fmt_align::fmt_align_left;
                    idx += idx_inc;
                    break;
                }

                case '>': {
                    m_fill = f_fill;
                    m_align = fmt_align::fmt_align_right;
                    idx += idx_inc;
                    break;
                }

                case '^': {
                    m_fill = f_fill;
                    m_align = fmt_align::fmt_align_center;
                    idx += idx_inc;
                    break;
                }

                default: {
                    break;
                }
            }

            if (fmt_align::fmt_align_default == m_align) {
                switch (f_fill) {
                    case '<': {
                        m_align = fmt_align::fmt_align_left;
                        ++idx;
                        break;
                    }

                    case '>': {
                        m_align = fmt_align::fmt_align_right;
                        ++idx;
                        break;
                    }

                    case '^': {
                        m_align = fmt_align::fmt_align_center;
                        ++idx;
                        break;
                    }

                    default: {
                        break;
                    }
                }
            }
        }

        constexpr void
        fmt_options_impl_sign(cstr_type const f, bsl::uintmax &idx) noexcept
        {
            switch (f[idx]) {
                case '+': {
                    m_sign = fmt_sign::fmt_sign_pos_neg;
                    ++idx;
                    break;
                }

                case '-': {
                    m_sign = fmt_sign::fmt_sign_neg_only;
                    ++idx;
                    break;
                }

                case ' ': {
                    m_sign = fmt_sign::fmt_sign_space_for_pos;
                    ++idx;
                    break;
                }

                default: {
                    break;
                }
            }
        }

        constexpr void
        fmt_options_impl_alternate_form(cstr_type const f, bsl::uintmax &idx) noexcept
        {
            if ('#' == f[idx]) {
                m_alternate_form = true;
                ++idx;
            }
        }

        constexpr void
        fmt_options_impl_sign_aware(cstr_type const f, bsl::uintmax &idx) noexcept
        {
            if ('0' == f[idx]) {
                m_sign_aware = true;
                ++idx;
            }
        }

        constexpr void
        fmt_options_impl_width(
            cstr_type const f, bsl::uintmax &idx, bsl::uintmax const len) noexcept
        {
            constexpr bsl::uintmax max_num_digits{3U};

            for (bsl::uintmax i{}; (i < max_num_digits) && (idx < len); ++i) {
                char_type const digit{f[idx]};

                if ((digit >= '0') && (digit <= '9')) {
                    m_width *= 10U;
                    m_width += static_cast<bsl::uintmax>(digit);
                    m_width -= static_cast<bsl::uintmax>('0');
                    ++idx;
                }
            }
        }

        constexpr void
        fmt_options_impl_type(cstr_type const f, bsl::uintmax &idx) noexcept
        {
            switch (f[idx]) {
                case 'b':
                case 'B': {
                    m_type = fmt_type::fmt_type_b;
                    break;
                }

                case 'c': {
                    m_type = fmt_type::fmt_type_c;
                    break;
                }

                case 'd': {
                    m_type = fmt_type::fmt_type_d;
                    break;
                }

                case 's': {
                    m_type = fmt_type::fmt_type_s;
                    break;
                }

                case 'x':
                case 'X': {
                    m_type = fmt_type::fmt_type_x;
                    break;
                }

                default: {
                    break;
                }
            }

            idx = bsl::npos;
        }
    };

    constexpr fmt_options nullops{""};
    constexpr fmt_options ptrops{
        (sizeof(bsl::uintptr) == sizeof(bsl::uint32)) ? "#010x" : "#018x"};    // NOLINT
}

#endif