Merge branch 'add-min-max-to-meta_enum' into '2024-patches'

Add min_value_of /  max_value_of / to_underlying to meta enum

See merge request lhcb/LHCb!4613

Kernel/LHCbKernel/include/Kernel/meta_enum.h

@@ -27,6 +27,7 @@ SOFTWARE. */
 #pragma once
 
 #include "GaudiKernel/StatusCode.h"
+#include <algorithm>
 #include <iomanip>
 #include <optional>
 #include <string_view>
@@ -207,12 +208,29 @@ namespace meta_enum_internal {
     for ( SizeType i = 0; i != msize; ++i ) { a[i] = m[i].value; }                                                     \
     return a;                                                                                                          \
   }                                                                                                                    \
+  template <typename E>                                                                                                \
+  constexpr E max_value_of();                                                                                          \
+  template <>                                                                                                          \
+  constexpr Type max_value_of<Type>() {                                                                                \
+    constexpr auto r = members_of<Type>();                                                                             \
+    static_assert( !r.empty() );                                                                                       \
+    return *std::max_element( r.begin(), r.end() );                                                                    \
+  }                                                                                                                    \
+  template <typename E>                                                                                                \
+  constexpr E min_value_of();                                                                                          \
+  template <>                                                                                                          \
+  constexpr Type min_value_of<Type>() {                                                                                \
+    constexpr auto r = members_of<Type>();                                                                             \
+    static_assert( !r.empty() );                                                                                       \
+    return *std::min_element( r.begin(), r.end() );                                                                    \
+  }                                                                                                                    \
   inline std::string toString( const Type e ) {                                                                        \
     for ( const auto& member : Type##_meta.members ) {                                                                 \
       if ( member.value == e ) return std::string{member.name};                                                        \
     }                                                                                                                  \
     return std::string{Type##_meta.defaultString};                                                                     \
   }                                                                                                                    \
+  constexpr auto       to_underlying( Type e ) { return static_cast<std::underlying_type_t<Type>>( e ); }              \
   inline std::ostream& toStream( const Type e, std::ostream& os ) { return os << std::quoted( toString( e ), '\'' ); } \
   inline std::ostream& operator<<( std::ostream& s, const Type e ) { return toStream( e, s ); }                        \
   inline StatusCode    parse( Type& e, std::string_view name ) {                                                       \

Kernel/LHCbKernel/tests/src/test_meta_enum.cpp

@@ -23,10 +23,6 @@ meta_enum_class( MyEnum, int, Unknown = 0, Case1, Case2, Case3, CaseLarge = 1000
     meta_enum_class_with_unknown( MyEnum2, int, Case2, Unknown = 0, Case1, Case2, Case3, CaseLarge = 10000 )
 
         BOOST_AUTO_TEST_CASE( test_meta_enum_printing ) {
-  BOOST_CHECK( static_cast<int>( MyEnum::Unknown ) == 0 );
-  BOOST_CHECK( static_cast<int>( MyEnum::Case1 ) == 1 );
-  BOOST_CHECK( static_cast<int>( MyEnum::Case3 ) == 3 );
-  BOOST_CHECK( static_cast<int>( MyEnum::CaseLarge ) == 10000 );
   std::ostringstream output;
   output << MyEnum::Case1 << " " << MyEnum::CaseLarge;
   BOOST_CHECK( output.str() == "'Case1' 'CaseLarge'" );
@@ -37,13 +33,25 @@ meta_enum_class( MyEnum, int, Unknown = 0, Case1, Case2, Case3, CaseLarge = 1000
   BOOST_CHECK( value == MyEnum::Unknown && sc == StatusCode::FAILURE );
   MyEnum2 value2;
   sc = parse( value2, "non existing" );
-  std::cout << value2 << "" << static_cast<int>( MyEnum2_meta.defaultValue ) << std::endl;
+  std::cout << value2 << "" << to_underlying( MyEnum2_meta.defaultValue ) << std::endl;
   BOOST_CHECK( value2 == MyEnum2::Case2 && sc == StatusCode::FAILURE );
 
-  for ( MyEnum i : members_of<MyEnum>() ) std::cout << i << " = " << static_cast<int>( i ) << '\n';
+  for ( MyEnum i : members_of<MyEnum>() ) std::cout << i << " = " << to_underlying( i ) << '\n';
 }
 
 BOOST_AUTO_TEST_CASE( test_meta_enum_property ) {
   // make sure we can define a property:
   Gaudi::Property<MyEnum2> prop{"hello", MyEnum2::Case3};
 }
+
+BOOST_AUTO_TEST_CASE( test_meta_enum_min_max ) {
+  BOOST_CHECK_EQUAL( min_value_of<MyEnum>(), MyEnum::Unknown );
+  BOOST_CHECK_EQUAL( max_value_of<MyEnum>(), MyEnum::CaseLarge );
+}
+
+BOOST_AUTO_TEST_CASE( test_meta_enum_to_underlying ) {
+  BOOST_CHECK_EQUAL( to_underlying( MyEnum::Unknown ), 0 );
+  BOOST_CHECK_EQUAL( to_underlying( MyEnum::Case1 ), 1 );
+  BOOST_CHECK_EQUAL( to_underlying( MyEnum::Case3 ), 3 );
+  BOOST_CHECK_EQUAL( to_underlying( MyEnum::CaseLarge ), 10000 );
+}