any_data.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2017 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_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 <boost/any.hpp>

#include <algorithm>
#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>
  const type
  entry(const std::string &name) const;

  template <typename type>
  const 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>
  const type
  entry(const unsigned int i) const;

  template <typename type>
  const 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 <class 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<boost::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());
  type *p = boost::any_cast<type>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}


template <typename type>
inline const type
AnyData::entry(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *p = boost::any_cast<type>(&data[i]);
  if (p == nullptr)
    p = boost::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(const unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *p = boost::any_cast<type>(&data[i]);
  if (p == nullptr)
    p = boost::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 = boost::any_cast<type *>(&data[i]);
  if (p == nullptr)
    p = boost::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 = boost::any_cast<type *>(&data[i]);
  if (p == nullptr)
    p = boost::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 = boost::any_cast<type>(&data[i]);
  if (p == 0)
    p = boost::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);
  type *             p = boost::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::entry(const std::string &n) const
{
  const unsigned int i = find(n);
  const type *       p = boost::any_cast<type>(&data[i]);
  Assert(p != nullptr,
         ExcTypeMismatch(typeid(type).name(), data[i].type().name()));
  return *p;
}


template <typename type>
inline const type
AnyData::read(const std::string &n) const
{
  const unsigned int i = find(n);
  const type *       p = boost::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 = boost::any_cast<type *>(&data[i]);
  if (p == nullptr)
    p = boost::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 = boost::any_cast<type *>(&data[i]);
  if (p == 0)
    p = boost::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 = boost::any_cast<type>(&data[i]);
  return p;
}


template <typename type>
inline void
AnyData::add(type ent, const std::string &n)
{
  boost::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 <class 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