Table.icc

Go to the documentation of this file.

#include "cetlib/container_algorithms.h"
#include "fhiclcpp/detail/printing_helpers.h"
#include "fhiclcpp/types/detail/PrintAllowedConfiguration.h"
#include "fhiclcpp/types/detail/ValidateThenSet.h"
#include "fhiclcpp/types/detail/optional_parameter_message.h"
#include "fhiclcpp/types/detail/strip_containing_names.h"
#include "fhiclcpp/types/detail/validationException.h"

namespace fhicl {

  template <typename T, typename KeysToIgnore>
  template <typename... TCARGS>
  Table<T, KeysToIgnore>::Table(Name&& name, TCARGS && ... tcargs)
    : Table{std::move(name), Comment(""), std::forward<TCARGS>(tcargs)...} {}

  template <typename T, typename KeysToIgnore>
  template <typename... TCARGS>
  Table<T, KeysToIgnore>::Table(Name&& name,
                                Comment&& comment,
                                TCARGS && ... tcargs)
    : TableBase{std::move(name), std::move(comment), par_style::REQUIRED, detail::AlwaysUse()}
    , RegisterIfTableMember{this}
    , value_{std::make_shared<T>(std::forward<TCARGS>(tcargs)...)}
  {
    maybe_implicitly_default();
    NameStackRegistry::end_of_ctor();
  }

  template <typename T, typename KeysToIgnore>
  template <typename... TCARGS>
  Table<T, KeysToIgnore>::Table(Name&& name,
                                Comment&& comment,
                                MaybeUseFunction maybeUse,
                                TCARGS && ... tcargs)
    : TableBase{std::move(name), std::move(comment), par_style::REQUIRED_CONDITIONAL, maybeUse}
    , RegisterIfTableMember{this}
    , value_{std::make_shared<T>(std::forward<TCARGS>(tcargs)...)}
  {
    maybe_implicitly_default();
    NameStackRegistry::end_of_ctor();
  }


  template <typename T, typename KeysToIgnore>
  template <typename, typename>
  Table<T, KeysToIgnore>::Table(ParameterSet const& pset)
    : Table{pset, KeysToIgnore{}(), Impl{}}
  {}

  template <typename T, typename KeysToIgnore>
  template <typename, typename>
  Table<T, KeysToIgnore>::Table(ParameterSet const& pset, std::set<std::string> const& keysToIgnore)
    : Table{pset, keysToIgnore, Impl{}}
  {}

  template <typename T, typename KeysToIgnore>
  Table<T, KeysToIgnore>::Table(ParameterSet const& pset, std::set<std::string> const& keysToIgnore, Impl)
    : TableBase{Name("<top_level>"), Comment(""), par_style::REQUIRED, detail::AlwaysUse()}
    , RegisterIfTableMember{this}
  {
    maybe_implicitly_default();
    validate_ParameterSet(pset, keysToIgnore);
    NameStackRegistry::end_of_ctor();
  }

  template <typename T, typename KeysToIgnore>
  void
  Table<T, KeysToIgnore>::validate_ParameterSet(ParameterSet const& pset, std::set<std::string> const& keysToIgnore)
  {
    pset_ = pset;
    detail::ValidateThenSet vs {pset_, keysToIgnore};
    cet::for_all(members(), [&vs](auto m){ vs.walk_over(*m); });

    try {
      vs.check_keys();
    }
    catch(fhicl::detail::validationException const&) {
      NameStackRegistry::instance().clear();
      throw;
    }
  }

  template <typename T, typename KeysToIgnore>
  void
  Table<T, KeysToIgnore>::print_allowed_configuration(std::ostream& os,
                                                      std::string const& tab) const
  {
    os << '\n' << tab << detail::optional_parameter_message() << '\n';
    detail::PrintAllowedConfiguration pc {os, false, tab};
    pc.walk_over(*this);
  }

  template <typename T, typename KeysToIgnore>
  void
  Table<T, KeysToIgnore>::do_set_value(fhicl::ParameterSet const& pset, bool const /*trimParent*/)
  {
    // Kind of tricky: we do not have the name of the current
    // parameter set.  A placeholder is often used (e.g. "<top_level>").
    // Fortunately, since the pset is passed in, we can just assign to
    // it for a top-level ParameterSet.  However, for nested parameter
    // sets, we need to trim off the placeholder, and then the key we
    // send pset.get<fhicl::ParameterSet>(key) is the key relative to
    // the top-level pset.
    std::string const& rkey = key();
    std::string const& nkey = detail::strip_first_containing_name(rkey);
    pset_ = (nkey == rkey) ? pset : pset.get<fhicl::ParameterSet>(nkey);
  }

  template <typename T, typename KeysToIgnore>
  void
  Table<T, KeysToIgnore>::maybe_implicitly_default()
  {
    bool const implicitly_default = std::all_of(members_.begin(),
                                                members_.end(),
                                                [](auto p){
                                                  return p->has_default() || p->is_optional();
                                                });
    if (implicitly_default)
      set_par_style(par_style::DEFAULT);
  }

}

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