parameter_acceptor.h

//-----------------------------------------------------------
//
//    Copyright (C) 2017 - 2018 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_base_parameter_acceptor_h
#define dealii_base_parameter_acceptor_h

#include <deal.II/base/config.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/signals2/signal.hpp>
#include <typeinfo>

DEAL_II_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 &output_filename="",
                         const ParameterHandler::OutputStyle output_style_for_prm_format=ParameterHandler::ShortText,
                         ParameterHandler &prm = ParameterAcceptor::prm);

  static void initialize(std::istream &input_stream,
                         ParameterHandler &prm = ParameterAcceptor::prm);


  static void clear();

  virtual void declare_parameters(ParameterHandler &prm);

  boost::signals2::signal<void()> declare_parameters_call_back;

  virtual void parse_parameters(ParameterHandler &prm);

  boost::signals2::signal<void()> parse_parameters_call_back;

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

  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 ParameterType>
  void add_parameter(const std::string &entry,
                     ParameterType &parameter,
                     const std::string &documentation = std::string(),
                     ParameterHandler &prm_ = prm,
                     const Patterns::PatternBase &pattern =
                       *Patterns::Tools::Convert<ParameterType>::to_pattern());

  static ParameterHandler prm;

  void enter_my_subsection(ParameterHandler &prm);

  void leave_my_subsection(ParameterHandler &prm);

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

  const unsigned int acceptor_id;

  static const char sep = '/';

protected:
  const std::string section_name;
};



template<class SourceClass>
class ParameterAcceptorProxy : public SourceClass, public ParameterAcceptor
{
public:
  template<typename... Args>
  ParameterAcceptorProxy(const std::string section_name, Args... args);

  virtual void declare_parameters(ParameterHandler &prm);

  virtual void parse_parameters(ParameterHandler &prm);
};



// Inline and template functions
template<class ParameterType>
void ParameterAcceptor::add_parameter(const std::string &entry,
                                      ParameterType &parameter,
                                      const std::string &documentation,
                                      ParameterHandler &prm,
                                      const Patterns::PatternBase &pattern)
{
  enter_my_subsection(prm);
  prm.add_parameter(entry, parameter, documentation, pattern);
  leave_my_subsection(prm);
}



template<class SourceClass>
template<typename... Args>
ParameterAcceptorProxy<SourceClass>::
ParameterAcceptorProxy(const std::string section_name, Args... args) :
  SourceClass(args...),
  ParameterAcceptor(section_name)
{
}



template<class SourceClass>
void  ParameterAcceptorProxy<SourceClass>::declare_parameters(ParameterHandler &prm)
{
  SourceClass::declare_parameters(prm);
}



template<class SourceClass>
void  ParameterAcceptorProxy<SourceClass>::parse_parameters(ParameterHandler &prm)
{
  SourceClass::parse_parameters(prm);
}

DEAL_II_NAMESPACE_CLOSE

#endif