general_data_storage.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// 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 (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 = 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