Made everything consteval

Author: liuzicheng1987

include/rfl/Literal.hpp

@@ -47,12 +47,12 @@ class Literal {
   /// Copy constructor - constructs a Literal from another literal with the same
   /// fields.
   /// @param _other The literal to copy from
-  Literal(const Literal<fields_...>& _other) = default;
+  constexpr Literal(const Literal<fields_...>& _other) = default;
 
   /// Move constructor - constructs a Literal from another literal with the same
   /// fields.
   /// @param _other The literal to move from
-  Literal(Literal<fields_...>&& _other) noexcept = default;
+  constexpr Literal(Literal<fields_...>&& _other) noexcept = default;
 
   /// Constructs a Literal from a string value.
   /// @param _str The string representing one of the literal's allowed values
@@ -61,7 +61,7 @@ class Literal {
   Literal(const std::string& _str) : value_(find_value(_str).value()) {}
 
   /// Default constructor - initializes to the first value (index 0).
-  Literal() : value_(0) {}
+  constexpr Literal() : value_(0) {}
 
   /// Destructor.
   ~Literal() = default;
@@ -87,7 +87,7 @@ class Literal {
   /// @tparam _value The index of the value (must be less than num_fields_)
   /// @return A Literal representing the value at the specified index
   template <ValueType _value>
-  static Literal<fields_...> from_value() {
+  static constexpr Literal<fields_...> from_value() {
     static_assert(_value < num_fields_,
                   "Value cannot exceed number of fields.");
     return Literal<fields_...>(_value);

include/rfl/internal/concat_literals.hpp

@@ -14,31 +14,31 @@ struct LiteralWrapper {
 };
 
 template <StringLiteral... _names>
-auto wrap_literal(const Literal<_names...>& _literal) {
+consteval auto wrap_literal(const Literal<_names...>& _literal) {
   return LiteralWrapper<_names...>{_literal};
 }
 
 template <StringLiteral... _names1, StringLiteral... _names2>
-auto operator+(const LiteralWrapper<_names1...>&,
-               const LiteralWrapper<_names2...>&) {
+consteval auto operator+(const LiteralWrapper<_names1...>&,
+                         const LiteralWrapper<_names2...>&) {
   return LiteralWrapper<_names1..., _names2...>{
-      rfl::Literal<_names1..., _names2...>::template from_value<0>()};
+      rfl::Literal<_names1..., _names2...>()};
 }
 
 template <class Head, class... Tail>
-auto concat_literals(const Head& _head, const Tail&... _tail) {
+consteval auto concat_literals(const Head& _head, const Tail&... _tail) {
   return (wrap_literal(_head) + ... + wrap_literal(_tail)).literal_;
 }
 
 // Special case - every literal contains exactly one value.
 template <StringLiteral _head, StringLiteral... _tail>
-auto concat_literals(const rfl::Literal<_head>&,
-                     const rfl::Literal<_tail>&...) {
-  return rfl::Literal<_head, _tail...>::template from_value<0>();
+consteval auto concat_literals(const rfl::Literal<_head>&,
+                               const rfl::Literal<_tail>&...) {
+  return rfl::Literal<_head, _tail...>();
 }
 
 // Special case - no literals.
-inline auto concat_literals() { return rfl::Literal<>(); }
+consteval inline auto concat_literals() { return rfl::Literal<>(); }
 
 }  // namespace rfl::internal
 

include/rfl/internal/cpp26/get_field_names.hpp

@@ -17,10 +17,10 @@
 namespace rfl::internal::cpp26 {
 
 template <class T>
-auto get_field_names();
+consteval auto get_field_names();
 
 template <class T, class FieldName>
-auto get_field_names_impl() {
+consteval auto get_field_names_impl() {
   using Type = std::remove_cvref_t<std::remove_pointer_t<T>>;
   if constexpr (is_rename_v<Type>) {
     using Name = typename Type::Name;
@@ -33,7 +33,7 @@ auto get_field_names_impl() {
 }
 
 template <class T>
-auto get_field_names() {
+consteval auto get_field_names() {
   using Type = std::remove_cvref_t<T>;
   if constexpr (std::is_pointer_v<Type>) {
     return get_field_names<std::remove_pointer_t<Type>>();