any_data.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2015 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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 <vector>
#include <algorithm>
#include <typeinfo>

DEAL_II_NAMESPACE_OPEN

class AnyData :
  public Subscriptor
{
public:
  AnyData();

  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,
                 char *, char *,
                 << "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;
};


inline
AnyData::AnyData()
{}


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 != 0,
         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==0 )
    p = boost::any_cast<const type>(&data[i]);
  Assert(p != 0,
         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==0)
    p = boost::any_cast<const 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 unsigned int i) const
{
  AssertIndexRange(i, size());
  const type *const *p = boost::any_cast<type *>(&data[i]);
  if (p==0)
    p = boost::any_cast<const type *>(&data[i]);
  Assert(p != 0,
         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==0)
    p = boost::any_cast<const type *>(&data[i]);
  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 != 0,
         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==0)
    p = boost::any_cast<const type *>(&data[i]);
  Assert(p != 0,
         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 0;

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