AEnumerate.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
//
// Created by alex2 on 6/24/2021.
//
 
#pragma once
 
#include <array>
#include <type_traits>
#include <AUI/Common/AString.h>
#include <AUI/Common/AMap.h>
#include <AUI/Traits/types.h>
#include <fmt/format.h>
 
 
//NOLINTBEGIN(modernize-*,cppcoreguidelines-macro-usage,bugprone-macro-parentheses)
 
namespace aui::enumerate::basic {
   template<typename enum_t>
   struct ValueToName {
       template<enum_t value>
       static AString name() {
#if AUI_COMPILER_MSVC
           AString s = __FUNCSIG__;
       AString::iterator end = s.begin() + s.rfind('>');
       AString::iterator begin = (std::find_if(std::make_reverse_iterator(end), s.rend(), [](wchar_t c) {
           return c == ':' || c == '<';
       })).base();
 
       AString result(begin, end);
#else
           AString s = __PRETTY_FUNCTION__;
#if AUI_COMPILER_CLANG
           auto end = s.rfind(']');
#else
           auto end = s.rfind(';');
#endif
           size_t begin = s.rfind("value =", end);
           if (begin == AString::NPOS) {
               begin = s.rfind('[', end) + 1;
           } else {
               begin += 8;
           }
           AString result = {s.begin() + begin, s.begin() + end};
 
 
           for (size_t p; (p = result.find("::")) != AString::NPOS;) {
               result = result.substr(p + 2);
           }
 
#endif
           return result;
       }
   };
};
 
namespace aui::enumerate {
   template<typename enum_t>
   struct ValueToName: basic::ValueToName<enum_t> {};
}
 

template<typename enum_t>
class AEnumerate {
private:
   struct enum_less {
       constexpr bool operator()(enum_t l, enum_t r) const {
           return static_cast<std::underlying_type_t<enum_t>>(l) < static_cast<std::underlying_type_t<enum_t>>(r);
       }
   };
 
public:
   static_assert(std::is_enum_v<enum_t>, "AEnumerate accepts only enums");
 
   template<enum_t... values>
   struct Values {
 
   };

   template<enum_t value>
   static AString valueName() {
       return aui::enumerate::ValueToName<enum_t>::template name<value>();
   }

   static const AMap<AString, enum_t>& nameToValueMap();

   static const AMap<enum_t, AString, enum_less>& valueToNameMap();

   static enum_t byName(const AString& name) {
       if (auto c = nameToValueMap().contains(name)) {
           return c->second;
       }
       if (auto c = nameToValueMap().contains(name.uppercase())) {
           return c->second;
       }
       throw AException("unknown enum value: \"{}\""_format(name));
   }

   static const AString& toName(enum_t value) {
       if (auto c = valueToNameMap().contains(value)) {
           return c->second;
       }
       throw AException("unknown enum value: \"(int){}\""_format((std::underlying_type_t<enum_t>)value));
   }
 
private:
   template<enum_t... values>
   static const AMap<AString, enum_t>& mapValueByName(const Values<values...>& v) {
       static AMap<AString, enum_t> map = {
           {valueName<values>(), values}...
       };
       return map;
   }
   template<enum_t... values>
   static const AMap<enum_t, AString, enum_less>& mapNameByValue(const Values<values...>& v) {
       static AMap<enum_t, AString, enum_less> map = {
           {values, valueName<values>() }...
       };
       return map;
   }
};
 
template<typename enum_t>
struct AEnumerateAllValues;
 
template<typename enum_t>
const AMap<AString, enum_t>& AEnumerate<enum_t>::nameToValueMap() {
   static_assert(aui::is_complete<AEnumerateAllValues<enum_t>>, "AUI_ENUM_VALUES is not defined for this enum type");
   auto v = AEnumerateAllValues<enum_t>::get();
 
   return mapValueByName(v);
}
 
namespace aui::enumerate {
   template<typename enum_t> requires aui::is_complete<AEnumerateAllValues<enum_t>>
   inline constexpr auto ALL_VALUES = []<auto... values>(typename AEnumerate<enum_t>::template Values<values...>) {
       constexpr enum_t ITEMS[] = {values...};
       return std::to_array(ITEMS);
   }(AEnumerateAllValues<enum_t>::get());
}
 
template<typename enum_t>
const AMap<enum_t, AString, typename AEnumerate<enum_t>::enum_less>& AEnumerate<enum_t>::valueToNameMap() {
   static_assert(aui::is_complete<AEnumerateAllValues<enum_t>>, "AUI_ENUM_VALUES is not defined for this enum type");
   auto v = AEnumerateAllValues<enum_t>::get();
 
   return mapNameByValue(v);
}

#define AUI_ENUM_VALUES(enum_t, ...) template<> \
struct AEnumerateAllValues<enum_t>{         \
   static inline constexpr AEnumerate<enum_t>::Values<__VA_ARGS__> get() {return {}; } \
};                                         \
namespace std { inline AString to_wstring(enum_t v) { return AEnumerate<enum_t>::valueToNameMap().optional(v).valueOr("<unknown enum value {}>"_format(int(v))); } } \
inline std::ostream& operator<<(std::ostream& o, enum_t v) { return o << std::to_wstring(v); }
 
template <typename T> struct fmt::formatter<T, char, std::enable_if_t<aui::is_complete<AEnumerateAllValues<T>>>>: formatter<std::string> {
   // parse is inherited from formatter<string_view>.
   template <typename FormatContext>
   auto format(T c, FormatContext& ctx) const {
       return formatter<string_view>::format(AEnumerate<T>::valueToNameMap()[c].toStdString(), ctx);
   }
};

#define AUI_ENUM_FLAG(name) enum class name: int; \
                           constexpr inline name operator|(name a, name b) {return static_cast<name>(static_cast<int>(a) | static_cast<int>(b));} \
                           constexpr inline name operator&(name a, name b) {return static_cast<name>(static_cast<int>(a) & static_cast<int>(b));} \
                           constexpr inline name operator^(name a, name b) {return static_cast<name>(static_cast<int>(a) ^ static_cast<int>(b));} \
                           constexpr inline name operator|=(name& a, name b) {return a = static_cast<name>(static_cast<int>(a) | static_cast<int>(b));} \
                           constexpr inline name operator&=(name& a, name b) {return a = static_cast<name>(static_cast<int>(a) & static_cast<int>(b));} \
                           constexpr inline name operator^=(name& a, name b) {return a = static_cast<name>(static_cast<int>(a) ^ static_cast<int>(b));} \
                           constexpr inline name operator~(const name& a) {return static_cast<name>(~static_cast<int>(a));} \
                           constexpr inline bool operator!(const name& a) {return a == static_cast<name>(0);}                                     \
                                                                  \
                           constexpr inline bool operator&&(const name& a, bool v) {return static_cast<int>(a) && v;}                                     \
                           constexpr inline bool operator||(const name& a, bool v) {return static_cast<int>(a) || v;}                                     \
\
                           enum class name: int
 
#define AUI_ENUM_INT(name) enum class name: int; \
                          constexpr inline bool operator<(name a, name b) {return static_cast<int>(a) < static_cast<int>(b);} \
                          constexpr inline bool operator>(name a, name b) {return static_cast<int>(a) > static_cast<int>(b);} \
                          enum class name: int
 
//NOLINTEND(modernize-*,cppcoreguidelines-macro-usage,bugprone-macro-parentheses)

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.