parameter_acceptor.h

Go to the documentation of this file.

//-----------------------------------------------------------
//
//    Copyright (C) 2014 - 2016 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_parameter_acceptor_h
#define _d2k_parameter_acceptor_h

#include <deal2lkit/config.h>
#include <deal2lkit/utilities.h>
#include <deal.II/base/parameter_handler.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/logstream.h>
#include <deal.II/base/exceptions.h>
#include <boost/any.hpp>
#include <typeinfo>



using namespace dealii;

D2K_NAMESPACE_OPEN

class ParameterAcceptor : public Subscriptor
{
public:
  ParameterAcceptor(const std::string section_name="");

  virtual ~ParameterAcceptor();

  static void initialize(const std::string filename="",
                         const std::string outfilename="");

  static void clear();

  virtual void parse_parameters(ParameterHandler &prm);

  virtual void parse_parameters_call_back();


  virtual void declare_parameters(ParameterHandler &) {};


  static void parse_all_parameters(ParameterHandler &prm=ParameterAcceptor::prm);


  static void log_info();


  static void declare_all_parameters(ParameterHandler &prm=ParameterAcceptor::prm);


  std::string get_section_name() const;

  std::vector<std::string> get_section_path() const;

  template <class T>
  void add_parameter(ParameterHandler &prm, T *parameter,
                     const std::string &entry,
                     const std::string &default_value,
                     const Patterns::PatternBase &pattern=Patterns::Anything(),
                     const std::string &documentation=std::string())
  {
    AssertThrow(std::is_const<T>::value == false,
                ExcMessage("You tried to add a parameter using a const "
                           "variable. This is not allowed, since these "
                           "variables will be filled later on when "
                           "parsing the parameter."));

    prm.declare_entry(entry, default_value, pattern, documentation);
    parameters[entry] = boost::any(parameter);
  }


  template <class T>
  void add_parameter(T &parameter,
                     const std::string &entry,
                     const std::string &documentation=std::string(),
                     ParameterHandler &prm=ParameterAcceptor::prm)
  {
    AssertThrow(std::is_const<T>::value == false,
                ExcMessage("You tried to add a parameter using a const "
                           "variable. This is not allowed, since these "
                           "variables will be filled later on when "
                           "parsing the parameter."));

    enter_my_subsection(prm);
    prm.declare_entry(entry, to_string(parameter),
                      *to_pattern(parameter),
                      documentation);
    leave_my_subsection(prm);
    parameters[entry] = boost::any(&parameter);
  }

  void enter_my_subsection(ParameterHandler &prm);

  void leave_my_subsection(ParameterHandler &prm);

  template <class T>
  static std_cxx11::shared_ptr<Patterns::PatternBase> to_pattern(const T &);

  template <class T>
  static T to_type(const std::string &);

  template <class T>
  static std::string to_string(const T &);

  static ParameterHandler prm;

private:
  static std::vector<SmartPointer<ParameterAcceptor> > class_list;

  const unsigned int acceptor_id;

  mutable std::map<std::string, boost::any> parameters;

  static const char sep = '/';

protected:
  const std::string section_name;
};


D2K_NAMESPACE_CLOSE

#endif