utility.hpp

Go to the documentation of this file.

 
#include <type_traits> /* std::underlying_type */
#include <charconv>    /* std::from_chars() */
#include <cctype>      /* std::isspace() */
#include <string>
 
#include <cstdio>      /* snprintf() */
 
#ifndef _POWERDXX_UTILITY_HPP_
#define _POWERDXX_UTILITY_HPP_
 
namespace utility {
 
template <typename T, size_t Count>
constexpr size_t countof(T (&)[Count]) { return Count; }
 
template <typename... Args>
inline void sprintf(Args...) {
    /* Assert depends on Args so it can only be determined if
     * the function is actually instantiated. */
    static_assert(sizeof...(Args) && false,
                  "Use of sprintf() is unsafe, use sprintf_safe() instead");
}
 
template <size_t Size, typename... Args>
inline int sprintf_safe(char (& dst)[Size], char const * const format,
                   Args const... args) {
    return snprintf(dst, Size, format, args...);
}
 
template <class ET, typename VT = typename std::underlying_type<ET>::type>
constexpr VT to_value(ET const op) {
    return static_cast<VT>(op);
}
 
template <size_t BufSize>
class Formatter {
    private:
    char const * const fmt;
 
    public:
    constexpr Formatter(char const * const fmt) : fmt{fmt} {}
 
    template <typename... ArgTs>
    std::string operator ()(ArgTs const &... args) const {
        char buf[BufSize];
        auto count = sprintf_safe(buf, this->fmt, args...);
        if (count < 0) {
            /* encoding error */
            return {};
        } else if (static_cast<size_t>(count) >= BufSize) {
            /* does not fit into buffer */
            return {buf, BufSize - 1};
        }
        return {buf, static_cast<size_t>(count)};
    }
};
 
namespace literals {
constexpr Formatter<16384> operator "" _fmt(char const * const fmt, size_t const) {
    return {fmt};
}
} /* namespace literals */
 
template <typename T>
class Sum {
    private:
    T value;
 
    public:
    explicit constexpr Sum(T const & value) : value{value} {}
 
    constexpr Sum() : Sum{0} {}
 
    constexpr operator T const &() const {
        return this->value;
    }
 
    constexpr Sum & operator +=(T const & value) {
        this->value += value;
        return *this;
    }
};
 
template <typename T>
class Min {
    private:
    T value;
 
    public:
    explicit constexpr Min(T const & value) : value{value} {}
 
    constexpr operator T const &() const {
        return this->value;
    }
 
    constexpr Min & operator =(T const & value) {
        this->value = this->value <= value ? this->value : value;
        return *this;
    }
};
 
template <typename T>
class Max {
    private:
    T value;
 
    public:
    explicit constexpr Max(T const & value) : value{value} {}
 
    constexpr operator T const &() const {
        return this->value;
    }
 
    constexpr Max & operator =(T const & value) {
        this->value = this->value >= value ? this->value : value;
        return *this;
    }
};
 
struct FromChars {
    char const * it;
 
    char const * const end;
 
    template <typename T>
    [[nodiscard]] bool operator ()(T & dst) {
        if (!this->it) {
            return false;
        }
        auto [p, ec] = std::from_chars(this->it, this->end, dst);
        if (this->it == p) {
            return false;
        }
        for (; p != this->end && std::isspace(*p); ++p);
        this->it = p;
        return true;
    }
 
    operator bool() const {
        return this->it && this->end != this->it && *this->it;
    }
 
    FromChars(char const * const start, char const * const end) :
        it{start}, end{end} {
        for (; this->it != end && std::isspace(*this->it); ++this->it);
    }
 
    template <size_t CountV>
    FromChars(char const (& str)[CountV], bool const terminator = true) :
        FromChars{str, str + CountV - terminator} {}
 
    FromChars(std::string const & str) :
        FromChars{str.data(), str.data() + str.size()} {}
};
 
struct Underlined {
    std::string text;
 
    std::string line;
 
    operator std::string() const {
        return this->text + '\n' + this->line;
    }
};
 
Underlined highlight(std::string const & str, ptrdiff_t const offs,
                     ptrdiff_t const len = 1);
 
} /* namespace utility */
 
#endif /* _POWERDXX_UTILITY_HPP_ */