dolphin/Source/Core/Common/EnumFormatter.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

102 lines
2.8 KiB
C
Raw Normal View History

2021-02-10 20:46:32 +00:00
// Copyright 2021 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
2021-02-10 20:46:32 +00:00
#pragma once
2021-04-25 02:26:27 +00:00
#include "Common/EnumMap.h"
2021-02-10 20:46:32 +00:00
#include <fmt/format.h>
#include <type_traits>
/*
* Helper for using enums with fmt.
*
* Usage example:
*
* enum class Foo
* {
* A = 0,
* B = 1,
* C = 2,
* };
*
* template <>
* struct fmt::formatter<Foo> : EnumFormatter<Foo::C>
* {
* formatter() : EnumFormatter({"A", "B", "C"}) {}
* };
*
* enum class Bar
* {
* D = 0,
* E = 1,
* F = 3,
* };
*
* template <>
* struct fmt::formatter<Bar> : EnumFormatter<Bar::F>
* {
* // using std::array here fails due to nullptr not being const char*, at least in MSVC
* // (but only when a field is used; directly in the constructor is OK)
* static constexpr array_type names = {"D", "E", nullptr, "F"};
* formatter() : EnumFormatter(names) {}
* };
*/
2021-04-25 02:26:27 +00:00
template <auto last_member, typename = decltype(last_member)>
2021-02-10 20:46:32 +00:00
class EnumFormatter
{
2021-04-25 02:26:27 +00:00
// The second template argument is needed to avoid compile errors from ambiguity with multiple
// enums with the same number of members in GCC prior to 8. See https://godbolt.org/z/xcKaW1seW
// and https://godbolt.org/z/hz7Yqq1P5
using T = decltype(last_member);
static_assert(std::is_enum_v<T>);
2021-02-10 20:46:32 +00:00
public:
constexpr auto parse(fmt::format_parse_context& ctx)
{
auto it = ctx.begin(), end = ctx.end();
// 'u' for user display, 's' for shader generation, 'n' for name only
if (it != end && (*it == 'u' || *it == 's' || *it == 'n'))
format_type = *it++;
2021-02-10 20:46:32 +00:00
return it;
}
template <typename FormatContext>
auto format(const T& e, FormatContext& ctx)
{
const auto value_s = static_cast<std::underlying_type_t<T>>(e); // Possibly signed
const auto value_u = static_cast<std::make_unsigned_t<T>>(value_s); // Always unsigned
2021-04-25 02:26:27 +00:00
const bool has_name = m_names.InBounds(e) && m_names[e] != nullptr;
2021-02-10 20:46:32 +00:00
switch (format_type)
2021-02-10 20:46:32 +00:00
{
default:
case 'u':
if (has_name)
2021-04-25 02:26:27 +00:00
return fmt::format_to(ctx.out(), "{} ({})", m_names[e], value_s);
2021-02-10 20:46:32 +00:00
else
return fmt::format_to(ctx.out(), "Invalid ({})", value_s);
case 's':
if (has_name)
2021-04-25 02:26:27 +00:00
return fmt::format_to(ctx.out(), "{:#x}u /* {} */", value_u, m_names[e]);
2021-02-10 20:46:32 +00:00
else
return fmt::format_to(ctx.out(), "{:#x}u /* Invalid */", value_u);
case 'n':
if (has_name)
return fmt::format_to(ctx.out(), "{}", m_names[e]);
else
return fmt::format_to(ctx.out(), "Invalid ({})", value_s);
2021-02-10 20:46:32 +00:00
}
}
protected:
// This is needed because std::array deduces incorrectly if nullptr is included in the list
2021-04-25 02:26:27 +00:00
using array_type = Common::EnumMap<const char*, last_member>;
2021-02-10 20:46:32 +00:00
constexpr explicit EnumFormatter(const array_type names) : m_names(std::move(names)) {}
private:
const array_type m_names;
char format_type = 'u';
2021-02-10 20:46:32 +00:00
};