any_data.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2014 - 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_any_data_h
#define dealii_any_data_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
 
#include <algorithm>
#include <any>
#include <typeinfo>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
class AnyData : public Subscriptor
{
public:
  AnyData() = default;
 
  unsigned int
  size() const;
 
  template <typename type>
  void
  add(type entry, const std::string &name);
 
  void
  merge(const AnyData &other);
 
  template <typename type>
  type
  entry(const std::string &name);
 
  template <typename type>
  type
  entry(const std::string &name) const;
 
  template <typename type>
  type
  read(const std::string &name) const;
 
  template <typename type>
  const type *
  read_ptr(const std::string &name) const;
 
  template <typename type>
  const type *
  try_read_ptr(const std::string &name) const;
 
  template <typename type>
  const type *
  try_read(const std::string &name) const;
 
  template <typename type>
  type
  entry(const unsigned int i);
 
  template <typename type>
  type
  entry(const unsigned int i) const;
 
  template <typename type>
  type
  read(const unsigned int i) const;
 
  template <typename type>
  const type *
  read_ptr(const unsigned int i) const;
 
  template <typename type>
  const type *
  try_read_ptr(const unsigned int i) const;
 
  template <typename type>
  const type *
  try_read(const unsigned int i) const;
 
  const std::string &
  name(const unsigned int i) const;
 
  unsigned int
  find(const std::string &name) const;
 
  unsigned int
  try_find(const std::string &name) const;
 
  template <typename type>
  bool
  is_type(const unsigned int i) const;
 
  template <typename StreamType>
  void
  list(StreamType &os) const;
 
  DeclException1(ExcNameNotFound,
                 std::string,
                 << "No entry with the name " << arg1 << " exists.");
 
  DeclException2(ExcTypeMismatch,
                 std::string,
                 std::string,
                 << "The requested type " << arg1 << " and the stored type "
                 << arg2 << " must coincide.");
 
  DeclException2(ExcNameMismatch,
                 int,
                 std::string,
                 << "Name at position " << arg1 << " is not equal to " << arg2
                 << '.');
 
private:
  std::vector<std::any> data;
  std::vector<std::string> names;
};
 
 
unsigned int inline AnyData::size() const
{
  AssertDimension(data.size(), names.size());
  return data.size();
}
 
 
template <typename type>
inline type
AnyData::entry(const unsigned int i)
{
  AssertIndexRange(i, size());
  const type *p = std::any_cast<type>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline type
AnyData::entry(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *p = std::any_cast<type>(&data[i]);
  if (p == nullptr)
    p = std::any_cast<const type>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline type
AnyData::read(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *p = std::any_cast<type>(&data[i]);
  if (p == nullptr)
    p = std::any_cast<const type>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline const type *
AnyData::read_ptr(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *const *p = std::any_cast<type *>(&data[i]);
  if (p == nullptr)
    p = std::any_cast<const type *>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type *).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline const type *
AnyData::try_read_ptr(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *const *p = std::any_cast<type *>(&data[i]);
  if (p == nullptr)
    p = std::any_cast<const type *>(&data[i]);
  if (p == nullptr)
    return nullptr;
  return *p;
}
 
 
template <typename type>
inline const type *
AnyData::try_read(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *p = std::any_cast<type>(&data[i]);
  if (p == 0)
    p = std::any_cast<const type>(&data[i]);
  return p;
}
 
 
inline const std::string &
AnyData::name(const unsigned int i) const
{
  AssertIndexRange(i, size());
  return names[i];
}
 
 
inline unsigned int
AnyData::try_find(const std::string &n) const
{
  std::vector<std::string>::const_iterator it =
    std::find(names.begin(), names.end(), n);
 
  if (it == names.end())
    return numbers::invalid_unsigned_int;
 
  return it - names.begin();
}
 
 
inline unsigned int
AnyData::find(const std::string &n) const
{
  const unsigned int i = try_find(n);
  Assert(i != numbers::invalid_unsigned_int, ExcNameNotFound(n));
 
  return i;
}
 
 
template <typename type>
inline bool
AnyData::is_type(const unsigned int i) const
{
  return data[i].type() == typeid(type);
}
 
 
template <typename type>
inline type
AnyData::entry(const std::string &n)
{
  const unsigned int i = find(n);
  const type        *p = std::any_cast<type>(&data[i]);
  Assert(p != 0, ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline type
AnyData::entry(const std::string &n) const
{
  const unsigned int i = find(n);
  const type        *p = std::any_cast<type>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline type
AnyData::read(const std::string &n) const
{
  const unsigned int i = find(n);
  const type        *p = std::any_cast<type>(&data[i]);
  Assert(p != 0, ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline const type *
AnyData::read_ptr(const std::string &n) const
{
  const unsigned int i = find(n);
  const type *const *p = std::any_cast<type *>(&data[i]);
  if (p == nullptr)
    p = std::any_cast<const type *>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}
 
 
template <typename type>
inline const type *
AnyData::try_read_ptr(const std::string &n) const
{
  const unsigned int i = try_find(n);
  if (i == numbers::invalid_unsigned_int)
    return 0;
 
  const type *const *p = std::any_cast<type *>(&data[i]);
  if (p == 0)
    p = std::any_cast<const type *>(&data[i]);
  return *p;
}
 
 
template <typename type>
inline const type *
AnyData::try_read(const std::string &n) const
{
  // Try to find name
  std::vector<std::string>::const_iterator it =
    std::find(names.begin(), names.end(), n);
  // Return null pointer if not found
  if (it == names.end())
    return nullptr;
 
  // Compute index and return casted pointer
  unsigned int i = it - names.begin();
  const type  *p = std::any_cast<type>(&data[i]);
  return p;
}
 
 
template <typename type>
inline void
AnyData::add(type ent, const std::string &n)
{
  std::any e = ent;
  data.push_back(e);
  names.push_back(n);
}
 
 
inline void
AnyData::merge(const AnyData &other)
{
  for (unsigned int i = 0; i < other.size(); ++i)
    {
      names.push_back(other.names[i]);
      data.push_back(other.data[i]);
    }
}
 
 
template <typename StreamType>
inline void
AnyData::list(StreamType &os) const
{
  for (unsigned int i = 0; i < names.size(); ++i)
    {
      os << i << '\t' << names[i] << '\t' << data[i].type().name() << std::endl;
    }
}
 
 
//----------------------------------------------------------------------//
 
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif