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
struct	CondConfig
class	ConfigurationTable
struct	dbid_parser
class	DelegatedParameter
struct	dss_parser
class	extended_value
struct	has_insertion_operator
struct	hex_parser
class	intermediate_table
class	KeyMap
struct	KeysToIgnore
struct	MaybeUseFunction
struct	Name
class	NameStackRegistry
struct	NoInsert
class	OptionalAtom
class	OptionalDelegatedParameter
class	OptionalSequence
class	OptionalSequence< T,-1ull >
class	OptionalTable
class	OptionalTableAs
class	OptionalTuple
class	OptionalTupleAs
class	OptionalTupleAs< T(ARGS...)>
class	ParameterSet
class	ParameterSetID
class	ParameterSetRegistry
class	ParameterSetWalker
class	Printer
class	PrinterFor
class	PrinterForTypes
struct	real_parser
class	Sequence
class	Sequence< T,-1ull >
class	SHA1
class	Table
class	TableAs
class	TableFragment
class	Tuple
class	TupleAs
class	TupleAs< T(ARGS...)>
struct	uint_parser
class	Vec
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)
intermediate_table	parse_document (std::string const &filename, cet::filepath_maker &maker)
intermediate_table	parse_document (std::istream &is, cet::filepath_maker &maker)
intermediate_table	parse_document (std::string const &s)
std::string	to_string (Protection p)
std::ostream &	boost_test_print_type (std::ostream &os, ParameterSet const &pset)
std::ostream &	boost_test_print_type (std::ostream &os, Protection const protection)
std::ostream &	operator<< (std::ostream &os, Vec const &v)
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	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)

Detailed Description

Title: RFFHitFinderAlg Class Author: Wes Ketchum (wketc.nosp@m.hum@.nosp@m.lanl..nosp@m.gov)

Description: Class that runs the RFF HitFinder. Implements an RFFHitFitter, and takes the result and stores it in recob::Hit objects.

Input: recob::Wire Output: recob::Hit

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

std::ostream& fhicl::boost_test_print_type ( std::ostream &  os, ParameterSet const &  pset  )

inline

Definition at line 15 of file boost_test_print_pset.h.

  {
    return os << pset.to_indented_string();
  }

std::ostream& fhicl::boost_test_print_type	(	std::ostream &	os,
		Protection const	protection
	)

Definition at line 20 of file parse_document_test.cc.

  {
    return os << to_string(protection);
  }

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

Definition at line 8 of file DatabaseSupport.cc.

{
  // Parse file into a ParameterSet.
  cet::filepath_maker fpm;
  auto const top = ParameterSet::make(filename, fpm);
  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 19 of file DatabaseSupport.cc.

{
  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 fhicl::get_regex_replace_str

(

std::string const &

str

)

Definition at line 11 of file Name.cc.

  {
    return std::regex_replace(str, re, "\\$&");
  }

bool fhicl::is_atom ( par_type const  pt )

inline

Definition at line 32 of file ParameterArgumentTypes.h.

  {
    return pt == par_type::ATOM;
  }

bool fhicl::is_sequence ( par_type const  pt )

inline

Definition at line 25 of file ParameterArgumentTypes.h.

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

  {
    return pt == par_type::TABLE;
  }

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

Definition at line 16 of file make_ParameterSet.cc.

{
  ps = ParameterSet::make(tbl);
}

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

Definition at line 24 of file make_ParameterSet.cc.

{
  ps = ParameterSet::make(xval);
}

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

Definition at line 32 of file make_ParameterSet.cc.

{
  ps = ParameterSet::make(str);
}

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

Definition at line 40 of file make_ParameterSet.cc.

{
  ps = ParameterSet::make(filename, maker);
}

bool fhicl::maximally_munched ( char const  ch )

inline

Definition at line 28 of file tokens.h.

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

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

bool fhicl::maximally_munched_dss ( char const  ch )

inline

Definition at line 47 of file tokens.h.

  {
    return maximally_munched(ch);
  }

bool fhicl::maximally_munched_number ( char const  ch )

inline

Definition at line 35 of file tokens.h.

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

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

Definition at line 139 of file ParameterSetID.cc.

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

std::ostream& fhicl::operator<<	(	std::ostream &	os,
		Vec const &	v
	)

Definition at line 29 of file CondConfig.h.

  {
    return os << "Half-lengths are: (" << v()[0] << ", " << v()[1] << ", "
              << v()[2] << ")";
  }

template<typename T >

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

inline

Definition at line 104 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 106 of file Table.h.

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

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

Definition at line 720 of file parse.cc.

{
  return parse_document_(cet::includer{filename, maker});
}

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

Definition at line 726 of file parse.cc.

{
  return parse_document_(cet::includer(is, maker));
}

fhicl::intermediate_table fhicl::parse_document

(

std::string const &

s

)

Definition at line 732 of file parse.cc.

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

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

Definition at line 50 of file DatabaseSupport.cc.

{
  cet::filepath_maker fpm;
  auto const top = ParameterSet::make(filename, fpm);
  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 669 of file parse.cc.

{
  using ws_t = qi::rule<FwdIter>;
  ws_t whitespace = space | lit('#') >> *(char_ - eol) >> eol |
                    lit("//") >> *(char_ - eol) >> eol;
  value_parser<ws_t> p;
  auto begin = s.begin();
  auto 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.

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

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

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