CbmEnumKeySet.h

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#pragma once
 
#include "CbmTypeTraits.h"
 
#include <array>
#include <cstddef>
#include <limits>
#include <type_traits>
#include <utility>
 
namespace cbm::util
{
  template<auto... KeyList>
  class EnumKeySet {
   public:
    static_assert(have_same_type_v<KeyList...>, "EnumKeySet: the non-type values Keys must have the same type");
 
    using Key_t = std::common_type_t<decltype(KeyList)...>;  
    static_assert(std::is_enum_v<Key_t>, "EnumKeySet: the parameter pack Keys must have an enumerator type");
 
    using Underlying_t = std::underlying_type_t<Key_t>;  

    static constexpr bool CheckKey(Key_t key) { return ((key == KeyList) || ...); }

    template<Key_t Key>
    static constexpr size_t Index()
    {
      static_assert(is_in_sequence_v<Key, KeyList...>,
                    "EnumKeySet::Index<Key>(): passing the Key, which is not defined in the mapping sequence");
      return Index(Key);
    }

    static constexpr size_t Index(Key_t key)
    {
      return static_cast<size_t>(kMapper[static_cast<Underlying_t>(key) - MinKey()]);
    }

    static constexpr Underlying_t MaxKey()
    {
      Underlying_t res{std::numeric_limits<Underlying_t>::min()};
      return ((res = std::max(static_cast<Underlying_t>(KeyList), res)), ...);
    }

    static constexpr Underlying_t MinKey()
    {
      Underlying_t res{std::numeric_limits<Underlying_t>::max()};
      return ((res = std::min(static_cast<Underlying_t>(KeyList), res)), ...);
    }

    static constexpr size_t NofKeys() { return sizeof...(KeyList); }

    static constexpr size_t MapperSize() { return static_cast<size_t>(MaxKey() - MinKey() + 1); }
 
    using KeyContainer_t = std::array<Key_t, NofKeys()>;
 
   private:
    using Container_t = std::array<size_t, MapperSize()>;

    static constexpr auto InitializedKeysArray()
    {
      KeyContainer_t res{};
      size_t idx{0};
      ((res[idx++] = KeyList), ...);
      return res;
    }

    static constexpr auto InitializedMapper()
    {
      Container_t res{};
      // Initialize the array with -1
      for (auto& value : res) {
        value = static_cast<Underlying_t>(-1);
      }
      // Apply the map from Keys
      size_t idx{0};
      ((res[static_cast<Underlying_t>(KeyList) - MinKey()] = idx++), ...);
      return res;
    }
 
    static constexpr Container_t kMapper = InitializedMapper();  
 
   public:
    static constexpr KeyContainer_t kKeys = InitializedKeysArray();
  };
}  // namespace cbm::util