#include <ValidateThenSet.h>

Inheritance diagram for fhicl::detail::ValidateThenSet:

Public Member Functions
	ValidateThenSet (fhicl::ParameterSet const &pset, std::set< std::string > const &keysToIgnore)

void	check_keys ()

Public Member Functions inherited from fhicl::detail::ParameterWalker< tt::const_flavor::require_non_const >
	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)

void	do_after_action (tt::maybe_const_t< ParameterBase, C > &p)

void	do_enter_table (tt::maybe_const_t< TableBase, C > &t)

void	do_exit_table (tt::maybe_const_t< TableBase, C > &t)

void	do_enter_sequence (tt::maybe_const_t< SequenceBase, C > &s)

void	do_exit_sequence (tt::maybe_const_t< SequenceBase, C > &s)

void	do_atom (tt::maybe_const_t< AtomBase, C > &a)

void	do_delegated_parameter (tt::maybe_const_t< DelegateBase, C > &dp)

Private Member Functions
bool	before_action (ParameterBase &p) override

void	after_action (ParameterBase &p) override

void	enter_sequence (SequenceBase &p) override

void	delegated_parameter (DelegateBase &) override

void	enter_table (TableBase &) override

void	atom (AtomBase &) override

Private Attributes
ParameterSet const &	pset_

std::set< std::string >	ignorableKeys_

std::vector< std::string >	userKeys_

std::vector< cet::exempt_ptr< ParameterBase > >	missingParameters_

Detailed Description

Definition at line 15 of file ValidateThenSet.h.

Constructor & Destructor Documentation

fhicl::detail::ValidateThenSet::ValidateThenSet	(	fhicl::ParameterSet const &	pset,
		std::set< std::string > const &	keysToIgnore
	)

inline

Definition at line 18 of file ValidateThenSet.h.

       : pset_{pset}
       , ignorableKeys_{keysToIgnore}
       , userKeys_{pset.get_all_keys()}
       , missingParameters_{}
     {
       cet::sort_all(userKeys_);
     }

Member Function Documentation

void fhicl::detail::ValidateThenSet::after_action ( ParameterBase & p )

overrideprivate

Definition at line 53 of file ValidateThenSet.cc.

 {
   p.set_value(pset_);
 }

void fhicl::detail::ValidateThenSet::atom ( AtomBase & )

inlineoverrideprivate

Definition at line 40 of file ValidateThenSet.h.

41 {}

bool fhicl::detail::ValidateThenSet::before_action ( ParameterBase & p )

overrideprivate

Definition at line 17 of file ValidateThenSet.cc.

 {
   // 'ConfigPredicate' condition must be satisfied to continue.
   if (!p.should_use())
     return false;
 
   // Check that key exists; allow defaulted or optional keys to be
   // absent.
   std::string const& k = strip_first_containing_name(p.key());
   if (!pset_.has_key(k) and !cet::search_all(ignorableKeys_, k)) {
     if (!p.has_default() and !p.is_optional()) {
       missingParameters_.emplace_back(&p);
     }
     return false;
   }
 
   // Sometimes we are able to short-circuit walking the parameters
   // that belong to a sequence.  This is especially helpful for
   // sequences with many entries of atomic type.
   if (is_sequence(p.parameter_type()) and p.preset_value(pset_)) {
     // Remove all entries that match the sequence key and any elements
     // of that sequence.
     auto erase_from =
       std::remove_if(userKeys_.begin(), userKeys_.end(), [&k](auto const& e) {
         return e.find(k + '[') == 0ull or e == k;
       });
     userKeys_.erase(erase_from, userKeys_.cend());
     return false;
   }
 
   auto erase_from = std::remove(userKeys_.begin(), userKeys_.end(), k);
   userKeys_.erase(erase_from, userKeys_.cend());
   return true;
 }

void fhicl::detail::ValidateThenSet::check_keys ( )

Definition at line 189 of file ValidateThenSet.cc.

 {
   removeIgnorableKeys(ignorableKeys_, userKeys_, missingParameters_);
   std::string errmsg;
   errmsg += fillMissingKeysMsg(missingParameters_);
   errmsg += fillExtraKeysMsg(pset_, userKeys_);
   if (!errmsg.empty()) {
     std::string fullmsg{detail::optional_parameter_message(false)};
     fullmsg += "\n";
     fullmsg += errmsg;
     throw validationException{fullmsg.c_str()};
   }
 }

void fhicl::detail::ValidateThenSet::delegated_parameter ( DelegateBase & dp )

overrideprivate

Definition at line 83 of file ValidateThenSet.cc.

 {
   // A delegated parameter must itself be present, but any nested
   // parameters do not need to be present since the nested parameters
   // are potentially validated elsewhere.
   auto const& name = dp.name();
   std::string const pattern{fhicl::Name::regex_safe(name) + R"((\.|\[))"};
   std::regex const r{pattern};
   auto erase_from =
     std::remove_if(userKeys_.begin(), userKeys_.end(), [&r](auto const& k) {
       return std::regex_search(k, r);
     });
   userKeys_.erase(erase_from, userKeys_.end());
 }

void fhicl::detail::ValidateThenSet::enter_sequence ( SequenceBase & p )

overrideprivate

Definition at line 61 of file ValidateThenSet.cc.

 {
   // Ensure that the supplied parameter represents a sequence.
   auto const& key = strip_first_containing_name(s.key());
   if (!pset_.is_key_to_sequence(key)) {
     throw fhicl::exception(type_mismatch, "error converting to sequence:\n")
       << "The supplied value of the parameter:\n"
       << "    " << s.key() << '\n'
       << "does not represent a sequence.\n";
   }
 
   std::regex const r{fhicl::Name::regex_safe(key) + "\\[\\d+\\]"};
   std::size_t const nElems =
     std::count_if(userKeys_.begin(), userKeys_.end(), [&r](auto const& k) {
       return std::regex_match(k, r);
     });
   s.prepare_elements_for_validation(nElems);
 }

void fhicl::detail::ValidateThenSet::enter_table ( TableBase & )

inlineoverrideprivate

Definition at line 37 of file ValidateThenSet.h.

38 {}

Member Data Documentation

std::set<std::string> fhicl::detail::ValidateThenSet::ignorableKeys_

private

Definition at line 44 of file ValidateThenSet.h.

std::vector<cet::exempt_ptr<ParameterBase> > fhicl::detail::ValidateThenSet::missingParameters_

private

Definition at line 46 of file ValidateThenSet.h.

ParameterSet const& fhicl::detail::ValidateThenSet::pset_

private

Definition at line 43 of file ValidateThenSet.h.

std::vector<std::string> fhicl::detail::ValidateThenSet::userKeys_

private

Definition at line 45 of file ValidateThenSet.h.

The documentation for this class was generated from the following files:

fhiclcpp/fhiclcpp/types/detail/ValidateThenSet.h
fhiclcpp/fhiclcpp/types/detail/ValidateThenSet.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation