fhicl Namespace Reference

parameter set interface More...

Namespaces
	comment_detail
	detail
	has_insertion_operator_impl
	sequence_detail
	tuple_detail

Classes
struct	ass_parser
class	Atom
struct	bin_parser
struct	binding_parser
struct	Comment
class	ConfigurationTable
struct	dbid_parser
class	DelegatedParameter
struct	dss_parser
class	extended_value
struct	has_insertion_operator
struct	hex_parser
class	intermediate_table
struct	KeysToIgnore
struct	MaybeUseFunction
struct	Name
class	NameStackRegistry
struct	NoInsert
class	OptionalAtom
class	OptionalDelegatedParameter
class	OptionalSequence
class	OptionalSequence< T,-1ull >
class	OptionalTable
class	OptionalTuple
class	OptionalTupleAs
class	OptionalTupleAs< T(ARGS...)>
class	ParameterSet
class	ParameterSetID
class	ParameterSetRegistry
class	ParameterSetWalker
struct	real_parser
class	Sequence
class	Sequence< T,-1ull >
class	Table
class	TableFragment
class	Tuple
class	TupleAs
class	TupleAs< T(ARGS...)>
struct	uint_parser
class	WrappedTable
struct	YesInsert

Typedefs
using	exception = cet::coded_exception< error, detail::translate >
template<typename T >
using	NullaryConfigPredicate_t = bool(T::*)() const

Enumerations
enum	error {   cant_find, cant_happen, cant_insert, number_is_too_large,   parse_error, type_mismatch, protection_violation, cant_open_db,   sql_error, unimplemented, other }
enum	value_tag {   UNKNOWN, NIL, BOOL, NUMBER,   COMPLEX, STRING, SEQUENCE, TABLE,   TABLEID }
enum	Protection : unsigned char { Protection::NONE, Protection::PROTECT_IGNORE, Protection::PROTECT_ERROR }
enum	par_type {   par_type::ATOM, par_type::TABLE, par_type::SEQ_VECTOR, par_type::SEQ_ARRAY,   par_type::TUPLE, par_type::DELEGATE, par_type::NTYPES }
enum	par_style {   par_style::REQUIRED, par_style::REQUIRED_CONDITIONAL, par_style::DEFAULT, par_style::DEFAULT_CONDITIONAL,   par_style::OPTIONAL, par_style::OPTIONAL_CONDITIONAL, par_style::NTYPES }

Functions
void	decompose_parameterset (fhicl::ParameterSet const &top, std::vector< std::string > &records, std::vector< std::string > &hashes)
void	decompose_fhicl (std::string const &filename, std::vector< std::string > &records, std::vector< std::string > &hashes)
void	parse_file_and_fill_db (std::string const &filename, sqlite3 *db)
void	make_ParameterSet (intermediate_table const &tbl, ParameterSet &ps)
void	make_ParameterSet (extended_value const &xval, ParameterSet &ps)
void	make_ParameterSet (std::string const &str, ParameterSet &ps)
void	make_ParameterSet (std::string const &filename, cet::filepath_maker &maker, ParameterSet &ps)
std::ostream &	operator<< (std::ostream &, ParameterSetID const &)
bool	parse_value_string (std::string const &s, extended_value &v, std::string &unparsed)
void	parse_document (std::string const &filename, cet::filepath_maker &maker, intermediate_table &result)
void	parse_document (std::istream &is, cet::filepath_maker &maker, intermediate_table &result)
void	parse_document (std::string const &s, intermediate_table &result)
std::string	to_string (Protection p)
bool	maximally_munched (char const ch)
bool	maximally_munched_number (char const ch)
bool	maximally_munched_ass (char const ch)
bool	maximally_munched_dss (char const ch)
template<typename T >
std::function< bool()>	use_if (T *p, NullaryConfigPredicate_t< T > f)
template<typename T >
std::function< bool()>	use_unless (T *p, NullaryConfigPredicate_t< T > f)
bool	is_table (par_type const pt)
bool	is_sequence (par_type const pt)
bool	is_atom (par_type const pt)
std::string const	get_regex_replace_str (std::string const &istr)
template<typename T >
std::ostream &	operator<< (std::ostream &os, OptionalTable< T > const &t)
template<typename T >
std::ostream &	operator<< (std::ostream &os, Table< T > const &t)

Detailed Description

parameter set interface

Typedef Documentation

using fhicl::exception = typedef cet::coded_exception<error, detail::translate>

Definition at line 33 of file exception.h.

template<typename T >

using fhicl::NullaryConfigPredicate_t = typedef bool (T::*)() const

Definition at line 17 of file ConfigPredicate.h.

Enumeration Type Documentation

enum fhicl::error

Enumerator
cant_find
cant_happen
cant_insert
number_is_too_large
parse_error
type_mismatch
protection_violation
cant_open_db
sql_error
unimplemented
other

Definition at line 15 of file exception.h.

             {
    cant_find,
    cant_happen,
    cant_insert,
    number_is_too_large,
    parse_error,
    type_mismatch,
    protection_violation,
    cant_open_db,
    sql_error,
    unimplemented,
    other
  };

enum fhicl::par_style

strong

Enumerator
REQUIRED
REQUIRED_CONDITIONAL
DEFAULT
DEFAULT_CONDITIONAL
OPTIONAL
OPTIONAL_CONDITIONAL
NTYPES

Definition at line 37 of file ParameterArgumentTypes.h.

                       {
    REQUIRED,
    REQUIRED_CONDITIONAL,
    DEFAULT,
    DEFAULT_CONDITIONAL,
    OPTIONAL,
    OPTIONAL_CONDITIONAL,
    NTYPES
  };

enum fhicl::par_type

strong

Enumerator
ATOM
TABLE
SEQ_VECTOR
SEQ_ARRAY
TUPLE
DELEGATE
NTYPES

Definition at line 8 of file ParameterArgumentTypes.h.

                      {
    ATOM,
    TABLE,
    SEQ_VECTOR,
    SEQ_ARRAY,
    TUPLE,
    DELEGATE,
    NTYPES
  };

enum fhicl::Protection : unsigned char

strong

Enumerator
NONE
PROTECT_IGNORE
PROTECT_ERROR

Definition at line 7 of file Protection.h.

: unsigned char { NONE, PROTECT_IGNORE, PROTECT_ERROR };

enum fhicl::value_tag

Enumerator
UNKNOWN
NIL
BOOL
NUMBER
COMPLEX
STRING
SEQUENCE
TABLE
TABLEID

Definition at line 22 of file extended_value.h.

                 {
    UNKNOWN,
    NIL,
    BOOL,
    NUMBER,
    COMPLEX,
    STRING,
    SEQUENCE,
    TABLE,
    TABLEID
  };

Function Documentation

void fhicl::decompose_fhicl	(	std::string const &	filename,
		std::vector< std::string > &	records,
		std::vector< std::string > &	hashes
	)

Definition at line 5 of file DatabaseSupport.cc.

References decompose_parameterset(), and make_ParameterSet().

{
  // Parse file into a ParameterSet.
  fhicl::ParameterSet top;
  cet::filepath_maker fpm;
  make_ParameterSet(filename, fpm, top);
  decompose_parameterset(top, records, hashes);
}

void fhicl::decompose_parameterset	(	fhicl::ParameterSet const &	top,
		std::vector< std::string > &	records,
		std::vector< std::string > &	hashes
	)

Definition at line 17 of file DatabaseSupport.cc.

References fhicl::ParameterSet::get(), fhicl::ParameterSet::get_names(), fhicl::ParameterSet::id(), fhicl::ParameterSet::is_key_to_sequence(), fhicl::ParameterSet::is_key_to_table(), fhicl::ParameterSet::to_compact_string(), and fhicl::ParameterSetID::to_string().

Referenced by decompose_fhicl().

{
  assert(records.size() == hashes.size());

  // First handle the top-level ParameterSet
  records.push_back(top.to_compact_string());
  hashes.push_back(top.id().to_string());

  // Recurse through all parameters, dealing with ParameterSets and
  // vectors thereof.
  std::vector<std::string> keys = top.get_names();
  for (auto const& key : keys) {
    if (top.is_key_to_table(key))
      decompose_parameterset(top.get<ParameterSet>(key), records, hashes);
    else if (top.is_key_to_sequence(key)) {
      try {
        auto nestlings = top.get<std::vector<ParameterSet>>(key);
        for (auto const& ps : nestlings)
          decompose_parameterset(ps, records, hashes);
      }
      catch (fhicl::exception const&) {
        // The vector didn't contain ParameterSets, keep going; no
        // corrective action is needed.
      }
    }
  }
}

std::string const fhicl::get_regex_replace_str

(

std::string const &

istr

)

Definition at line 8 of file Name.cc.

Referenced by fhicl::Name::regex_safe().

  {
    static std::regex const r("\\[|\\]");
    auto ostr = std::regex_replace(istr, r, "\\$&");
    return ostr;
  }

bool fhicl::is_atom ( par_type const  pt )

inline

Definition at line 32 of file ParameterArgumentTypes.h.

References ATOM.

Referenced by evgen::MARLEYHelper::fhicl_parameter_to_json(), and fhicl::detail::ParameterWalker< C >::walk_over().

  {
    return pt == par_type::ATOM;
  }

bool fhicl::is_sequence ( par_type const  pt )

inline

Definition at line 25 of file ParameterArgumentTypes.h.

References SEQ_ARRAY, SEQ_VECTOR, and TUPLE.

Referenced by evgen::MARLEYHelper::fhicl_parameter_to_json().

  {
    return pt == par_type::SEQ_VECTOR || pt == par_type::SEQ_ARRAY ||
           pt == par_type::TUPLE;
  }

bool fhicl::is_table ( par_type const  pt )

inline

Definition at line 19 of file ParameterArgumentTypes.h.

References TABLE.

Referenced by evgen::MARLEYHelper::fhicl_parameter_to_json().

  {
    return pt == par_type::TABLE;
  }

void fhicl::make_ParameterSet	(	intermediate_table const &	tbl,
		ParameterSet &	ps
	)

Definition at line 31 of file make_ParameterSet.cc.

References fhicl::ParameterSet::put().

Referenced by evdb::ServiceTable::ApplyEdits(), testing::BasicTesterEnvironment< ConfigurationClass >::CompileParameterSet(), decompose_fhicl(), fhicl::ParameterSetRegistry::find_(), main(), make_ParameterSet(), parse_file_and_fill_db(), lar::standalone::ParseConfiguration(), testing::BasicTesterEnvironment< ConfigurationClass >::ParseParameters(), detinfo::DetectorPropertiesServiceStandard::postOpenFile(), detinfo::DetectorClocksServiceStandard::postOpenFile(), util::DetectorPropertiesServiceArgoNeuT::postOpenFile(), read_all_parameter_sets(), art::run_art(), art::run_art_string_config(), and fhicl::ParameterSetRegistry::stageIn().

{
  for (auto const& pr : tbl) {
    if (!pr.second.in_prolog)
      ps.put(pr.first, pr.second);
  }
}

void fhicl::make_ParameterSet	(	extended_value const &	xval,
		ParameterSet &	ps
	)

Definition at line 42 of file make_ParameterSet.cc.

References fhicl::extended_value::is_a(), fhicl::ParameterSet::put(), TABLE, and type_mismatch.

{
  if (!xval.is_a(TABLE))
    throw fhicl::exception(type_mismatch, "extended value not a table");

  table_t const& tbl = table_t(xval);
  for (auto const& pr : tbl) {
    if (!pr.second.in_prolog)
      ps.put(pr.first, pr.second);
  }
}

void fhicl::make_ParameterSet	(	std::string const &	str,
		ParameterSet &	ps
	)

Definition at line 57 of file make_ParameterSet.cc.

References make_ParameterSet(), and parse_document().

{
  intermediate_table tbl;
  parse_document(str, tbl);
  make_ParameterSet(tbl, ps);
}

void fhicl::make_ParameterSet	(	std::string const &	filename,
		cet::filepath_maker &	maker,
		ParameterSet &	ps
	)

Definition at line 67 of file make_ParameterSet.cc.

References make_ParameterSet(), and parse_document().

{
  intermediate_table tbl;
  parse_document(filename, maker, tbl);
  make_ParameterSet(tbl, ps);
}

bool fhicl::maximally_munched ( char const  ch )

inline

Definition at line 28 of file tokens.h.

Referenced by maximally_munched_ass(), maximally_munched_dss(), and maximally_munched_number().

  {
    return !std::isgraph(ch) || ch == '#' || ch == '/' || ch == ',' ||
           ch == ']' || ch == '}';
  }

bool fhicl::maximally_munched_ass ( char const  ch )

inline

Definition at line 41 of file tokens.h.

References maximally_munched().

Referenced by fhicl::ass_parser::parse().

  {
    return maximally_munched(ch) || ch == '.' || ch == '[' || ch == ':';
  }

bool fhicl::maximally_munched_dss ( char const  ch )

inline

Definition at line 47 of file tokens.h.

References bin, and maximally_munched().

Referenced by fhicl::dss_parser::parse().

  {
    return maximally_munched(ch);
  }

bool fhicl::maximally_munched_number ( char const  ch )

inline

Definition at line 35 of file tokens.h.

References maximally_munched().

Referenced by fhicl::real_parser::parse(), fhicl::uint_parser::parse(), fhicl::hex_parser::parse(), fhicl::dbid_parser::parse(), and fhicl::bin_parser::parse().

  {
    return maximally_munched(ch) || ch == ')';
  }

ostream & fhicl::operator<<	(	std::ostream &	os,
		ParameterSetID const &	psid
	)

Definition at line 142 of file ParameterSetID.cc.

References fhicl::ParameterSetID::to_string().

{
  return os << psid.to_string();
}

template<typename T >

std::ostream& fhicl::operator<< ( std::ostream &  os, OptionalTable< T > const &  t  )

inline

Definition at line 100 of file OptionalTable.h.

  {
    std::ostringstream config;
    t.print_allowed_configuration(config);
    return os << config.str();
  }

template<typename T >

std::ostream& fhicl::operator<< ( std::ostream &  os, Table< T > const &  t  )

inline

Definition at line 110 of file Table.h.

  {
    std::ostringstream config;
    t.print_allowed_configuration(config);
    return os << config.str();
  }

void fhicl::parse_document	(	std::string const &	filename,
		cet::filepath_maker &	maker,
		intermediate_table &	result
	)

Definition at line 856 of file parse.cc.

Referenced by art::BasicOptionsHandler::doProcessOptions(), main(), make_ParameterSet(), parse_document(), testing::BasicTesterEnvironment< ConfigurationClass >::ParseParameters(), and art::run_art_string_config().

{
  parse_document_(cet::includer(filename, maker), result);
} // parse_document()

void fhicl::parse_document	(	std::istream &	is,
		cet::filepath_maker &	maker,
		intermediate_table &	result
	)

Definition at line 864 of file parse.cc.

{
  parse_document_(cet::includer(is, maker), result);
} // parse_document()

void fhicl::parse_document ( std::string const &  s, intermediate_table &  result  )

inline

Definition at line 32 of file parse.h.

References parse_document().

  {
    std::istringstream is{s};
    cet::filepath_maker m;
    parse_document(is, m, result);
  }

void fhicl::parse_file_and_fill_db	(	std::string const &	filename,
		sqlite3 *	db
	)

Definition at line 48 of file DatabaseSupport.cc.

References fhicl::ParameterSetRegistry::exportTo(), make_ParameterSet(), and fhicl::ParameterSetRegistry::put().

Referenced by main().

{
  fhicl::ParameterSet top;
  cet::filepath_maker fpm;
  make_ParameterSet(filename, fpm, top);
  fhicl::ParameterSetRegistry::put(top);
  fhicl::ParameterSetRegistry::exportTo(out);
}

bool fhicl::parse_value_string	(	std::string const &	s,
		extended_value &	v,
		std::string &	unparsed
	)

Definition at line 802 of file parse.cc.

References evd::details::begin(), e, evd::details::end(), shims::lit(), parse_error, and s.

Referenced by fhicl::detail::decode(), and fhicl::detail::encode().

{
  typedef std::string::const_iterator iter_t;
  typedef qi::rule<iter_t> ws_t;
  ws_t whitespace = space | lit('#') >> *(char_ - eol) >> eol |
                    lit("//") >> *(char_ - eol) >> eol;
  value_parser<iter_t, ws_t> p;
  iter_t begin = s.begin();
  iter_t const end = s.end();
  bool const b =
    qi::phrase_parse(begin, end, p >> *whitespace, whitespace, result) &&
    begin == end;
  unparsed = std::string(begin, end);
  return b;
} // parse_value_string()

std::string fhicl::to_string

(

Protection

p

)

Definition at line 4 of file Protection.cc.

Referenced by fhicl::detail::HashParameterSetID::operator()().

{
  std::string result;
  switch (p) {
    case Protection::NONE:
      result = "NONE";
      break;
    case Protection::PROTECT_IGNORE:
      result = "PROTECT_IGNORE";
      break;
    case Protection::PROTECT_ERROR:
      result = "PROTECT_ERROR";
      break;
  }
  return result;
}

template<typename T >

std::function<bool()> fhicl::use_if	(	T *	p,
		NullaryConfigPredicate_t< T >	f
	)

Definition at line 21 of file ConfigPredicate.h.

References f.

  {
    return [p, f]() { return (p->*f)(); };
  }

template<typename T >

std::function<bool()> fhicl::use_unless	(	T *	p,
		NullaryConfigPredicate_t< T >	f
	)

Definition at line 28 of file ConfigPredicate.h.

References f.

  {
    return [p, f]() { return !(p->*f)(); };
  }