formatter.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_FORMAT_FORMATTER_H
#define FENNEC_FORMAT_FORMATTER_H
 
#include <fennec/format/charconv.h>
#include <fennec/string/string.h>
#include <fennec/format/format_arg.h>
 
namespace fennec
{
 
// base template =======================================================================================================
 
template<typename T>
struct formatter {
    string operator()(const format_arg&, const T&) {
        static_assert(false, "Formatter not implemented for the provided type.");
        return string("");
    }
};
 
 
// strings =============================================================================================================
 
template<size_t N>
struct formatter<char[N]> {
    string operator()(const format_arg&, const char (&str)[N]) {
        return string(str);
    }
};
 
template<size_t N>
struct formatter<const char[N]> {
    string operator()(const format_arg&, const char (&str)[N]) {
        return string(str);
    }
};
 
template<>
struct formatter<cstring> {
    string operator()(const format_arg&, const cstring& str) {
        return str;
    }
};
 
template<>
struct formatter<string> {
    string operator()(const format_arg&, const string& str) {
        return str;
    }
};
 
 
// decimal types =======================================================================================================
 
template<typename IntT> requires(is_integral_v<IntT> and not is_bool_v<IntT>)
struct formatter<IntT> {
    string operator()(const format_arg& fmt, IntT x) {
        char digits[128] = {};
        auto chk = fennec::to_chars(digits, digits + sizeof(digits), fennec::abs(x), fmt.base);
        assertf(chk != nullptr, "fennec::format error, to_chars error");
        size_t len = chk - digits;
 
        // handle uppercase
        if (fmt.upper) {
            for (auto& digit : digits) {
                if (digit == 0) {
                    break;
                }
                digit = toupper(digit);
            }
        }
 
        const bool   has_sign = (x < 0 or fmt.sign != '-');
        const bool   zero     = fmt.fill == '0';
        const size_t prefix = fmt.alt ? (fmt.type == 'd' ? 0 : 2 - (fmt.type == 'o')) : 0;
        const size_t sgnlen = len + (zero ? has_sign + prefix : 0);
        const size_t explen = fennec::max(sgnlen, fmt.width) + (zero ? 0 : has_sign + prefix);
        const size_t fill   = fmt.width > sgnlen ? fmt.width - sgnlen : 0;
        size_t sign = 0;
 
        string res = string(explen);
 
        if (fill > 0) {
            switch (fmt.align) {
                case '<':
                    memcpy(res.data() + has_sign + prefix, digits, len);
                    memset(res.data() + has_sign + prefix + len, fmt.fill == '0' ? ' ' : fmt.fill, fill);
                    break;
                case '>': case '\0':
                    memcpy(res.data() + explen - len, digits, len);
                    sign = fmt.fill == '0' ? 0 : explen - len - 1 - prefix;
                    memset(res.data(), fmt.fill, explen - len);
                    break;
                case '^':
                    size_t bef = fill / 2 + has_sign + prefix;
                    size_t aft = explen - bef;
                    memcpy(res.data() + bef, digits, len);
                    sign = fmt.fill == '0' ? 0 : bef - 1 - prefix;
                    memset(res.data(), fmt.fill, bef);
                    memset(res.data() + bef + len, fmt.fill == '0' ? ' ' : fmt.fill, aft);
                    break;
 
 
            }
        } else {
            memcpy(res.data() + has_sign + prefix, digits, len);
        }
 
        if (has_sign) {
            res[sign] = (x < 0) ? '-' : fmt.sign;
        }
 
        if (prefix) {
            res[sign + has_sign] = '0';
            if (fmt.type != 'o') {
                res[sign + has_sign + 1] = fmt.type;
            }
        }
 
        return res;
    }
};
 
template<typename BoolT> requires(is_bool_v<BoolT>)
struct formatter<BoolT> {
    string operator()(const format_arg& fmt, BoolT x) {
        if (fmt.type == 's' or fmt.type == '\0') {
            return x ? string("true") : string("false");
        }
 
        return formatter<uint8_t>{}(fmt, static_cast<uint8_t>(x));
    }
};
 
template<typename FloatT> requires(is_floating_point_v<FloatT>)
struct formatter<FloatT> {
    string operator()(const format_arg& fmt, FloatT x) {
 
        // nan & inf cases
        if (fennec::isnan(x)) {
            return string("nan");
        }
        if (fennec::isinf(x)) {
            return string("inf");
        }
 
 
        char digits[128] = {};
        auto chk = fennec::to_chars(digits, digits + sizeof(digits), fennec::abs(x), fmt.type, fmt.precision);
        assertf(chk != nullptr, "fennec::format error, to_chars error");
        size_t len = chk - digits;
 
        // handle uppercase
        if (fmt.upper) {
            for (auto& digit : digits) {
                if (digit == 0) {
                    break;
                }
                digit = toupper(digit);
            }
        }
 
        const bool   has_sign = (x < 0 or fmt.sign != '-');
        const bool   zero     = fmt.fill == '0';
        const size_t prefix = fmt.alt ? 2 : 0;
        const size_t sgnlen = len + (zero ? has_sign + prefix : 0);
        const size_t explen = fennec::max(sgnlen, fmt.width) + (zero ? 0 : has_sign + prefix);
        const size_t fill   = fmt.width > sgnlen ? fmt.width - sgnlen : 0;
        size_t sign = 0;
 
        string res = string(explen);
 
        if (fill > 0) {
            switch (fmt.align) {
                case '<':
                    memcpy(res.data() + has_sign + prefix, digits, len);
                    memset(res.data() + has_sign + prefix + len, fmt.fill == '0' ? ' ' : fmt.fill, fill);
                    break;
                case '>': case '\0':
                    memcpy(res.data() + explen - len, digits, len);
                    sign = fmt.fill == '0' ? 0 : explen - len - 1 - prefix;
                    memset(res.data(), fmt.fill, explen - len);
                    break;
                case '^':
                    size_t bef = fill / 2 + has_sign + prefix;
                    size_t aft = explen - bef;
                    memcpy(res.data() + bef, digits, len);
                    sign = fmt.fill == '0' ? 0 : bef - 1 - prefix;
                    memset(res.data(), fmt.fill, bef);
                    memset(res.data() + bef + len, fmt.fill == '0' ? ' ' : fmt.fill, aft);
                    break;
 
 
            }
        } else {
            memcpy(res.data() + has_sign + prefix, digits, len);
        }
 
        if (has_sign) {
            res[sign] = (x < 0) ? '-' : fmt.sign;
        }
 
        if (prefix) {
            res[sign + has_sign] = '0';
            res[sign + has_sign + 1] = fmt.type + ('x' - 'a');
        }
 
        return res;
    }
 
 
};
 
}
 
#endif // FENNEC_FORMAT_FORMATTER_H