GeneralRegistry.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include <unordered_map>
#include <mutex>
#include <deque>

#include "MooseError.h"

template <class Key, class Item, class KeyHash = std::hash<Key>>
class GeneralRegistry
{
public:
  GeneralRegistry(const std::string & name);

  std::size_t size() const;

  std::size_t id(const Key & key) const;

  bool keyExists(const Key & key) const;
  bool idExists(const std::size_t id) const;

  const Item & item(const std::size_t id) const;

protected:
  const Item & itemNonLocking(const std::size_t id) const;

  template <typename CreateItem>
  std::size_t registerItem(const Key & key, CreateItem & create_item);

  const std::string _name;

  std::unordered_map<Key, std::size_t, KeyHash> _key_to_id;
  std::deque<Item> _id_to_item;

  mutable std::mutex _key_to_id_mutex;
  mutable std::mutex _id_to_item_mutex;
};

template <class Key, class Item, class KeyHash>
GeneralRegistry<Key, Item, KeyHash>::GeneralRegistry(const std::string & name) : _name(name)
{
}

template <class Key, class Item, class KeyHash>
std::size_t
GeneralRegistry<Key, Item, KeyHash>::size() const
{
  std::lock_guard<std::mutex> lock(_id_to_item_mutex);
  return _id_to_item.size();
}

template <class Key, class Item, class KeyHash>
std::size_t
GeneralRegistry<Key, Item, KeyHash>::id(const Key & key) const
{
  std::lock_guard<std::mutex> lock(_key_to_id_mutex);
  const auto it = _key_to_id.find(key);
  if (it == _key_to_id.end())
    mooseError(_name, ": Key '", key, "' is not registered");
  return it->second;
}

template <class Key, class Item, class KeyHash>
bool
GeneralRegistry<Key, Item, KeyHash>::keyExists(const Key & key) const
{
  std::lock_guard<std::mutex> lock(_key_to_id_mutex);
  return _key_to_id.count(key);
}

template <class Key, class Item, class KeyHash>
bool
GeneralRegistry<Key, Item, KeyHash>::idExists(const std::size_t id) const
{
  std::lock_guard<std::mutex> lock(_id_to_item_mutex);
  return id < _id_to_item.size();
}

template <class Key, class Item, class KeyHash>
const Item &
GeneralRegistry<Key, Item, KeyHash>::item(const std::size_t id) const
{
  std::lock_guard<std::mutex> lock(_id_to_item_mutex);
  return itemNonLocking(id);
}

template <class Key, class Item, class KeyHash>
const Item &
GeneralRegistry<Key, Item, KeyHash>::itemNonLocking(const std::size_t id) const
{
  if (id >= _id_to_item.size())
    mooseError(_name, ": ID '", id, "' is not registered");
  return _id_to_item[id];
}

template <class Key, class Item, class KeyHash>
template <typename CreateItem>
std::size_t
GeneralRegistry<Key, Item, KeyHash>::registerItem(const Key & key, CreateItem & create_item)
{
  std::lock_guard<std::mutex> lock_key(_key_to_id_mutex);

  // Is it already registered?
  const auto it = _key_to_id.find(key);
  if (it != _key_to_id.end())
    return it->second;

  // It's not registered
  std::lock_guard<std::mutex> lock_id(_id_to_item_mutex);
  const auto id = _id_to_item.size();
  _key_to_id.emplace(key, id);
  _id_to_item.emplace_back(std::move(create_item(id)));
  return id;
}