fhicl::detail Namespace Reference

Namespaces
	atom
	no_defaults
	sequence
	table
	yes_defaults

Classes
struct	AllowedConfiguration
struct	AllowedConfiguration< T, cet::enable_if_type_exists_t< typename T::Parameters > >
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< std::complex< U > >::value|| std::is_pointer< std::complex< U > >::value >::type >
class	it_value_get< T, typename tt::disable_if< std::is_reference< T >::value|| std::is_pointer< T >::value >::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	KeyAssembler
class	Keys
class	MaybeDisplayParent
class	ParameterBase
class	ParameterMetadata
class	ParameterWalker
struct	per_entry
struct	per_entry< 0, TUPLE >
class	Prettifier
class	PrettifierAnnotated
class	PrettifierPrefixAnnotated
class	PrintAllowedConfiguration
class	RegisterIfTableMember
class	SearchAllowedConfiguration
class	SequenceBase
class	SequenceKey
class	TableBase
class	TableMemberRegistry
class	ValidateThenSet
class	validationException

Typedefs
typedef std::string	ps_atom_t
typedef std::vector< boost::any >	ps_sequence_t
typedef long double	ldbl
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 (boost::any const &val)
bool	is_table (boost::any const &val)
bool	is_nil (boost::any const &val)
ps_atom_t	encode (std::string const &)
ps_atom_t	encode (char const *)
ps_atom_t	encode (void *)
ps_atom_t	encode (bool)
ParameterSetID	encode (ParameterSet const &)
ps_atom_t	encode (std::uintmax_t)
template<class T >
tt::enable_if< tt::is_uint< T >::value, ps_atom_t >::type	encode (T const &)
ps_atom_t	encode (std::intmax_t)
template<class T >
tt::enable_if< tt::is_int< T >::value, ps_atom_t >::type	encode (T const &)
ps_atom_t	encode (ldbl)
template<class T >
tt::enable_if< tt::is_floating_point< T >::value, ps_atom_t >::type	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< tt::is_numeric< T >::value, std::string >::type	encode (T const &)
void	decode (boost::any const &, std::string &)
void	decode (boost::any const &, void *&)
void	decode (boost::any const &, bool &)
void	decode (boost::any const &, ParameterSet &)
void	decode (boost::any const &, std::uintmax_t &)
template<class T >
tt::enable_if< tt::is_uint< T >::value, void >::type	decode (boost::any const &, T &)
void	decode (boost::any const &, std::intmax_t &)
template<class T >
tt::enable_if< tt::is_int< T >::value, void >::type	decode (boost::any const &, T &)
void	decode (boost::any const &, ldbl &)
template<class T >
tt::enable_if< tt::is_floating_point< T >::value, void >::type	decode (boost::any const &, T &)
void	decode (boost::any const &, std::complex< ldbl > &)
template<class T >
void	decode (boost::any const &, std::complex< T > &)
template<class T >
void	decode (boost::any const &, std::vector< T > &)
template<typename U >
void	decode_tuple (boost::any const &, U &tuple)
template<typename T , std::size_t SIZE>
void	decode (boost::any const &a, std::array< T, SIZE > &result)
template<typename KEY , typename VALUE >
void	decode (boost::any const &a, std::pair< KEY, VALUE > &result)
template<typename... ARGS>
void	decode (boost::any const &a, std::tuple< ARGS... > &result)
template<class T >
tt::disable_if< tt::is_numeric< T >::value, void >::type	decode (boost::any const &, T &)
boost::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, boost::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)
template<typename L >
void	try_insert (L l, std::string const &key)
std::string	translate (error)
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)

Typedef Documentation

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

Definition at line 17 of file MaybeDisplayParent.h.

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

Definition at line 108 of file ParameterSetImplHelpers.h.

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

Definition at line 71 of file KeyAssembler.h.

typedef long double fhicl::detail::ldbl

Definition at line 47 of file coding.h.

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

Definition at line 72 of file KeyAssembler.h.

typedef std::string fhicl::detail::ps_atom_t

Definition at line 45 of file coding.h.

typedef std::vector<boost::any> fhicl::detail::ps_sequence_t

Definition at line 46 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 7 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::DelegatedParameter::DelegatedParameter(), fhicl::OptionalDelegatedParameter::OptionalDelegatedParameter(), fhicl::OptionalTuple< TYPES >::OptionalTuple(), and fhicl::Tuple< TYPES >::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 8 of file check_nargs_for_bounded_sequences.cc.

Referenced by fhicl::OptionalSequence< Table< T >< art::RootInputFileSequence::Config::SecondaryFile > >::do_prepare_elements_for_validation(), fhicl::OptionalTuple< ARGS... >::do_prepare_elements_for_validation(), fhicl::Sequence< float, 3u >::do_prepare_elements_for_validation(), and fhicl::Tuple< TYPES >::do_prepare_elements_for_validation().

{
  auto maybe_plural = [](std::size_t const nargs) {
    return nargs == 1ull ? "" : "s";
  };
  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 23 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 30 of file KeysToIgnore.h.

References evd::details::begin(), concatenate_keys(), and evd::details::end().

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

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

Referenced by art::decode(), decode(), decode_tuple(), fhicl::detail::per_entry< SIZE, TUPLE >::decode_tuple_entry(), fhicl::detail::per_entry< 0, TUPLE >::decode_tuple_entry(), encode(), fhicl::ParameterSet::get_one_(), is_table(), fhicl::detail::it_value_get< T, typename tt::disable_if< std::is_reference< T >::value|| std::is_pointer< T >::value >::type >::operator()(), and fhicl::detail::it_value_get< std::complex< U >, typename tt::disable_if< std::is_reference< std::complex< U > >::value|| std::is_pointer< std::complex< U > >::value >::type >::operator()().

void fhicl::detail::decode	(	boost::any const &	,
		void *&
	)

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

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

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

template<class T >

tt::enable_if< tt::is_uint< T >::value, void >::type fhicl::detail::decode	(	boost::any const &	a,
		T &	result
	)

Definition at line 222 of file coding.h.

References decode(), and fhicl::detail::atom::value().

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

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

template<class T >

tt::enable_if< tt::is_int< T >::value, void >::type fhicl::detail::decode	(	boost::any const &	a,
		T &	result
	)

Definition at line 233 of file coding.h.

References decode(), and fhicl::detail::atom::value().

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

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

template<class T >

tt::enable_if< tt::is_floating_point< T >::value, void >::type fhicl::detail::decode	(	boost::any const &	a,
		T &	result
	)

Definition at line 244 of file coding.h.

References decode().

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

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

template<class T >

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

Definition at line 255 of file coding.h.

References decode().

{
  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	(	boost::any const &	a,
		std::vector< T > &	result
	)

Definition at line 267 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)) {
    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 (sequence_t::const_iterator it = seq.begin(), e = seq.end(); it != e;
         ++it) {
      decode(it->to_string(), via);
      result.push_back(via);
    }
  }

  else if (a.type() == typeid(ps_sequence_t)) {
    ps_sequence_t const& seq = boost::any_cast<ps_sequence_t>(a);
    result.clear();
    T via;
    for (ps_sequence_t::const_iterator it = seq.begin(), e = seq.end(); it != e;
         ++it) {
      decode(*it, via);
      result.push_back(via);
    }
  }

  else
    throw fhicl::exception(type_mismatch, "invalid sequence");
}

template<typename T , std::size_t SIZE>

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

Definition at line 129 of file coding.h.

References decode_tuple().

    {
      decode_tuple(a, result);
    }

template<typename KEY , typename VALUE >

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

Definition at line 135 of file coding.h.

References decode_tuple().

    {
      decode_tuple(a, result);
    }

template<typename... ARGS>

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

Definition at line 141 of file coding.h.

References decode_tuple().

    {
      decode_tuple(a, result);
    }

template<class T >

tt::disable_if< tt::is_numeric< T >::value, void >::type fhicl::detail::decode	(	boost::any const &	a,
		T &	result
	)

Definition at line 366 of file coding.h.

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

template<typename U >

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

Definition at line 337 of file coding.h.

References decode(), fhicl::detail::per_entry< SIZE, TUPLE >::decode_tuple_entry(), tmp, and fhicl::detail::atom::value().

Referenced by decode(), and is_table().

{
  ps_sequence_t const& seq = boost::any_cast<ps_sequence_t>(a);

  constexpr std::size_t TUPLE_SIZE = std::tuple_size<U>::value;

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

boost::any fhicl::detail::encode

(

extended_value const &

xval

)

Definition at line 25 of file encode_extended_value.cc.

References shims::map< Key, T, Compare, Allocator >::begin(), fhicl::BOOL, fhicl::COMPLEX, e, encode(), shims::map< Key, T, Compare, Allocator >::end(), 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, and fhicl::UNKNOWN.

{
  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(boost::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.

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(), fhicl::ParameterSet::put_or_replace(), fhicl::ParameterSet::put_or_replace_compatible(), 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 105 of file coding.cc.

References encode().

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

ps_atom_t fhicl::detail::encode

(

void *

)

Definition at line 111 of file coding.cc.

References canon_nil().

{
  return canon_nil();
}

ps_atom_t fhicl::detail::encode

(

bool

value

)

Definition at line 117 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 123 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 129 of file coding.cc.

References fhicl::detail::atom::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 >

tt::enable_if<tt::is_uint<T>::value, ps_atom_t>::type fhicl::detail::encode

(

T const &

)

ps_atom_t fhicl::detail::encode

(

std::intmax_t

value

)

Definition at line 141 of file coding.cc.

References encode().

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

template<class T >

tt::enable_if<tt::is_int<T>::value, ps_atom_t>::type fhicl::detail::encode

(

T const &

)

ps_atom_t fhicl::detail::encode

(

ldbl

value

)

Definition at line 150 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 fhicl::detail::atom::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 >

tt::enable_if<tt::is_floating_point<T>::value, ps_atom_t>::type 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< tt::is_numeric< T >::value, std::string >::type fhicl::detail::encode

(

T const &

value

)

Definition at line 211 of file coding.h.

References fhicl::detail::atom::value().

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

template<typename T >

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

(

)

Definition at line 16 of file KeysToIgnore.h.

References TEMPLATE_ARG.

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

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

inline

Definition at line 111 of file ParameterSetImplHelpers.h.

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 const seq = boost::any_cast<ps_sequence_t>(a);

      if (*it >= seq.size())
        return false;

      a = seq[*it];

      return find_an_any(++it, cend, a);
    }

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

inline

Definition at line 42 of file ParameterSetImplHelpers.h.

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

inline

Definition at line 86 of file ParameterSetImplHelpers.h.

References geo::vect::indices().

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, R"((\]\[|\[|\]))");

      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};
    }

bool fhicl::detail::is_nil

(

boost::any const &

val

)

Definition at line 75 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 ( boost::any const &  val )

inline

Definition at line 50 of file coding.h.

Referenced by atom_rep(), 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 67 of file printing_helpers.h.

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

Referenced by fhicl::detail::PrintAllowedConfiguration::before_action(), 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 ( boost::any const &  val )

inline

Definition at line 56 of file coding.h.

References decode(), decode_tuple(), encode(), is_nil(), and fhicl::detail::atom::value().

Referenced by atom_rep(), 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 74 of file printing_helpers.h.

References is_sequence_element().

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

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

      return is_sequence_element(key) ? false : true;
    }

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

inline

Definition at line 21 of file printing_helpers.h.

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

Referenced by fhicl::detail::Prettifier::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::Prettifier::exit_sequence(), fhicl::detail::PrettifierAnnotated::exit_sequence(), fhicl::detail::PrettifierPrefixAnnotated::exit_sequence(), fhicl::detail::Prettifier::exit_table(), fhicl::detail::PrettifierAnnotated::exit_table(), fhicl::detail::PrettifierPrefixAnnotated::exit_table(), and fhicl::detail::Prettifier::maybe_nl_().

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

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

inline

Definition at line 7 of file optional_parameter_message.h.

Referenced by fhicl::detail::ValidateThenSet::check_keys(), and art::detail::describe().

    {
      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 27 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 39 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 48 of file printing_helpers.cc.

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

{
  std::string result;

  if (sz == size_t_max)
    return result;

  std::smatch m;
  if (std::regex_match(key, m, std::regex{R"(.*\[(\d+)\])"}) &&
      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.

Referenced by fhicl::detail::ParameterMetadata::set_key().

{
  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::detail::ValidateThenSet::enter_sequence(), fhicl::DelegatedParameter::get(), fhicl::OptionalDelegatedParameter::get_if_present(), and fhicl::OptionalDelegatedParameter::hasValue().

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

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

Definition at line 32 of file ParameterSetRegistry.cc.

References fhicl::cant_open_db, and fhicl::sql_error.

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

{
  std::string const msgString{msg ? msg : ""};
  sqlite3_free(msg);
  if (db == nullptr) {
    throw fhicl::exception(fhicl::error::cant_open_db) << "Can't open DB.";
  }
  auto errcode = sqlite3_errcode(db);
  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
      << "): " << sqlite3_errmsg(db)
      << (msgString.empty() ? "" : (std::string(". ") + msgString));
  }
}

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