Namespaces | Classes | Typedefs | Enumerations | Functions
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

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.

enum fhicl::par_style
strong
Enumerator
REQUIRED 
REQUIRED_CONDITIONAL 
DEFAULT 
DEFAULT_CONDITIONAL 
OPTIONAL 
OPTIONAL_CONDITIONAL 
NTYPES 

Definition at line 37 of file ParameterArgumentTypes.h.

enum fhicl::par_type
strong
Enumerator
ATOM 
TABLE 
SEQ_VECTOR 
SEQ_ARRAY 
TUPLE 
DELEGATE 
NTYPES 

Definition at line 8 of file ParameterArgumentTypes.h.

8  {
9  ATOM,
10  TABLE,
11  SEQ_VECTOR,
12  SEQ_ARRAY,
13  TUPLE,
14  DELEGATE,
15  NTYPES
16  };
Definition: inflate.h:37
#define DELEGATE(CLASS, FUNC, OUTPUT,...)
Delegate (or function pointer)
Definition: FunctionBind.h:16
enum fhicl::Protection : unsigned char
strong
Enumerator
UNKNOWN 
NIL 
BOOL 
NUMBER 
COMPLEX 
STRING 
SEQUENCE 
TABLE 
TABLEID 

Definition at line 22 of file extended_value.h.

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().

33  {
34  return pt == par_type::ATOM;
35  }
bool fhicl::is_sequence ( par_type const  pt)
inline

Definition at line 25 of file ParameterArgumentTypes.h.

References SEQ_ARRAY, SEQ_VECTOR, and TUPLE.

26  {
27  return pt == par_type::SEQ_VECTOR || pt == par_type::SEQ_ARRAY ||
28  pt == par_type::TUPLE;
29  }
bool fhicl::is_table ( par_type const  pt)
inline

Definition at line 19 of file ParameterArgumentTypes.h.

References TABLE.

20  {
21  return pt == par_type::TABLE;
22  }
Definition: inflate.h:37
void fhicl::make_ParameterSet ( intermediate_table const &  tbl,
ParameterSet ps 
)
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().

29  {
30  return !std::isgraph(ch) || ch == '#' || ch == '/' || ch == ',' ||
31  ch == ']' || ch == '}';
32  }
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().

42  {
43  return maximally_munched(ch) || ch == '.' || ch == '[' || ch == ':';
44  }
bool maximally_munched(char const ch)
Definition: tokens.h:28
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().

48  {
49  return maximally_munched(ch);
50  }
bool maximally_munched(char const ch)
Definition: tokens.h:28
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().

36  {
37  return maximally_munched(ch) || ch == ')';
38  }
bool maximally_munched(char const ch)
Definition: tokens.h:28
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.

101  {
102  std::ostringstream config;
103  t.print_allowed_configuration(config);
104  return os << config.str();
105  }
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.

110  {
111  std::ostringstream config;
112  t.print_allowed_configuration(config);
113  return os << config.str();
114  }
void fhicl::parse_document ( std::string const &  filename,
cet::filepath_maker maker,
intermediate_table result 
)
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().

33  {
34  std::istringstream is{s};
36  parse_document(is, m, result);
37  }
const XML_Char * s
Definition: expat.h:262
void parse_document(std::string const &s, intermediate_table &result)
Definition: parse.h:32
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)
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.

22  {
23  return [p, f]() { return (p->*f)(); };
24  }
const char * p
Definition: xmltok.h:285
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.

29  {
30  return [p, f]() { return !(p->*f)(); };
31  }
const char * p
Definition: xmltok.h:285