general_data_storage.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.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/any.hpp>
#include <boost/core/demangle.hpp>

#include <algorithm>
#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, typename... Args>
  Type &
  get_or_add_object_with_name(const std::string &name,
                              Arg &&             argument,
                              Args &&... arguments);

  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, boost::any> any_data;
};


/*----------------- Inline and template methods -----------------*/


#ifndef DOXYGEN


template <class Stream>
void
GeneralDataStorage::print_info(Stream &os)
{
  for (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 = boost::any_cast<Type *>(any_data[name]);
    }
  else if (any_data[name].type() == typeid(Type))
    {
      p = boost::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 = boost::any_cast<Type *>(it->second);
      return *p;
    }
  else if (it->second.type() == typeid(Type))
    {
      const Type *p = boost::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, 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, 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