general_data_storage.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2019 - 2024 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_algorithms_general_data_storage_h
#define dealii_algorithms_general_data_storage_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
 
#include <boost/core/demangle.hpp>
 
#include <algorithm>
#include <any>
#include <map>
#include <string>
#include <typeinfo>
 
DEAL_II_NAMESPACE_OPEN
 
 
class GeneralDataStorage : public Subscriptor
{
public:
  GeneralDataStorage() = default;
 
  GeneralDataStorage(const GeneralDataStorage &) = default;
 
  GeneralDataStorage(GeneralDataStorage &&) = default;
 
  std::size_t
  size() const;
 
  void
  merge(const GeneralDataStorage &other_data);
 
  template <class Stream>
  void
  print_info(Stream &stream);
 
  void
  reset();
 
  template <typename Type>
  void
  add_unique_copy(const std::string &name, const Type &entry);
 
  template <typename Type>
  void
  add_or_overwrite_copy(const std::string &name, const Type &entry);
 
  template <typename Type>
  void
  add_unique_reference(const std::string &name, Type &entry);
 
  template <typename Type>
  void
  add_or_overwrite_reference(const std::string &name, Type &entry);
 
  template <typename Type, typename Arg, typename... Args>
  Type &
  get_or_add_object_with_name(const std::string &name,
                              Arg               &argument,
                              Args &...arguments);
 
  template <typename Type, typename Arg>
  Type &
  get_or_add_object_with_name(const std::string &name, Arg &argument);
 
  template <typename Type, typename Arg, typename... Args>
  Type &
  get_or_add_object_with_name(const std::string &name,
                              Arg              &&argument,
                              Args &&...arguments);
 
  template <typename Type, typename Arg>
  Type &
  get_or_add_object_with_name(const std::string &name, Arg &&argument);
 
  template <typename Type>
  Type &
  get_or_add_object_with_name(const std::string &name);
 
  template <typename Type>
  Type &
  get_object_with_name(const std::string &name);
 
  template <typename Type>
  const Type &
  get_object_with_name(const std::string &name) const;
 
  bool
  stores_object_with_name(const std::string &name) const;
 
  void
  remove_object_with_name(const std::string &name);
 
  DeclException1(ExcNameNotFound,
                 std::string,
                 << "No entry with the name " << arg1 << " exists.");
 
  DeclException1(ExcNameHasBeenFound,
                 std::string,
                 << "An entry with the name " << arg1 << " already exists.");
 
  DeclException3(ExcTypeMismatch,
                 std::string,
                 const char *,
                 const char *,
                 << "The stored type for entry with name \"" << arg1 << "\" is "
                 << arg2 << " but you requested type " << arg3 << '.');
 
private:
  std::map<std::string, std::any> any_data;
};
 
 
/*----------------- Inline and template methods -----------------*/
 
 
#ifndef DOXYGEN
 
 
template <class Stream>
void
GeneralDataStorage::print_info(Stream &os)
{
  for (const auto &it : any_data)
    {
      os << it.first << '\t' << '\t'
         << boost::core::demangle(it.second.type().name()) << std::endl;
    }
}
 
 
template <typename Type>
void
GeneralDataStorage::add_unique_copy(const std::string &name, const Type &entry)
{
  AssertThrow(!stores_object_with_name(name), ExcNameHasBeenFound(name));
  add_or_overwrite_copy(name, entry);
}
 
 
template <typename Type>
void
GeneralDataStorage::add_or_overwrite_copy(const std::string &name,
                                          const Type        &entry)
{
  any_data[name] = entry;
}
 
 
template <typename Type>
void
GeneralDataStorage::add_unique_reference(const std::string &name, Type &entry)
{
  AssertThrow(!stores_object_with_name(name), ExcNameHasBeenFound(name));
  add_or_overwrite_reference(name, entry);
}
 
 
template <typename Type>
void
GeneralDataStorage::add_or_overwrite_reference(const std::string &name,
                                               Type              &entry)
{
  Type *ptr      = &entry;
  any_data[name] = ptr;
}
 
 
template <typename Type>
Type &
GeneralDataStorage::get_object_with_name(const std::string &name)
{
  AssertThrow(stores_object_with_name(name), ExcNameNotFound(name));
 
  Type *p = nullptr;
 
  if (any_data[name].type() == typeid(Type *))
    {
      p = std::any_cast<Type *>(any_data[name]);
    }
  else if (any_data[name].type() == typeid(Type))
    {
      p = std::any_cast<Type>(&any_data[name]);
    }
  else
    {
      AssertThrow(false,
                  ExcTypeMismatch(name,
                                  any_data[name].type().name(),
                                  typeid(Type).name()));
    }
 
  return *p;
}
 
 
template <typename Type>
const Type &
GeneralDataStorage::get_object_with_name(const std::string &name) const
{
  AssertThrow(stores_object_with_name(name), ExcNameNotFound(name));
 
  const auto it = any_data.find(name);
 
  if (it->second.type() == typeid(Type *))
    {
      const Type *p = std::any_cast<Type *>(it->second);
      return *p;
    }
  else if (it->second.type() == typeid(Type))
    {
      const Type *p = std::any_cast<Type>(&it->second);
      return *p;
    }
  else
    {
      AssertThrow(false,
                  ExcTypeMismatch(name,
                                  it->second.type().name(),
                                  typeid(Type).name()));
      const Type *p = nullptr;
      return *p;
    }
}
 
 
 
template <typename Type, typename Arg>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
                                                Arg               &argument)
{
  if (!stores_object_with_name(name))
    add_unique_copy(name, Type(argument));
 
  return get_object_with_name<Type>(name);
}
 
 
 
template <typename Type, typename Arg, typename... Args>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
                                                Arg               &argument,
                                                Args &...arguments)
{
  if (!stores_object_with_name(name))
    add_unique_copy(name, Type(argument, arguments...));
 
  return get_object_with_name<Type>(name);
}
 
 
 
template <typename Type, typename Arg>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
                                                Arg              &&argument)
{
  if (!stores_object_with_name(name))
    add_unique_copy(name, Type(std::forward<Arg>(argument)));
 
  return get_object_with_name<Type>(name);
}
 
 
 
template <typename Type, typename Arg, typename... Args>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name,
                                                Arg              &&argument,
                                                Args &&...arguments)
{
  if (!stores_object_with_name(name))
    add_unique_copy(name,
                    Type(std::forward<Arg>(argument),
                         std::forward<Args>(arguments)...));
 
  return get_object_with_name<Type>(name);
}
 
 
template <typename Type>
Type &
GeneralDataStorage::get_or_add_object_with_name(const std::string &name)
{
  if (!stores_object_with_name(name))
    add_unique_copy(name, Type());
 
  return get_object_with_name<Type>(name);
}
 
 
#endif // DOXYGEN
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif // dealii_algorithms_general_data_storage_h