ParameterWalker.h

Go to the documentation of this file.

#ifndef fhiclcpp_types_detail_ParameterWalker_h
#define fhiclcpp_types_detail_ParameterWalker_h

/*
  ======================================================================

  ParameterWalker

  ======================================================================

  The ParameterWalker class makes it possible to traverse the nested
  configuration for a given parameter.  This class is very similar in
  functionality to the 'ParameterSet::walk_' function.

  The tree-walking functionality is provided via derivation:

      class MyWalker : ParameterWalker<tt::const_flavor::require(_non)_const>
      {
        // members, functions, etc.
      };

  where a provided template argument of
  'tt::const_flavor::require_const ' makes all virtual functions
  accept "T const*" arguments, whereas require_non_const makes all
  virtual functions accept "T*" arguments.

  Heuristically, it looks like:

      for (auto p : parameters) {
         if (!psw.before_action(p))
             return;

         if (is_table(param)) {
             cast_from(p,t)
         *** psw.enter_table(t)
             descend_into_table ...
             psw.exit_table(t)
         }
         else if (is_sequence(param)) {
             cast_from(p,s)
         *** psw.enter_sequence(s)
             loop_through_sequence ...
             psw.exit_sequence(s)
         }
         else if (is_atom(param)) {
             cast_from(p,a)
         *** psw.atom(a)
         }
         else {
             cast_from(p,dp)
         *** psw.delegated_parameter(dp)
         }

         psw.after_action(p)
      }

  The actions that are to be taken per parameter category (table,
  sequence, or atom) are defined entirely by overrides to the
  ParameterWalker virtual functions that 'psw' calls (as shown above).

  The function calls prefaced with '***' correspond to pure virtual
  functions, which must have corresponding overrides in any derived
  classes.

  The 'exit_{table,sequence}' functions are provided if (e.g.) the
  derived-class state needs to be restored after the table or sequence
  traversal.  The '{before,after}_action' virtual functions are
  provided so that category-agnostic instructions can be executed
  before or after the category-specific ones.
*/

#include "cetlib/container_algorithms.h"
#include "cetlib_except/demangle.h"
#include "fhiclcpp/type_traits.h"
#include "fhiclcpp/types/detail/AtomBase.h"
#include "fhiclcpp/types/detail/DelegateBase.h"
#include "fhiclcpp/types/detail/SequenceBase.h"
#include "fhiclcpp/types/detail/TableBase.h"

namespace fhicl::detail {

  template <tt::const_flavor C>
  class ParameterWalker {
  public:
    ParameterWalker() = default;
    virtual ~ParameterWalker() = default;

    void walk_over(tt::maybe_const_t<ParameterBase, C>&);

    bool
    do_before_action(tt::maybe_const_t<ParameterBase, C>& p)
    {
      return before_action(p);
    }
    void
    do_after_action(tt::maybe_const_t<ParameterBase, C>& p)
    {
      after_action(p);
    }

    void
    do_enter_table(tt::maybe_const_t<TableBase, C>& t)
    {
      enter_table(t);
    }
    void
    do_exit_table(tt::maybe_const_t<TableBase, C>& t)
    {
      exit_table(t);
    }

    void
    do_enter_sequence(tt::maybe_const_t<SequenceBase, C>& s)
    {
      enter_sequence(s);
    }
    void
    do_exit_sequence(tt::maybe_const_t<SequenceBase, C>& s)
    {
      exit_sequence(s);
    }

    void
    do_atom(tt::maybe_const_t<AtomBase, C>& a)
    {
      atom(a);
    }

    void
    do_delegated_parameter(tt::maybe_const_t<DelegateBase, C>& dp)
    {
      delegated_parameter(dp);
    }

  private:
    virtual void enter_table(tt::maybe_const_t<TableBase, C>&) = 0;
    virtual void enter_sequence(tt::maybe_const_t<SequenceBase, C>&) = 0;
    virtual void atom(tt::maybe_const_t<AtomBase, C>&) = 0;
    virtual void delegated_parameter(tt::maybe_const_t<DelegateBase, C>&) = 0;

    virtual bool
    before_action(tt::maybe_const_t<ParameterBase, C>&)
    {
      return true;
    }
    virtual void
    after_action(tt::maybe_const_t<ParameterBase, C>&)
    {}
    virtual void
    exit_table(tt::maybe_const_t<TableBase, C>&)
    {}
    virtual void
    exit_sequence(tt::maybe_const_t<SequenceBase, C>&)
    {}
  };

  //=============================================================================
  // IMPLEMENTATION BELOW

  template <tt::const_flavor C>
  void
  ParameterWalker<C>::walk_over(tt::maybe_const_t<ParameterBase, C>& p)
  {
    if (!do_before_action(p))
      return;

    fhicl::par_type const pt = p.parameter_type();

    auto& tw = *this;

    if (is_table(pt)) {
      using maybe_const_table = tt::maybe_const_t<TableBase, C>;
      maybe_const_table& t = dynamic_cast<maybe_const_table&>(p);
      do_enter_table(t);
      cet::for_all(t.members(), [&tw](auto m) { tw.walk_over(*m); });
      do_exit_table(t);
    } else if (is_sequence(pt)) {
      using maybe_const_sequence = tt::maybe_const_t<SequenceBase, C>;
      maybe_const_sequence& s = dynamic_cast<maybe_const_sequence&>(p);
      do_enter_sequence(s);
      s.walk_elements(tw);
      do_exit_sequence(s);
    } else if (is_atom(pt)) {
      using maybe_const_atom = tt::maybe_const_t<AtomBase, C>;
      maybe_const_atom& a = dynamic_cast<maybe_const_atom&>(p);
      do_atom(a);
    } else {
      using maybe_const_delegate = tt::maybe_const_t<DelegateBase, C>;
      maybe_const_delegate& dp = dynamic_cast<maybe_const_delegate&>(p);
      do_delegated_parameter(dp);
    }

    do_after_action(p);
  }

  // Explicit instantiations to avoid code bloat
  extern template class ParameterWalker<tt::const_flavor::require_const>;
  extern template class ParameterWalker<tt::const_flavor::require_non_const>;
}

#endif /* fhiclcpp_types_detail_ParameterWalker_h */

// Local variables:
// mode: c++
// End: