Namespaces
	atom

	no_defaults

	sequence

	table

	yes_defaults

Classes
struct	AllowedConfiguration

class	AtomBase

class	DelegateBase

class	HashParameterSetID

class	Indentation

class	it_value_get

class	it_value_get< std::complex< U >, typename tt::disable_if< std::is_reference_v< std::complex< U > >\|\| std::is_pointer_v< std::complex< U > > >::type >

class	it_value_get< intermediate_table::sequence_t & >

class	it_value_get< intermediate_table::sequence_t >

class	it_value_get< intermediate_table::sequence_t const & >

class	it_value_get< intermediate_table::table_t & >

class	it_value_get< intermediate_table::table_t >

class	it_value_get< intermediate_table::table_t const & >

class	it_value_get< T, typename tt::disable_if< std::is_reference_v< T >\|\| std::is_pointer_v< T > >::type >

class	KeyAssembler

class	Keys

class	MaybeDisplayParent

class	ParameterBase

class	ParameterMetadata

class	ParameterWalker

struct	per_entry

struct	per_entry< 0, TUPLE >

class	per_thread_holder

class	Prettifier

class	PrettifierAnnotated

class	PrettifierPrefixAnnotated

class	PrintAllowedConfiguration

class	RegisterIfTableMember

class	SearchAllowedConfiguration

class	SequenceBase

class	SequenceKey

class	TableBase

class	TableMemberRegistry

struct	thread_hash_compare

class	ValidateThenSet

class	validationException

class	ValuePrinter

struct	void_t< decltype(typename T::Parameters{ std::declval< fhicl::Name >()})>

Typedefs
using	ps_atom_t = std::string

using	ps_sequence_t = std::vector< std::any >

using	ldbl = long double

using	key_t = std::string

using	name_t = std::string

using	cit_size_t = std::vector< std::size_t >::const_iterator

using	base_ptr = cet::exempt_ptr< ParameterBase >

Enumerations
enum	binding_modifier : unsigned char { binding_modifier::NONE, binding_modifier::PROTECT_IGNORE, binding_modifier::PROTECT_ERROR }

enum	print_mode { print_mode::raw, print_mode::annotated, print_mode::prefix_annotated }

Functions
bool	is_sequence (std::any const &val)

bool	is_table (std::any const &val)

bool	is_nil (std::any const &val)

ps_atom_t	encode (std::string const &)

ps_atom_t	encode (char const *)

ps_atom_t	encode (std::nullptr_t)

ps_atom_t	encode (bool)

ParameterSetID	encode (ParameterSet const &)

ps_atom_t	encode (std::uintmax_t)

template<class T >
std::enable_if_t< tt::is_uint< T >::value, ps_atom_t >	encode (T const &)

ps_atom_t	encode (std::intmax_t)

template<class T >
std::enable_if_t< tt::is_int< T >::value, ps_atom_t >	encode (T const &)

ps_atom_t	encode (ldbl)

template<class T >
std::enable_if_t< std::is_floating_point_v< T >, ps_atom_t >	encode (T const &)

template<class T >
ps_atom_t	encode (std::complex< T > const &)

template<class T >
ps_sequence_t	encode (std::vector< T > const &)

template<class T >
tt::disable_if_t< tt::is_numeric< T >::value, std::string >	encode (T const &)

void	decode (std::any const &, std::string &)

void	decode (std::any const &, std::nullptr_t &)

void	decode (std::any const &, bool &)

void	decode (std::any const &, ParameterSet &)

void	decode (std::any const &, std::uintmax_t &)

template<class T >
std::enable_if_t< tt::is_uint< T >::value >	decode (std::any const &, T &)

void	decode (std::any const &, std::intmax_t &)

template<class T >
std::enable_if_t< tt::is_int< T >::value >	decode (std::any const &, T &)

void	decode (std::any const &, ldbl &)

template<class T >
std::enable_if_t< std::is_floating_point_v< T > >	decode (std::any const &, T &)

void	decode (std::any const &, std::complex< ldbl > &)

template<class T >
void	decode (std::any const &, std::complex< T > &)

template<class T >
void	decode (std::any const &, std::vector< T > &)

template<typename U >
void	decode_tuple (std::any const &, U &tuple)

template<typename T , std::size_t SIZE>
void	decode (std::any const &a, std::array< T, SIZE > &result)

template<typename KEY , typename VALUE >
void	decode (std::any const &a, std::pair< KEY, VALUE > &result)

template<typename... ARGS>
void	decode (std::any const &a, std::tuple< ARGS... > &result)

template<class T >
tt::disable_if_t< tt::is_numeric< T >::value >	decode (std::any const &, T &)

std::any	encode (extended_value const &xval)

Keys	get_names (std::string const &key)

SequenceKey	get_sequence_indices (std::string const &key)

bool	find_an_any (cit_size_t it, cit_size_t const cend, std::any &a)

std::string	nl (std::size_t i=1)

std::string	printed_suffix (std::string const &key, std::size_t const sz)

std::string	print_prefix_annotated_info (std::string const &curr_info)

std::string	print_annotated_info (std::string const &curr_info, std::string const &cached_info)

bool	is_sequence_element (std::string const &key)

bool	is_table_member (std::string const &key)

std::size_t	index_for_sequence_element (std::string const &name)

template<typename L >
void	try_insert (L l, std::string const &key)

std::string	translate (error)

void	throwOnSQLiteFailure (int rc, char *msg=nullptr)

void	throwOnSQLiteFailure (sqlite3 db, char msg=nullptr)

std::function< bool()>	AlwaysUse ()

void	check_nargs_for_bounded_sequences (std::string const &key, std::size_t expected, std::size_t provided)

std::string	optional_parameter_message (bool const with_comment=true)

std::string	strip_first_containing_name (std::string const &key)

std::string	strip_all_containing_names (std::string const &key)

template<typename T >
std::set< std::string >	ensure_callable ()

std::set< std::string > &	concatenate_keys (std::set< std::string > &keys)

template<typename H , typename... T>
std::set< std::string > &	concatenate_keys (std::set< std::string > &keys, H const &h, T const &...t)

int	fhicl_get_impl (int argc, char **argv)

template<typename T >
std::string	name_of ()

template<>
std::string	name_of< std::string > ()

Typedef Documentation

using fhicl::detail::base_ptr = typedef cet::exempt_ptr<ParameterBase>

Definition at line 16 of file MaybeDisplayParent.h.

using fhicl::detail::cit_size_t = typedef std::vector<std::size_t>::const_iterator

Definition at line 70 of file ParameterSetImplHelpers.h.

using fhicl::detail::key_t = typedef std::string

Definition at line 69 of file KeyAssembler.h.

using fhicl::detail::ldbl = typedef long double

Definition at line 46 of file coding.h.

using fhicl::detail::name_t = typedef std::string

Definition at line 70 of file KeyAssembler.h.

using fhicl::detail::ps_atom_t = typedef std::string

Definition at line 44 of file coding.h.

using fhicl::detail::ps_sequence_t = typedef std::vector<std::any>

Definition at line 45 of file coding.h.

Enumeration Type Documentation

enum fhicl::detail::binding_modifier : unsigned char

strong

Enumerator
NONE
PROTECT_IGNORE
PROTECT_ERROR

Definition at line 5 of file binding_modifier.h.

                               : unsigned char {
     NONE,
     PROTECT_IGNORE,
     PROTECT_ERROR,
 #if 0 /* Preparation for issue #7231. */
       INITIAL,
       REPLACE,
       REPLACE_COMPAT,
       ADD_OR_REPLACE_COMPAT
 #endif
   };

enum fhicl::detail::print_mode

strong

Enumerator
raw
annotated
prefix_annotated

Definition at line 5 of file print_mode.h.

5 { raw, annotated, prefix_annotated };

fhicl::detail::print_mode::prefix_annotated

run_cnn_1class.raw

raw

Definition: run_cnn_1class.py:54

fhicl::detail::print_mode::annotated

Function Documentation

std::function<bool()> fhicl::detail::AlwaysUse ( )

inline

Definition at line 10 of file ConfigPredicate.h.

     {
       return []() { return true; };
     }

void fhicl::detail::check_nargs_for_bounded_sequences	(	std::string const &	key,
		std::size_t	expected,
		std::size_t	provided
	)

Definition at line 9 of file check_nargs_for_bounded_sequences.cc.

 {
   constexpr auto maybe_plural = [](std::size_t const nargs) {
     return nargs == 1ull ? "" : "s";
   };
   constexpr auto has_or_have = [](std::size_t const nargs) {
     return nargs == 1ull ? "has" : "have";
   };
   if (nargs != expected) {
     std::ostringstream oss;
     oss << '\n'
         << nargs << " value" << maybe_plural(nargs) << ' ' << has_or_have(nargs)
         << " been provided for the parameter with key:\n"
         << "  " << key << '\n'
         << "which expects " << expected << " value" << maybe_plural(expected)
         << '.';
     throw detail::validationException{oss.str().c_str()};
   }
 }

std::set<std::string>& fhicl::detail::concatenate_keys ( std::set< std::string > & keys )

inline

Definition at line 22 of file KeysToIgnore.h.

     {
       return keys;
     }

template<typename H , typename... T>

std::set<std::string>& fhicl::detail::concatenate_keys	(	std::set< std::string > &	keys,
		H const &	h,
		T const &...	t
	)

Definition at line 29 of file KeysToIgnore.h.

     {
       keys.insert(begin(h), end(h));
       return concatenate_keys(keys, t...);
     }

void fhicl::detail::decode	(	std::any const &	,
		std::string &
	)

void fhicl::detail::decode	(	std::any const &	,
		std::nullptr_t &
	)

void fhicl::detail::decode	(	std::any const &	,
		bool &
	)

void fhicl::detail::decode	(	std::any const &	,
		ParameterSet &
	)

void fhicl::detail::decode	(	std::any const &	,
		std::uintmax_t &
	)

template<class T >

std::enable_if_t< tt::is_uint< T >::value > fhicl::detail::decode	(	std::any const &	a,
		T &	result
	)

Definition at line 211 of file coding.h.

 {
   std::uintmax_t via;
   decode(a, via);
   result = boost::numeric_cast<T>(via);
 }

void fhicl::detail::decode	(	std::any const &	,
		std::intmax_t &
	)

template<class T >

std::enable_if_t< tt::is_int< T >::value > fhicl::detail::decode	(	std::any const &	a,
		T &	result
	)

Definition at line 222 of file coding.h.

 {
   std::intmax_t via;
   decode(a, via);
   result = boost::numeric_cast<T>(via);
 }

void fhicl::detail::decode	(	std::any const &	,
		ldbl &
	)

template<class T >

std::enable_if_t< std::is_floating_point_v< T > > fhicl::detail::decode	(	std::any const &	a,
		T &	result
	)

Definition at line 233 of file coding.h.

 {
   ldbl via;
   decode(a, via);
   result = via; // boost::numeric_cast<T>(via);
 }

void fhicl::detail::decode	(	std::any const &	,
		std::complex< ldbl > &
	)

template<class T >

void fhicl::detail::decode	(	std::any const &	a,
		std::complex< T > &	result
	)

Definition at line 244 of file coding.h.

 {
   std::complex<ldbl> via;
   decode(a, via);
   result = std::complex<T>{boost::numeric_cast<T>(via.real()),
                            boost::numeric_cast<T>(via.imag())};
 }

template<class T >

void fhicl::detail::decode	(	std::any const &	a,
		std::vector< T > &	result
	)

Definition at line 256 of file coding.h.

 {
   if (a.type() == typeid(std::string)) {
     typedef fhicl::extended_value extended_value;
     typedef extended_value::sequence_t sequence_t;
 
     std::string str;
     decode(a, str);
 
     extended_value xval;
     std::string unparsed;
     if (!parse_value_string(str, xval, unparsed) || !xval.is_a(SEQUENCE))
       throw fhicl::exception(type_mismatch, "error in sequence string:\n")
         << str << "\nat or before:\n"
         << unparsed;
 
     sequence_t const& seq = sequence_t(xval);
     result.clear();
     T via;
     for (auto const& e : seq) {
       decode(e.to_string(), via);
       result.push_back(via);
     }
   }
 
   else if (a.type() == typeid(ps_sequence_t)) {
     ps_sequence_t const& seq = std::any_cast<ps_sequence_t>(a);
     result.clear();
     T via;
     for (auto const& e : seq) {
       decode(e, via);
       result.push_back(via);
     }
   }
 
   else
     throw fhicl::exception(type_mismatch, "invalid sequence");
 }

template<typename T , std::size_t SIZE>

void fhicl::detail::decode	(	std::any const &	a,
		std::array< T, SIZE > &	result
	)

Definition at line 124 of file coding.h.

   {
     decode_tuple(a, result);
   }

template<typename KEY , typename VALUE >

void fhicl::detail::decode	(	std::any const &	a,
		std::pair< KEY, VALUE > &	result
	)

Definition at line 130 of file coding.h.

   {
     decode_tuple(a, result);
   }

template<typename... ARGS>

void fhicl::detail::decode	(	std::any const &	a,
		std::tuple< ARGS... > &	result
	)

Definition at line 136 of file coding.h.

   {
     decode_tuple(a, result);
   }

template<class T >

tt::disable_if_t< tt::is_numeric< T >::value > fhicl::detail::decode	(	std::any const &	a,
		T &	result
	)

Definition at line 353 of file coding.h.

 {
   result = std::any_cast<T>(a);
 }

template<typename U >

void fhicl::detail::decode_tuple	(	std::any const &	a,
		U &	tuple
	)

Definition at line 324 of file coding.h.

 {
   auto const seq = std::any_cast<ps_sequence_t>(a);
 
   constexpr std::size_t TUPLE_SIZE = std::tuple_size_v<U>;
 
   if (seq.size() != TUPLE_SIZE) {
     std::ostringstream errmsg;
     errmsg << "Number of expected arguments (" << TUPLE_SIZE
            << ") does not match "
            << "number of FHiCL sequence entries (" << seq.size() << "): [ ";
     for (auto ca = seq.begin(); ca != seq.cend(); ++ca) {
       std::string tmp;
       decode(*ca, tmp);
       errmsg << tmp;
       if (ca != seq.cend() - 1) {
         errmsg << ", ";
       }
     }
     errmsg << " ]";
     throw std::length_error(errmsg.str());
   }
 
   per_entry<TUPLE_SIZE - 1, U>::decode_tuple_entry(seq, result);
 }

std::any fhicl::detail::encode ( extended_value const & xval )

Definition at line 24 of file encode_extended_value.cc.

 {
   switch (xval.tag) {
   case NIL:
   case BOOL:
   case NUMBER:
   case STRING:
     return atom_t(xval);
 
   case COMPLEX: {
     complex_t const& cmplx = complex_t(xval);
     return '(' + cmplx.first + ',' + cmplx.second + ')';
   }
 
   case SEQUENCE: {
     ps_sequence_t result;
     sequence_t const& seq = sequence_t(xval);
     for (sequence_t::const_iterator it = seq.begin(), e = seq.end(); it != e;
          ++it)
       result.push_back(std::any(encode(*it)));
     return result;
   }
 
   case TABLE: {
     typedef table_t::const_iterator const_iterator;
     table_t const& tbl = table_t(xval);
     ParameterSet result;
     for (const_iterator it = tbl.begin(), e = tbl.end(); it != e; ++it) {
       if (!it->second.in_prolog)
         result.put(it->first, it->second);
     }
     return ParameterSetRegistry::put(result);
   }
 
   case TABLEID: {
     atom_t const& tableID = atom_t(xval);
     return ParameterSetID(tableID);
   }
 
   case UNKNOWN:
   default: {
     throw fhicl::exception(type_mismatch, "unknown extended value");
   }
   }
 } // encode()

ps_atom_t fhicl::detail::encode ( std::string const & value )

Definition at line 87 of file coding.cc.

 {
   bool is_quoted = value.size() >= 2 && value[0] == value.end()[-1] &&
                    (value[0] == '\"' || value[0] == '\'');
 
   std::string const& str = is_quoted ? value : '\'' + value + '\'';
 
   extended_value xval;
   std::string unparsed;
   if (!parse_value_string(str, xval, unparsed) || !xval.is_a(STRING))
     throw fhicl::exception(type_mismatch, "error in input string:\n")
       << str << "\nat or before:\n"
       << unparsed;
 
   return extended_value::atom_t(xval);
 }

ps_atom_t fhicl::detail::encode ( char const * value )

Definition at line 105 of file coding.cc.

 {
   return encode(std::string(value));
 }

ps_atom_t fhicl::detail::encode ( std::nullptr_t )

Definition at line 111 of file coding.cc.

 {
   return canon_nil();
 }

ps_atom_t fhicl::detail::encode ( bool value )

Definition at line 117 of file coding.cc.

 {
   return value ? literal_true() : literal_false();
 }

ParameterSetID fhicl::detail::encode ( ParameterSet const & value )

Definition at line 123 of file coding.cc.

 {
   return ParameterSetRegistry::put(value);
 }

ps_atom_t fhicl::detail::encode ( std::uintmax_t value )

Definition at line 129 of file coding.cc.

 {
   std::string result = lexical_cast<std::string>(value);
   if (result.size() > 6) {
     std::size_t sz = result.size() - 1;
     result.insert(1, ".");
     result += "e+" + lexical_cast<std::string>(sz);
   }
   return result;
 }

template<class T >

std::enable_if_t<tt::is_uint<T>::value, ps_atom_t> fhicl::detail::encode ( T const & )

ps_atom_t fhicl::detail::encode ( std::intmax_t value )

Definition at line 141 of file coding.cc.

 {
   std::string result = encode(std::uintmax_t(std::abs(value)));
   if (value < 0)
     result.insert(0, "-");
   return result;
 }

template<class T >

std::enable_if_t<tt::is_int<T>::value, ps_atom_t> fhicl::detail::encode ( T const & )

ps_atom_t fhicl::detail::encode ( ldbl value )

Definition at line 150 of file coding.cc.

 {
   if (value == std::numeric_limits<ldbl>::infinity())
     return '+' + literal_infinity();
   if (value == -std::numeric_limits<ldbl>::infinity())
     return '-' + literal_infinity();
 
   std::intmax_t chopped = static_cast<std::intmax_t>(value);
   if (static_cast<ldbl>(chopped) == value)
     return encode(chopped);
 
   std::string result;
   cet::canonical_number(lexical_cast<std::string>(value), result);
   return result;
 }

template<class T >

std::enable_if_t<std::is_floating_point_v<T>, ps_atom_t> fhicl::detail::encode ( T const & )

template<class T >

ps_atom_t fhicl::detail::encode ( std::complex< T > const & )

template<class T >

ps_sequence_t fhicl::detail::encode ( std::vector< T > const & )

template<class T >

tt::disable_if_t< tt::is_numeric< T >::value, std::string > fhicl::detail::encode ( T const & value )

Definition at line 200 of file coding.h.

 {
   return boost::lexical_cast<std::string>(value);
 }

template<typename T >

std::set<std::string> fhicl::detail::ensure_callable ( )

Definition at line 15 of file KeysToIgnore.h.

     {
       static_assert(tt::is_callable<T>::value);
       return T{}();
     }

int fhicl::detail::fhicl_get_impl	(	int	argc,
		char **	argv
	)

Definition at line 231 of file fhicl_get_impl.cc.

                                                      {
   supported_types_t const printer_for_types{};
   auto const maybe_opts = process_arguments(argc, argv, printer_for_types);
 
   if (std::holds_alternative<Help>(maybe_opts)) {
     std::cout << std::get<Help>(maybe_opts).msg;
     return 0;
   }
 
   auto const& opts = std::get<Options>(maybe_opts);
 
   auto const pset =
     fhicl::ParameterSet::make(opts.input_filename, *opts.policy);
 
   auto const& key = opts.parameter_key;
 
   if (opts.names_in) {
     print_table_names(pset, key, opts.allow_missing);
     return 0;
   }
 
   if (not pset.has_key(key)) {
     throw cet::exception{config} << "A parameter with the fully-qualified key '"
                                  << key << "' does not exist.";
   }
 
   if (not empty(opts.atom_as)) {
     printer_for_types.value_for_atom(pset, opts.atom_as, key);
     return 0;
   }
 
   if (not empty(opts.sequence_of)) {
     printer_for_types.value_for_sequence(pset, opts.sequence_of, key);
     return 0;
   }
 
   return 0;
 }
 catch (std::exception const& e) {
   std::cerr << e.what();
   return 1;
 }

bool fhicl::detail::find_an_any	(	cit_size_t	it,
		cit_size_t const	cend,
		std::any &	a
	)

inline

Definition at line 73 of file ParameterSetImplHelpers.h.

   {
     if (it == cend) {
       // If we got this far, that means the element must exist,
       // otherwise the previous recursive 'find_parameter' call would
       // have returned false.
       return true;
     }
 
     auto seq = std::any_cast<ps_sequence_t>(a);
     if (*it >= seq.size())
       return false;
 
     a = std::move(seq[*it]);
 
     return find_an_any(++it, cend, a);
   }

Keys fhicl::detail::get_names ( std::string const & key )

Definition at line 17 of file ParameterSetImplHelpers.cc.

   {
     std::vector<std::string> keys;
     boost::algorithm::split(keys, key, boost::algorithm::is_any_of("."));
 
     // Remove empty keys
     keys.erase(std::remove(keys.begin(), keys.end(), ""), keys.end());
 
     if (keys.empty())
       throw fhicl::exception(fhicl::cant_find, "vacuous key");
 
     std::string const last = keys.back();
     keys.pop_back();
 
     return Keys{keys, last};
   }

SequenceKey fhicl::detail::get_sequence_indices ( std::string const & key )

Definition at line 35 of file ParameterSetImplHelpers.cc.

   {
     // Split "name[0][5][1]" according to delimiters "][", "[", and "]"
     // to give {"name","0","5","1"};
     auto tokens = cet::split_by_regex(key, reBrackets);
 
     auto const name = tokens.front();
     tokens.erase(tokens.begin());
 
     std::vector<std::size_t> indices;
     cet::transform_all(
       tokens, std::back_inserter(indices), [](std::string const& index) {
         return std::stoul(index);
       });
     return SequenceKey{name, indices};
   }

std::size_t fhicl::detail::index_for_sequence_element ( std::string const & name )

Definition at line 110 of file printing_helpers.cc.

 {
   if (!is_sequence_element(name)) {
     throw exception{error::other,
                     "An error occurred while converting a name to a sequence "
                     "element index.\n"}
       << "The name '" << name << "' does not correspond to a sequence element.";
   }
   auto const b = name.find_last_of("[");
   assert(b != std::string::npos);
   auto const e = name.find_last_of("]");
   assert(e == name.length() - 1);
   auto const start = b + 1;
   assert(start < e);
   return std::stoull(name.substr(start, e - start));
 }

bool fhicl::detail::is_nil ( std::any const & val )

Definition at line 75 of file coding.cc.

 {
   bool result = false;
   if (!(is_table(val) || is_sequence(val))) {
     std::string str;
     atom_rep(val, str);
     result = (str == canon_nil());
   }
   return result;
 }

bool fhicl::detail::is_sequence ( std::any const & val )

inline

Definition at line 49 of file coding.h.

   {
     return val.type() == typeid(ps_sequence_t);
   }

bool fhicl::detail::is_sequence_element ( std::string const & key )

inline

Definition at line 64 of file printing_helpers.h.

   {
     auto pos = key.find_last_of(sequence::closing_brace());
     return pos != std::string::npos && pos == key.size() - 1;
   }

bool fhicl::detail::is_table ( std::any const & val )

inline

Definition at line 55 of file coding.h.

   {
     return val.type() == typeid(ParameterSetID);
   }

bool fhicl::detail::is_table_member ( std::string const & key )

inline

Definition at line 71 of file printing_helpers.h.

   {
     auto pos1 = key.find_last_of(".");
     if (pos1 == std::string::npos)
       return false;
 
     return not is_sequence_element(key);
   }

template<typename T >

std::string fhicl::detail::name_of ( )

Definition at line 61 of file Printer.h.

     {
       return cet::demangle_symbol(typeid(T).name());
     }

template<>

std::string fhicl::detail::name_of< std::string > ( )

Definition at line 68 of file Printer.h.

     {
       return "string";
     }

std::string fhicl::detail::nl ( std::size_t i = 1 )

inline

Definition at line 18 of file printing_helpers.h.

   {
     return std::string(i, '\n');
   }

std::string fhicl::detail::optional_parameter_message ( bool const with_comment = true )

inline

Definition at line 6 of file optional_parameter_message.h.

   {
     std::string result;
     if (with_comment) {
       result += "## ";
     }
     result += "Any parameters prefaced with '#' are optional.";
     return result;
   }

std::string fhicl::detail::print_annotated_info	(	std::string const &	curr_info,
		std::string const &	cached_info
	)

Definition at line 29 of file printing_helpers.cc.

 {
   if (!allowed_info(curr_info))
     return "";
   std::string const tag = "  # ";
   std::string const printed_info =
     curr_info == cached_info ? "\"\"" : curr_info;
   return tag + printed_info;
 }

std::string fhicl::detail::print_prefix_annotated_info ( std::string const & curr_info )

Definition at line 41 of file printing_helpers.cc.

 {
   std::string const printed_info = allowed_info(info) ? info : "";
   return "#SRC|" + printed_info + "|";
 }

std::string fhicl::detail::printed_suffix	(	std::string const &	key,
		std::size_t const	sz
	)

Definition at line 50 of file printing_helpers.cc.

 {
   std::string result;
 
   if (sz == size_t_max)
     return result;
 
   std::smatch m;
   if (std::regex_match(key, m, reSequenceElement) &&
       std::stoul(m[1]) != sz - 1) {
     result = ",";
   }
   return result;
 }

std::string fhicl::detail::strip_all_containing_names ( std::string const & key )

Definition at line 14 of file strip_containing_names.cc.

 {
   auto const pos = key.find_last_of(".") + 1;
   return key.substr(pos);
 }

std::string fhicl::detail::strip_first_containing_name ( std::string const & key )

Definition at line 7 of file strip_containing_names.cc.

 {
   auto const pos = key.find_first_of(".") + 1;
   return key.substr(pos);
 }

void fhicl::detail::throwOnSQLiteFailure	(	int	rc,
		char *	msg = `nullptr`
	)

Definition at line 41 of file ParameterSetRegistry.cc.

 {
   std::string const msgString{msg ? msg : ""};
   sqlite3_free(msg);
   if (errcode != SQLITE_OK) {
     // Caller's responsibility to make sure this really is an error
     // and not (say) SQLITE_ROW or SQLITE_DONE,
     throw exception(error::sql_error, "SQLite error:")
       << sqlite3_errstr(errcode) << " (" << errcode << ')'
       << (msgString.empty() ? "" : (std::string(": ") + msgString));
   }
 }

void fhicl::detail::throwOnSQLiteFailure	(	sqlite3 *	db,
		char *	msg = `nullptr`
	)

Definition at line 55 of file ParameterSetRegistry.cc.

 {
   if (db == nullptr) {
     sqlite3_free(msg);
     throw fhicl::exception(fhicl::error::cant_open_db) << "Can't open DB.";
   }
   auto const errcode = sqlite3_errcode(db);
   throwOnSQLiteFailure(errcode, msg);
 }

std::string fhicl::detail::translate ( error code )

Definition at line 12 of file exception.cc.

 {
   switch (code) {
   case cant_find:
     return "Can't find key";
   case cant_happen:
     return "Can't happen";
   case cant_insert:
     return "Can't insert key";
   case number_is_too_large:
     return "Excessive value";
   case parse_error:
     return "Parse error";
   case type_mismatch:
     return "Type mismatch";
   case protection_violation:
     return "Protection violation";
   case cant_open_db:
     return "Can't open DB";
   case sql_error:
     return "SQL error";
   case unimplemented:
     return "Unimplemented feature";
   case other:
     return "Other error";
   default:
     return "Unknown code";
   }
 }

template<typename L >

void fhicl::detail::try_insert	(	L	l,
		std::string const &	key
	)

Definition at line 11 of file try_blocks.h.

                                             {
     l(key);
   }
   catch (boost::bad_lexical_cast const& e) {
     throw fhicl::exception{cant_insert, key} << e.what();
   }
   catch (boost::bad_numeric_cast const& e) {
     throw fhicl::exception{cant_insert, key} << e.what();
   }
   catch (fhicl::exception const& e) {
     throw fhicl::exception{cant_insert, key, e};
   }
   catch (std::exception const& e) {
     throw fhicl::exception{cant_insert, key} << e.what();
   }

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation