fhicl Namespace Reference

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 &str)
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)

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
	)

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

std::string const fhicl::get_regex_replace_str

(

std::string const &

str

)

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

bool fhicl::is_atom ( par_type const  pt )

inline

Definition at line 32 of file ParameterArgumentTypes.h.

References ATOM.

Referenced by 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.

  {
    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.

  {
    return pt == par_type::TABLE;
  }

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

Referenced by evdb::ServiceTable::ApplyEdits(), and meta::MetadataParse::MetadataParse().

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

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

void fhicl::make_ParameterSet	(	std::string const &	filename,
		cet::filepath_maker &	maker,
		ParameterSet &	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 == ')';
  }

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

template<typename T >

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

inline

Definition at line 100 of file OptionalTable.h.

References gen_flatrecord::config, and confusionMatrixTree::t.

  {
    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 109 of file Table.h.

References gen_flatrecord::config, and confusionMatrixTree::t.

  {
    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
	)

Referenced by meta::MetadataParse::MetadataParse(), and parse_document().

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

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

inline

Definition at line 32 of file parse.h.

References m, and 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
	)

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

Referenced by fhicl::detail::decode().

std::string fhicl::to_string

(

Protection

p

)

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

template<typename T >

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

Definition at line 21 of file ConfigPredicate.h.

References MakeMiniprodValidationCuts::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 MakeMiniprodValidationCuts::f.

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