1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <android-base/stringprintf.h>
18
19 #include <array>
20 #include <cstdint>
21 #include <optional>
22 #include <string>
23
24 #ifndef __UI_INPUT_NAMEDENUM_H
25 #define __UI_INPUT_NAMEDENUM_H
26
27 namespace android {
28
29 namespace details {
30 template <typename E, E V>
enum_value_name()31 constexpr std::optional<std::string_view> enum_value_name() {
32 // Should look something like (but all on one line):
33 // std::optional<std::string_view>
34 // android::details::enum_value_name()
35 // [E = android::test::TestEnums, V = android::test::TestEnums::ONE]
36 std::string_view view = __PRETTY_FUNCTION__;
37 size_t templateStart = view.rfind("[");
38 size_t templateEnd = view.rfind("]");
39 if (templateStart == std::string::npos || templateEnd == std::string::npos) {
40 return std::nullopt;
41 }
42
43 // Extract the template parameters without the enclosing braces.
44 // Example (cont'd): E = android::test::TestEnums, V = android::test::TestEnums::ONE
45 view = view.substr(templateStart + 1, templateEnd - templateStart - 1);
46 size_t valStart = view.rfind("V = ");
47 if (valStart == std::string::npos) {
48 return std::nullopt;
49 }
50
51 // Example (cont'd): V = android::test::TestEnums::ONE
52 view = view.substr(valStart);
53 size_t nameStart = view.rfind("::");
54 if (nameStart == std::string::npos) {
55 return std::nullopt;
56 }
57
58 // Chop off the initial "::"
59 nameStart += 2;
60 return view.substr(nameStart);
61 }
62
63 template <typename E, typename T, T... I>
generate_enum_values(std::integer_sequence<T,I...> seq)64 constexpr auto generate_enum_values(std::integer_sequence<T, I...> seq) {
65 constexpr size_t count = seq.size();
66
67 std::array<E, count> values{};
68 for (size_t i = 0, v = 0; v < count; ++i) {
69 values[v++] = static_cast<E>(T{0} + i);
70 }
71
72 return values;
73 }
74
75 template <typename E, std::size_t N>
76 inline constexpr auto enum_values =
77 generate_enum_values<E>(std::make_integer_sequence<std::underlying_type_t<E>, N>{});
78
79 template <typename E, std::size_t N, std::size_t... I>
generate_enum_names(std::index_sequence<I...>)80 constexpr auto generate_enum_names(std::index_sequence<I...>) noexcept {
81 return std::array<std::optional<std::string_view>, sizeof...(I)>{
82 {enum_value_name<E, enum_values<E, N>[I]>()...}};
83 }
84
85 template <typename E, std::size_t N>
86 inline constexpr auto enum_names = generate_enum_names<E, N>(std::make_index_sequence<N>{});
87
88 } // namespace details
89
90 class NamedEnum {
91 public:
92 // By default allowed enum value range is 0 ~ 7.
93 template <typename E>
94 static constexpr size_t max = 8;
95
96 template <auto V>
enum_name()97 static constexpr auto enum_name() {
98 using E = decltype(V);
99 return details::enum_value_name<E, V>();
100 }
101
102 template <typename E>
enum_name(E val)103 static constexpr std::optional<std::string_view> enum_name(E val) {
104 auto idx = static_cast<size_t>(val);
105 return idx < max<E> ? details::enum_names<E, max<E>>[idx] : std::nullopt;
106 }
107
108 // Helper function for parsing enum value to string.
109 // Example : enum class TestEnums { ZERO = 0x0 };
110 // NamedEnum::string(TestEnums::ZERO) returns string of "ZERO".
111 // Note the default maximum enum is 8, if the enum ID to be parsed if greater than 8 like 16,
112 // it should be declared to specialized the maximum enum by below:
113 // template <> constexpr size_t NamedEnum::max<TestEnums> = 16;
114 // If the enum class definition is sparse and contains enum values starting from a large value,
115 // Do not specialize it to a large number to avoid performance issues.
116 // The recommended maximum enum number to specialize is 64.
117 template <typename E>
118 static const std::string string(E val, const char* fallbackFormat = "%02d") {
119 std::string result;
120 std::optional<std::string_view> enumString = enum_name(val);
121 result += enumString ? enumString.value() : base::StringPrintf(fallbackFormat, val);
122 return result;
123 }
124 };
125
126 } // namespace android
127
128 #endif // __UI_INPUT_NAMEDENUM_H