CbmEnumMap.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 <boost/serialization/array.hpp>
#include <boost/serialization/base_object.hpp>
 
#include <algorithm>
#include <array>
#include <initializer_list>
#include <utility>
 
namespace cbm::util
{
  template<class T, class KeySet, class Base = std::array<T, KeySet::NofKeys()>>
  class EnumMap : private Base {
   public:
    using Base_t   = Base;
    using KeySet_t = KeySet;
    using Value_t  = T;
    using Key_t    = typename KeySet::Key_t;
 

    constexpr EnumMap() : Base(){};

    constexpr EnumMap(std::initializer_list<std::pair<Key_t, Value_t>> init) : Base()
    {
      for (const auto& entry : init) {
        if (KeySet::CheckKey(entry.first)) {
          (*this)[entry.first] = entry.second;
        }
        else {
          throw std::runtime_error("cbm::EnumMap: invalid key passed to the initializer list");
        }
      }
    }

    constexpr T& operator[](Key_t key) { return Base::operator[](KeySet::Index(key)); }

    constexpr const T& operator[](Key_t key) const { return Base::operator[](KeySet::Index(key)); }

    constexpr const T& operator[](size_t index) const { return Base::operator[](index); }

    constexpr T& at(Key_t key)
    {
      if (!KeySet::CheckKey(key)) {
        throw std::out_of_range("EnumMap: key out of range");
      }
      return operator[](key);
    }

    constexpr const T& at(Key_t key) const
    {
      if (!KeySet::CheckKey(key)) {
        throw std::out_of_range("EnumMap: key out of range");
      }
      return operator[](key);
    }

    constexpr bool CheckKey(Key_t key) const { return KeySet::CheckKey(key); }

    template<Key_t key>
    constexpr bool CheckKey() const
    {
      return KeySet::CheckKey(key);
    }
 
    using Base::back;
    using Base::begin;
    using Base::cbegin;
    using Base::cend;
    using Base::crbegin;
    using Base::crend;
    using Base::empty;  // true, if the size of the map is zero (to be consistent with STL containers)
    using Base::end;
    using Base::front;
    using Base::rbegin;
    using Base::rend;
    using Base::size;
    using Base::swap;
 
   private:
    friend class boost::serialization::access;
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& boost::serialization::base_object<Base>(*this);
    }
  };
}  // namespace cbm::util