fhicl::detail Namespace Reference

Namespaces
	atom
	no_defaults
	sequence
	table
	yes_defaults

Classes
struct	AllowedConfiguration
struct	void_t< decltype(typename T::Parameters{ std::declval< fhicl::Name >()})>
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

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
template<typename T >
using	insertion_expression_t = decltype(std::declval< std::ostream & >()<< std::declval< T const & >())
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 &)
template<typename TUPLE , size_t I>
auto	decode_entry (ps_sequence_t const &vec)
template<typename TUPLE , size_t... I>
void	decode_tuple_entries (ps_sequence_t const &vec, TUPLE &result, std::index_sequence< I... >)
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 (std::vector< std::size_t >::const_iterator it, std::vector< std::size_t >::const_iterator 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)
template<typename T >
std::string	maybe_insert (T const &t)
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)
std::ostream &	operator<< (std::ostream &os, TableBase const &t)
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 > ()

Variables
template<typename T , typename = void>
constexpr bool	has_insertion_operator {false}

Typedef Documentation

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

Definition at line 16 of file MaybeDisplayParent.h.

template<typename T >

using fhicl::detail::insertion_expression_t = typedef decltype(std::declval<std::ostream&>() << std::declval<T const&>())

Definition at line 12 of file maybe_insert.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.

{ raw, annotated, prefix_annotated };

Function Documentation

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

inline

Definition at line 10 of file ConfigPredicate.h.

Referenced by fhicl::Atom< T >::Atom(), fhicl::DelegatedParameter::DelegatedParameter(), fhicl::OptionalAtom< T >::OptionalAtom(), fhicl::OptionalDelegatedParameter::OptionalDelegatedParameter(), fhicl::OptionalSequence< T, N >::OptionalSequence(), fhicl::OptionalSequence< T,-1ull >::OptionalSequence(), fhicl::OptionalTable< T >::OptionalTable(), fhicl::OptionalTuple< T >::OptionalTuple(), fhicl::Sequence< T, N >::Sequence(), fhicl::Sequence< T,-1ull >::Sequence(), fhicl::Table< T, KeysToIgnore >::Table(), and fhicl::Tuple< T >::Tuple().

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

Referenced by fhicl::OptionalTuple< ARGS... >::do_prepare_elements_for_validation(), fhicl::OptionalSequence< art::InputTag >::do_prepare_elements_for_validation(), fhicl::Tuple< T >::do_prepare_elements_for_validation(), and fhicl::Sequence< float, 3u >::do_prepare_elements_for_validation().

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

Referenced by concatenate_keys(), and fhicl::KeysToIgnore< H, T >::operator()().

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

References util::begin(), concatenate_keys(), and util::end().

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

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

Referenced by decode(), art::decode(), decode_entry(), decode_tuple(), encode(), is_table(), fhicl::detail::it_value_get< T, typename tt::disable_if< std::is_reference_v< T >|| std::is_pointer_v< T > >::type >::operator()(), fhicl::detail::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 >::operator()(), and art::detail::path_specs().

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 214 of file coding.h.

References decode(), and value.

{
  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 225 of file coding.h.

References decode().

{
  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 236 of file coding.h.

References decode().

{
  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 247 of file coding.h.

References decode().

{
  std::complex<ldbl> via;
  decode(a, via);
  result = {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 259 of file coding.h.

References decode(), e, fhicl::extended_value::is_a(), fhicl::parse_value_string(), fhicl::SEQUENCE, and fhicl::type_mismatch.

{
  if (a.type() == typeid(std::string)) {
    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;

    auto const& seq = fhicl::extended_value::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 125 of file coding.h.

References decode_tuple().

  {
    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 132 of file coding.h.

References decode_tuple().

  {
    decode_tuple(a, result);
  }

template<typename... ARGS>

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

Definition at line 139 of file coding.h.

References decode_tuple().

  {
    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 351 of file coding.h.

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

template<typename TUPLE , size_t I>

auto fhicl::detail::decode_entry

(

ps_sequence_t const &

vec

)

Definition at line 301 of file coding.h.

References decode(), and fhicl::TUPLE.

  {
    std::tuple_element_t<I, TUPLE> result_elem;
    decode(vec.at(I), result_elem);
    return result_elem;
  }

template<typename U >

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

Definition at line 321 of file coding.h.

References decode(), decode_tuple_entries(), and tmp.

Referenced by decode(), and is_table().

{
  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());
  }

  decode_tuple_entries(seq, result, std::make_index_sequence<TUPLE_SIZE>());
  //  per_entry<TUPLE_SIZE - 1, U>::decode_tuple_entry(seq, result);
}

template<typename TUPLE , size_t... I>

void fhicl::detail::decode_tuple_entries	(	ps_sequence_t const &	vec,
		TUPLE &	result,
		std::index_sequence< I... >
	)

Definition at line 310 of file coding.h.

Referenced by decode_tuple().

  {
    ((std::get<I>(result) = decode_entry<TUPLE, I>(vec)), ...);
  }

std::any fhicl::detail::encode

(

extended_value const &

xval

)

Definition at line 24 of file encode_extended_value.cc.

References fhicl::BOOL, fhicl::COMPLEX, e, util::quantities::concepts::encode(), fhicl::NIL, fhicl::NUMBER, fhicl::ParameterSetRegistry::put(), fhicl::ParameterSet::put(), fhicl::SEQUENCE, fhicl::STRING, fhicl::TABLE, fhicl::TABLEID, fhicl::extended_value::tag, fhicl::type_mismatch, fhicl::UNKNOWN, and value.

{
  switch (xval.tag) {
  case NIL:
  case BOOL:
  case NUMBER:
  case STRING:
    return atom_t(xval);

  case COMPLEX: {
    auto const [real, imag] = complex_t(xval);
    return '(' + real + ',' + imag + ')';
  }

  case SEQUENCE: {
    ps_sequence_t result;
    for (auto const& e : sequence_t(xval)) {
      result.push_back(encode(e));
    }
    return result;
  }

  case TABLE: {
    ParameterSet result;
    for (auto const& [key, value] : table_t(xval)) {
      if (!value.in_prolog)
        result.put(key, value);
    }
    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 83 of file coding.cc.

References fhicl::extended_value::is_a(), fhicl::parse_value_string(), fhicl::STRING, and fhicl::type_mismatch.

Referenced by encode(), is_table(), fhicl::intermediate_table::put(), fhicl::ParameterSet::put(), and fhicl::intermediate_table::putNil().

{
  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 101 of file coding.cc.

References encode().

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

ps_atom_t fhicl::detail::encode

(

std::nullptr_t

)

Definition at line 107 of file coding.cc.

References canon_nil().

{
  return canon_nil();
}

ps_atom_t fhicl::detail::encode

(

bool

value

)

Definition at line 113 of file coding.cc.

References literal_false(), and literal_true().

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

ParameterSetID fhicl::detail::encode

(

ParameterSet const &

value

)

Definition at line 119 of file coding.cc.

References fhicl::ParameterSetRegistry::put().

{
  return ParameterSetRegistry::put(value);
}

ps_atom_t fhicl::detail::encode

(

std::uintmax_t

value

)

Definition at line 125 of file coding.cc.

References value.

{
  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 137 of file coding.cc.

References util::abs(), and encode().

{
  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 146 of file coding.cc.

References atom_rep(), fhicl::BOOL, canon_nil(), fhicl::COMPLEX, decode(), encode(), fhicl::ParameterSetRegistry::get(), fhicl::extended_value::is_a(), literal_infinity(), literal_true(), fhicl::NUMBER, fhicl::parse_value_string(), fhicl::type_mismatch, and value.

{
  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 203 of file coding.h.

References value.

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

References e, util::empty(), and fhicl::ParameterSet::make().

Referenced by main().

    {
  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	(	std::vector< std::size_t >::const_iterator	it,
		std::vector< std::size_t >::const_iterator const	cend,
		std::any &	a
	)

Definition at line 96 of file ParameterSetImplHelpers.cc.

Referenced by fhicl::ParameterSet::find_one_(), fhicl::ParameterSet::get_one_(), and fhicl::ParameterSet::key_is_type_().

  {
    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 38 of file ParameterSetImplHelpers.cc.

References fhicl::cant_find, and fhicl::detail::Keys::last().

Referenced by fhicl::ParameterSet::get_if_present(), fhicl::ParameterSet::has_key(), and fhicl::ParameterSet::key_is_type_().

  {
    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 78 of file ParameterSetImplHelpers.cc.

References fhicl::detail::SequenceKey::indices(), and fhicl::detail::SequenceKey::name().

Referenced by fhicl::ParameterSet::find_one_(), fhicl::ParameterSet::get_one_(), and fhicl::ParameterSet::key_is_type_().

  {
    // 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 111 of file printing_helpers.cc.

References e, is_sequence_element(), and fhicl::other.

Referenced by is_table_member().

{
  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 71 of file coding.cc.

References atom_rep(), canon_nil(), is_sequence(), and is_table().

Referenced by fhicl::ParameterSet::insert_or_replace_compatible_(), and is_table().

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

Referenced by atom_rep(), fhicl::detail::ValidateThenSet::before_action(), art::decode(), fhicl::detail::SearchAllowedConfiguration::form_absolute(), fhicl::ParameterSet::insert_or_replace_compatible_(), fhicl::ParameterSet::is_key_to_atom(), fhicl::ParameterSet::is_key_to_sequence(), is_nil(), fhicl::ParameterSet::stringify_(), fhicl::ParameterSet::walk(), and fhicl::detail::ParameterWalker< C >::walk_over().

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

References fhicl::detail::sequence::closing_brace().

Referenced by fhicl::detail::PrintAllowedConfiguration::before_action(), index_for_sequence_element(), is_table_member(), fhicl::detail::table::printed_prefix(), fhicl::detail::sequence::printed_prefix(), and fhicl::detail::atom::printed_prefix().

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

References decode(), decode_tuple(), encode(), is_nil(), and value.

Referenced by atom_rep(), fhicl::detail::ValuePrinter::before_action(), fhicl::detail::Prettifier::before_action(), fhicl::detail::SearchAllowedConfiguration::form_absolute(), fhicl::ParameterSet::get_pset_names(), fhicl::ParameterSet::insert_or_replace_compatible_(), fhicl::ParameterSet::is_key_to_atom(), fhicl::ParameterSet::is_key_to_table(), is_nil(), fhicl::detail::RegisterIfTableMember::RegisterIfTableMember(), fhicl::ParameterSet::stringify_(), fhicl::ParameterSet::walk(), and fhicl::detail::ParameterWalker< C >::walk_over().

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

References index_for_sequence_element(), and is_sequence_element().

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

  {
    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::maybe_insert

(

T const &

t

)

Definition at line 23 of file maybe_insert.h.

Referenced by fhicl::TupleAs< T(ARGS...)>::conversion_comment(), and fhicl::TableAs< T, Config >::conversion_comment().

  {
    if constexpr (has_insertion_operator<T>) {
      std::ostringstream os;
      os << "     with a default value of:\n"
         << "        " << t;
      return os.str();
    }
    return "     A default value is present, but it cannot be\n"
           "     printed out since no 'operator<<' overload has\n"
           "     been provided for the above type.";
  }

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.

References print_annotated_info(), print_prefix_annotated_info(), and printed_suffix().

Referenced by fhicl::detail::Prettifier::atom(), fhicl::detail::ValuePrinter::atom(), fhicl::detail::PrettifierAnnotated::atom(), fhicl::detail::PrettifierPrefixAnnotated::atom(), recob::dumper::DumpPCAxis(), recob::dumper::DumpSpacePoint(), fhicl::detail::PrettifierAnnotated::enter_sequence(), fhicl::detail::PrettifierPrefixAnnotated::enter_sequence(), fhicl::detail::PrettifierAnnotated::enter_table(), fhicl::detail::PrettifierPrefixAnnotated::enter_table(), fhicl::detail::ValuePrinter::exit_sequence(), fhicl::detail::Prettifier::exit_sequence(), fhicl::detail::PrettifierAnnotated::exit_sequence(), fhicl::detail::PrettifierPrefixAnnotated::exit_sequence(), fhicl::detail::ValuePrinter::exit_table(), fhicl::detail::Prettifier::exit_table(), fhicl::detail::PrettifierAnnotated::exit_table(), fhicl::detail::PrettifierPrefixAnnotated::exit_table(), fhicl::detail::Prettifier::maybe_nl_(), and fhicl::detail::ValuePrinter::maybe_nl_().

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

std::ostream & fhicl::detail::operator<<	(	std::ostream &	os,
		TableBase const &	t
	)

Definition at line 139 of file TableBase.cc.

References fhicl::detail::TableBase::print_allowed_configuration().

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

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

inline

Definition at line 6 of file optional_parameter_message.h.

Referenced by fhicl::detail::ValidateThenSet::check_keys(), and fhicl::detail::TableBase::print_allowed_configuration().

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

Referenced by fhicl::detail::PrettifierAnnotated::atom(), fhicl::detail::PrettifierAnnotated::enter_sequence(), fhicl::detail::PrettifierAnnotated::enter_table(), and nl().

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

Referenced by fhicl::detail::PrettifierPrefixAnnotated::atom(), fhicl::detail::PrettifierPrefixAnnotated::enter_sequence(), fhicl::detail::PrettifierPrefixAnnotated::enter_table(), and nl().

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

Referenced by fhicl::detail::Prettifier::atom(), fhicl::detail::ValuePrinter::atom(), fhicl::detail::PrettifierAnnotated::atom(), fhicl::detail::PrettifierPrefixAnnotated::atom(), fhicl::detail::ValuePrinter::exit_sequence(), fhicl::detail::Prettifier::exit_sequence(), fhicl::detail::PrettifierAnnotated::exit_sequence(), fhicl::detail::PrettifierPrefixAnnotated::exit_sequence(), fhicl::detail::Prettifier::exit_table(), fhicl::detail::ValuePrinter::exit_table(), fhicl::detail::PrettifierAnnotated::exit_table(), fhicl::detail::PrettifierPrefixAnnotated::exit_table(), and nl().

{
  using namespace std::string_literals;
  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 = ","s;
  }
  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.

Referenced by fhicl::detail::ValidateThenSet::before_action(), fhicl::detail::ValidateThenSet::delegated_parameter(), fhicl::OptionalSequence< T, N >::do_preset_value(), fhicl::Sequence< float, 3u >::do_preset_value(), fhicl::OptionalSequence< T,-1ull >::do_preset_value(), fhicl::Sequence< T,-1ull >::do_preset_value(), fhicl::Atom< T >::do_set_value(), fhicl::OptionalAtom< T >::do_set_value(), fhicl::detail::ValidateThenSet::enter_sequence(), fhicl::DelegatedParameter::get(), fhicl::OptionalDelegatedParameter::get_if_present(), fhicl::OptionalDelegatedParameter::hasValue(), fhicl::detail::TableBase::maybe_select_pset(), and fhicl::detail::TableBase::select_pset().

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

References fhicl::sql_error.

Referenced by fhicl::ParameterSetRegistry::exportTo(), fhicl::ParameterSetRegistry::find_(), fhicl::ParameterSetRegistry::importFrom(), throwOnSQLiteFailure(), and fhicl::ParameterSetRegistry::~ParameterSetRegistry().

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

References fhicl::cant_open_db, and throwOnSQLiteFailure().

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

References fhicl::cant_find, fhicl::cant_happen, fhicl::cant_insert, fhicl::cant_open_db, fhicl::number_is_too_large, fhicl::other, fhicl::parse_error, fhicl::protection_violation, fhicl::sql_error, fhicl::type_mismatch, and fhicl::unimplemented.

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

References fhicl::cant_insert, and e.

Referenced by fhicl::ParameterSet::put(), fhicl::ParameterSet::put_or_replace(), and fhicl::ParameterSet::put_or_replace_compatible().

      {
    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();
  }

Variable Documentation

template<typename T , typename = void>

constexpr bool fhicl::detail::has_insertion_operator {false}

Definition at line 15 of file maybe_insert.h.