Waybar/include/util/format.hpp

100 lines
3.1 KiB
C++
Raw Normal View History

2019-09-23 20:25:54 +00:00
#pragma once
#include <fmt/format.h>
#include <glibmm/ustring.h>
2019-09-23 20:25:54 +00:00
class pow_format {
2022-04-06 06:37:19 +00:00
public:
pow_format(long long val, std::string&& unit, bool binary = false)
2024-06-12 21:08:27 +00:00
: val_(val), unit_(unit), binary_(binary) {};
2019-09-23 20:25:54 +00:00
2022-04-06 06:37:19 +00:00
long long val_;
std::string unit_;
bool binary_;
};
2019-09-23 20:25:54 +00:00
namespace fmt {
2022-04-06 06:37:19 +00:00
template <>
struct formatter<pow_format> {
char spec = 0;
int width = 0;
2022-04-06 06:37:19 +00:00
template <typename ParseContext>
constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
auto it = ctx.begin(), end = ctx.end();
if (it != end && *it == ':') ++it;
if (it && (*it == '>' || *it == '<' || *it == '=')) {
spec = *it;
++it;
}
if (it == end || *it == '}') return it;
if ('0' <= *it && *it <= '9') {
// We ignore it for now, but keep it for compatibility with
// existing configs where the format for pow_format'ed numbers was
// 'string' and specifications such as {:>9} were valid.
// The rationale for ignoring it is that the only reason to specify
// an alignment and a with is to get a fixed width bar, and ">" is
// sufficient in this implementation.
2021-06-30 02:29:12 +00:00
#if FMT_VERSION < 80000
2022-04-06 06:37:19 +00:00
width = parse_nonnegative_int(it, end, ctx);
2021-06-30 02:29:12 +00:00
#else
2022-04-06 06:37:19 +00:00
width = detail::parse_nonnegative_int(it, end, -1);
2021-06-30 02:29:12 +00:00
#endif
2022-04-06 06:37:19 +00:00
}
return it;
}
2022-04-06 06:37:19 +00:00
template <class FormatContext>
auto format(const pow_format& s, FormatContext& ctx) -> decltype(ctx.out()) {
const char* units[] = {"", "k", "M", "G", "T", "P", nullptr};
2022-04-06 06:37:19 +00:00
auto base = s.binary_ ? 1024ull : 1000ll;
auto fraction = (double)s.val_;
2022-04-06 06:37:19 +00:00
int pow;
for (pow = 0; units[pow + 1] != nullptr && fraction / base >= 1; ++pow) {
fraction /= base;
}
2022-10-17 07:19:00 +00:00
auto number_width = 5 // coeff in {:.1f} format
+ s.binary_; // potential 4th digit before the decimal point
auto max_width = number_width + 1 // prefix from units array
+ s.binary_ // for the 'i' in GiB.
2022-04-06 06:37:19 +00:00
+ s.unit_.length();
2022-04-06 06:37:19 +00:00
const char* format;
std::string string;
switch (spec) {
case '>':
return fmt::format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
2022-04-06 06:37:19 +00:00
case '<':
return fmt::format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
2022-04-06 06:37:19 +00:00
case '=':
format = "{coefficient:<{number_width}.1f}{padding}{prefix}{unit}";
2022-04-06 06:37:19 +00:00
break;
case 0:
default:
format = "{coefficient:.1f}{prefix}{unit}";
2022-04-06 06:37:19 +00:00
break;
}
return fmt::format_to(
ctx.out(), fmt::runtime(format), fmt::arg("coefficient", fraction),
fmt::arg("number_width", number_width),
2022-04-06 06:37:19 +00:00
fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
fmt::arg("unit", s.unit_),
fmt::arg("padding", pow ? ""
: s.binary_ ? " "
: " "));
}
};
2022-04-06 06:37:19 +00:00
// Glib ustirng support
template <>
struct formatter<Glib::ustring> : formatter<std::string> {
template <typename FormatContext>
auto format(const Glib::ustring& value, FormatContext& ctx) {
return formatter<std::string>::format(static_cast<std::string>(value), ctx);
2022-04-06 06:37:19 +00:00
}
};
} // namespace fmt