any_data.h

Go to the documentation of this file.

//-----------------------------------------------------------
//
//    Copyright (C) 2015 by the deal2lkit authors
//
//    This file is part of the deal2lkit library.
//
//    The deal2lkit 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 deal2lkit distribution.
//
//-----------------------------------------------------------

#ifndef _d2k_any_data_h
#define _d2k_any_data_h

#include <deal2lkit/config.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>

#include <map>
#include <deal2lkit/utilities.h>

using namespace dealii;


D2K_NAMESPACE_OPEN

class AnyData : public Subscriptor
{
public:

  template <typename type>
  void add_copy (const type &entry, const std::string &name);

  template <typename type>
  void add_ref (type &entry, const std::string &name);

  template <typename type>
  type &get (const std::string &name);

  template <typename type>
  const type &get (const std::string &name) const;

  inline bool have (const std::string &name) const;

  template <class STREAM>
  void print_info (STREAM &os);

  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");


private:
  std::map<std::string, boost::any> mydata;
}; // end class

template <typename type>
void AnyData::add_copy (const type &entry, const std::string &name)
{
  mydata[name] = entry;
}

template <typename type>
void AnyData::add_ref (type &entry, const std::string &name)
{
  type *ptr = &entry;
  mydata[name] = ptr;
}

template <typename type>
type &AnyData::get(const std::string &name)
{
  Assert( mydata.find(name) != mydata.end(),
          ExcNameNotFound(name));

  type *p=NULL;

  if (mydata[name].type() == typeid(type *) )
    {
      p = boost::any_cast<type *>(mydata[name]);
    }
  else if (mydata[name].type() == typeid(type))
    {
      p = boost::any_cast<type>(&mydata[name]);
    }
  else
    {
      Assert(false,
             ExcTypeMismatch(typeid(type).name(),mydata[name].type().name()));
    }

  return *p;
}

template <typename type>
const type &AnyData::get(const std::string &name) const
{
  Assert( mydata.find(name) != mydata.end(),
          ExcNameNotFound(name));

  typedef std::map<std::string, boost::any>::const_iterator it_type;

  it_type it = mydata.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
    {
      Assert(false,
             ExcTypeMismatch(typeid(type).name(),it->second.type().name()));
      const type *p=NULL;
      return *p;
    }
}


bool AnyData::have(const std::string &name) const
{
  return mydata.find(name) != mydata.end();
}

template <class STREAM>
inline
void AnyData::print_info(STREAM &os)
{
  for (std::map<std::string, boost::any>::iterator  it=mydata.begin(); it != mydata.end(); ++it)
    {
      os << it->first
         << '\t' << '\t'
         << demangle(it->second.type().name())
         << std::endl;
    }
}


D2K_NAMESPACE_CLOSE

#endif