#include <ParameterSet.h>

Public Types
using	ps_atom_t = fhicl::detail::ps_atom_t

using	ps_sequence_t = fhicl::detail::ps_sequence_t

using	annot_t = std::unordered_map< std::string, std::string >

Public Member Functions
bool	is_empty () const

ParameterSetID	id () const

std::string	to_string () const

std::string	to_compact_string () const

std::string	to_indented_string () const

std::string	to_indented_string (unsigned initial_indent_level) const

std::string	to_indented_string (unsigned initial_indent_level, bool annotate) const

std::string	to_indented_string (unsigned initial_indent_level, detail::print_mode pm) const

std::vector< std::string >	get_names () const

std::vector< std::string >	get_pset_names () const

std::vector< std::string >	get_all_keys () const

bool	has_key (std::string const &key) const

bool	is_key_to_table (std::string const &key) const

bool	is_key_to_sequence (std::string const &key) const

bool	is_key_to_atom (std::string const &key) const

template<class T >
std::optional< T >	get_if_present (std::string const &key) const

template<class T , class Via >
std::optional< T >	get_if_present (std::string const &key, T convert(Via const &)) const

template<class T >
bool	get_if_present (std::string const &key, T &value) const

template<class T , class Via >
bool	get_if_present (std::string const &key, T &value, T convert(Via const &)) const

template<class T >
T	get (std::string const &key) const

template<class T , class Via >
T	get (std::string const &key, T convert(Via const &)) const

template<class T >
T	get (std::string const &key, T const &default_value) const

template<class T , class Via >
T	get (std::string const &key, T const &default_value, T convert(Via const &)) const

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

void	walk (ParameterSetWalker &psw) const

void	put (std::string const &key)

template<class T >
void	put (std::string const &key, T const &value)

void	put_or_replace (std::string const &key)

template<class T >
void	put_or_replace (std::string const &key, T const &value)

template<class T >
void	put_or_replace_compatible (std::string const &key, T const &value)

bool	erase (std::string const &key)

bool	operator== (ParameterSet const &other) const

bool	operator!= (ParameterSet const &other) const

template<>
void	put (std::string const &key, fhicl::extended_value const &value)

Static Public Member Functions
static ParameterSet	make (intermediate_table const &tbl)

static ParameterSet	make (extended_value const &xval)

static ParameterSet	make (std::string const &str)

static ParameterSet	make (std::string const &filename, cet::filepath_maker &maker)

Private Types
using	map_t = std::map< std::string, std::any >

using	map_iter_t = map_t::const_iterator

Private Member Functions
void	insert_ (std::string const &key, std::any const &value)

void	insert_or_replace_ (std::string const &key, std::any const &value)

void	insert_or_replace_compatible_ (std::string const &key, std::any const &value)

std::string	to_string_ (bool compact=false) const

std::string	stringify_ (std::any const &a, bool compact=false) const

bool	key_is_type_ (std::string const &key, std::function< bool(std::any const &)> func) const

template<class T >
std::optional< T >	get_one_ (std::string const &key) const

bool	find_one_ (std::string const &key) const

std::optional< ParameterSet >	descend_ (std::vector< std::string > const &names) const

Private Attributes
map_t	mapping_

annot_t	srcMapping_

ParameterSetID	id_

Detailed Description

Definition at line 36 of file ParameterSet.h.

Member Typedef Documentation

using fhicl::ParameterSet::annot_t = std::unordered_map<std::string, std::string>

Definition at line 40 of file ParameterSet.h.

using fhicl::ParameterSet::map_iter_t = map_t::const_iterator

private

Definition at line 123 of file ParameterSet.h.

using fhicl::ParameterSet::map_t = std::map<std::string, std::any>

private

Definition at line 122 of file ParameterSet.h.

using fhicl::ParameterSet::ps_atom_t = fhicl::detail::ps_atom_t

Definition at line 38 of file ParameterSet.h.

using fhicl::ParameterSet::ps_sequence_t = fhicl::detail::ps_sequence_t

Definition at line 39 of file ParameterSet.h.

Member Function Documentation

std::optional< ParameterSet > ParameterSet::descend_ ( std::vector< std::string > const & names ) const

private

Definition at line 223 of file ParameterSet.cc.

 {
   if (empty(names)) {
     return std::make_optional(*this);
   }
   ParameterSet const* p{this};
   std::optional<ParameterSet> result;
   for (auto const& name : names) {
     if (!p->find_one_(name)) {
       return std::nullopt;
     }
     if (!p->is_key_to_table(name)) {
       return std::nullopt;
     }
 
     if (result = p->get_one_<ParameterSet>(name); not result) {
       return std::nullopt;
     }
     p = &result.value();
   }
   return result;
 }

bool ParameterSet::erase ( std::string const & key )

Definition at line 338 of file ParameterSet.cc.

 {
   bool const did_erase{1u == mapping_.erase(key)};
   id_.invalidate();
   return did_erase;
 }

bool ParameterSet::find_one_ ( std::string const & key ) const

private

Definition at line 209 of file ParameterSet.cc.

 {
   auto skey = detail::get_sequence_indices(simple_key);
 
   auto it = mapping_.find(skey.name());
   if (it == mapping_.end()) {
     return false;
   }
 
   auto a = it->second;
   return detail::find_an_any(skey.indices().cbegin(), skey.indices().cend(), a);
 }

template<class T >

T fhicl::ParameterSet::get ( std::string const & key ) const

Definition at line 271 of file ParameterSet.h.

 {
   auto result = get_if_present<T>(key);
   return result ? *result : throw fhicl::exception(cant_find, key);
 }

template<class T , class Via >

T fhicl::ParameterSet::get	(	std::string const &	key,
		T	convertVia const &
	)		const

Definition at line 279 of file ParameterSet.h.

 {
   auto result = get_if_present<T>(key, convert);
   return result ? *result : throw fhicl::exception(cant_find, key);
 }

template<class T >

T fhicl::ParameterSet::get	(	std::string const &	key,
		T const &	default_value
	)		const

Definition at line 287 of file ParameterSet.h.

 {
   auto result = get_if_present<T>(key);
   return result ? *result : default_value;
 }

template<class T , class Via >

T fhicl::ParameterSet::get	(	std::string const &	key,
		T const &	default_value,
		T	convertVia const &
	)		const

Definition at line 295 of file ParameterSet.h.

 {
   auto result = get_if_present<T>(key, convert);
   return result ? *result : default_value;
 }

vector< string > ParameterSet::get_all_keys ( ) const

Definition at line 201 of file ParameterSet.cc.

 {
   KeyAssembler ka;
   walk(ka);
   return ka.result();
 }

template<class T >

std::optional< T > fhicl::ParameterSet::get_if_present ( std::string const & key ) const

Definition at line 224 of file ParameterSet.h.

 {
   auto keys = detail::get_names(key);
   if (auto ps = descend_(keys.tables())) {
     return ps->get_one_<T>(keys.last());
   }
   return std::nullopt;
 }

template<class T , class Via >

std::optional< T > fhicl::ParameterSet::get_if_present	(	std::string const &	key,
		T	convertVia const &
	)		const

Definition at line 235 of file ParameterSet.h.

 {
   auto go_between = get_if_present<Via>(key);
   if (not go_between) {
     return std::nullopt;
   }
   return std::make_optional(convert(*go_between));
 } // get_if_present<>()

template<class T >

bool fhicl::ParameterSet::get_if_present	(	std::string const &	key,
		T &	value
	)		const

Definition at line 247 of file ParameterSet.h.

 {
   if (auto present_parameter = get_if_present<T>(key)) {
     value = *present_parameter;
     return true;
   }
   return false;
 }

template<class T , class Via >

bool fhicl::ParameterSet::get_if_present	(	std::string const &	key,
		T &	value,
		T	convertVia const &
	)		const

Definition at line 258 of file ParameterSet.h.

 {
   if (auto present_parameter = get_if_present<T>(key, convert)) {
     result = *present_parameter;
     return true;
   }
   return false;
 } // get_if_present<>()

vector< string > ParameterSet::get_names ( ) const

Definition at line 179 of file ParameterSet.cc.

 {
   vector<string> keys;
   cet::transform_all(mapping_, std::back_inserter(keys), [](auto const& pr) {
     return pr.first;
   });
   return keys;
 }

template<class T >

std::optional< T > fhicl::ParameterSet::get_one_ ( std::string const & key ) const

private

Definition at line 321 of file ParameterSet.h.

 {
   T value;
   try {
     auto skey = detail::get_sequence_indices(key);
 
     map_iter_t it = mapping_.find(skey.name());
     if (it == mapping_.end()) {
       return std::nullopt;
     }
 
     auto a = it->second;
     if (!detail::find_an_any(
           skey.indices().cbegin(), skey.indices().cend(), a)) {
       throw fhicl::exception(error::cant_find);
     }
 
     using detail::decode;
     decode(a, value);
     return std::make_optional(value);
   }
   catch (fhicl::exception const& e) {
     std::ostringstream errmsg;
     errmsg << "\nUnsuccessful attempt to convert FHiCL parameter '" << key
            << "' to type '" << cet::demangle_symbol(typeid(value).name())
            << "'.\n\n"
            << "[Specific error:]";
     throw fhicl::exception(type_mismatch, errmsg.str(), e);
   }
   catch (std::exception const& e) {
     std::ostringstream errmsg;
     errmsg << "\nUnsuccessful attempt to convert FHiCL parameter '" << key
            << "' to type '" << cet::demangle_symbol(typeid(value).name())
            << "'.\n\n"
            << "[Specific error:]\n"
            << e.what() << "\n\n";
     throw fhicl::exception(type_mismatch, errmsg.str());
   }
 }

vector< string > ParameterSet::get_pset_names ( ) const

Definition at line 189 of file ParameterSet.cc.

 {
   vector<string> keys;
   for (auto const& [key, value] : mapping_) {
     if (is_table(value)) {
       keys.push_back(key);
     }
   }
   return keys;
 }

std::string ParameterSet::get_src_info ( std::string const & key ) const

Definition at line 257 of file ParameterSet.cc.

 {
   auto result = srcMapping_.find(key);
   return result != srcMapping_.cend() ? result->second : "";
 }

bool ParameterSet::has_key ( std::string const & key ) const

Definition at line 247 of file ParameterSet.cc.

 {
   auto keys = detail::get_names(key);
   auto ps = descend_(keys.tables());
   return ps ? ps->find_one_(keys.last()) : false;
 }

ParameterSetID ParameterSet::id ( ) const

Definition at line 153 of file ParameterSet.cc.

 {
   if (!id_.is_valid()) {
     id_.reset(*this);
   }
   return id_;
 }

void ParameterSet::insert_	(	std::string const &	key,
		std::any const &	value
	)

private

Definition at line 290 of file ParameterSet.cc.

 {
   check_put_local_key(key);
   if (!mapping_.emplace(key, value).second) {
     throw exception(cant_insert) << "key " << key << " already exists.";
   }
   id_.invalidate();
 }

void ParameterSet::insert_or_replace_	(	std::string const &	key,
		std::any const &	value
	)

private

Definition at line 300 of file ParameterSet.cc.

 {
   check_put_local_key(key);
   mapping_[key] = value;
   id_.invalidate();
 }

void ParameterSet::insert_or_replace_compatible_	(	std::string const &	key,
		std::any const &	value
	)

private

Definition at line 308 of file ParameterSet.cc.

 {
   check_put_local_key(key);
   auto item = mapping_.find(key);
   if (item == mapping_.end()) {
     insert_(key, value);
     return;
   } else {
     if (!detail::is_nil(value)) {
       auto is_non_nil_atom = [](any const& v) {
         return !(detail::is_sequence(v) || detail::is_table(v) ||
                  detail::is_nil(v));
       };
       if (detail::is_sequence(item->second) && !detail::is_sequence(value)) {
         throw exception(cant_insert)
           << "can't use non-sequence to replace sequence.";
       } else if (detail::is_table(item->second) && !detail::is_table(value)) {
         throw exception(cant_insert) << "can't use non-table to replace table.";
       } else if (is_non_nil_atom(item->second) &&
                  (detail::is_sequence(value) || detail::is_table(value))) {
         throw exception(cant_insert)
           << "can't use non-atom to replace non-nil atom.";
       }
     }
     item->second = value;
   }
   id_.invalidate();
 }

bool ParameterSet::is_empty ( ) const

Definition at line 147 of file ParameterSet.cc.

 {
   return mapping_.empty();
 }

bool fhicl::ParameterSet::is_key_to_atom ( std::string const & key ) const

inline

Definition at line 177 of file ParameterSet.h.

 {
   return key_is_type_(key, [](std::any const& a) {
     return !(detail::is_sequence(a) || detail::is_table(a));
   });
 }

bool fhicl::ParameterSet::is_key_to_sequence ( std::string const & key ) const

inline

Definition at line 171 of file ParameterSet.h.

 {
   return key_is_type_(key, &detail::is_sequence);
 }

bool fhicl::ParameterSet::is_key_to_table ( std::string const & key ) const

inline

Definition at line 165 of file ParameterSet.h.

 {
   return key_is_type_(key, &detail::is_table);
 }

bool ParameterSet::key_is_type_	(	std::string const &	key,
		std::function< bool(std::any const &)>	func
	)		const

private

Definition at line 346 of file ParameterSet.cc.

 {
   auto split_keys = detail::get_names(key);
   auto ps = descend_(split_keys.tables());
   if (not ps) {
     throw exception(error::cant_find, key);
   }
 
   auto skey = detail::get_sequence_indices(split_keys.last());
 
   auto it = ps->mapping_.find(skey.name());
   if (it == ps->mapping_.end()) {
     throw exception(error::cant_find, key);
   }
 
   auto a = it->second;
   return detail::find_an_any(
            skey.indices().cbegin(), skey.indices().cend(), a) ?
            func(a) :
            throw exception(error::cant_find, key);
 }

fhicl::ParameterSet fhicl::ParameterSet::make ( intermediate_table const & tbl )

static

Definition at line 68 of file ParameterSet.cc.

 {
   ParameterSet result;
   for (auto const& [key, value] : tbl) {
     if (!value.in_prolog)
       result.put(key, value);
   }
   return result;
 }

fhicl::ParameterSet fhicl::ParameterSet::make ( extended_value const & xval )

static

Definition at line 81 of file ParameterSet.cc.

 {
   if (!xval.is_a(TABLE))
     throw fhicl::exception(type_mismatch, "extended value not a table");
 
   ParameterSet result;
   auto const& tbl = table_t(xval);
   for (auto const& [key, value] : tbl) {
     if (!value.in_prolog)
       result.put(key, value);
   }
   return result;
 }

fhicl::ParameterSet fhicl::ParameterSet::make ( std::string const & str )

static

Definition at line 98 of file ParameterSet.cc.

 {
   auto const tbl = parse_document(str);
   return ParameterSet::make(tbl);
 }

fhicl::ParameterSet fhicl::ParameterSet::make	(	std::string const &	filename,
		cet::filepath_maker &	maker
	)

static

Definition at line 107 of file ParameterSet.cc.

 {
   auto const tbl = parse_document(filename, maker);
   return ParameterSet::make(tbl);
 }

bool fhicl::ParameterSet::operator!= ( ParameterSet const & other ) const

inline

Definition at line 312 of file ParameterSet.h.

 {
   return !operator==(other);
 }

bool fhicl::ParameterSet::operator== ( ParameterSet const & other ) const

inline

Definition at line 306 of file ParameterSet.h.

 {
   return id() == other.id();
 }

void ParameterSet::put ( std::string const & key )

Definition at line 266 of file ParameterSet.cc.

 {
   put(key, nullptr);
 }

template<class T >

void fhicl::ParameterSet::put	(	std::string const &	key,
		T const &	value
	)

Definition at line 186 of file ParameterSet.h.

 {
   auto insert = [this, &value](auto const& key) {
     using detail::encode;
     this->insert_(key, std::any(encode(value)));
   };
   detail::try_insert(insert, key);
 }

void fhicl::ParameterSet::put	(	std::string const &	key,
		fhicl::extended_value const &	value
	)

Definition at line 409 of file ParameterSet.cc.

   {
     auto insert = [this, &value](auto const& key) {
       using detail::encode;
       this->insert_(key, std::any(encode(value)));
       fill_src_info(value, key, srcMapping_);
     };
     detail::try_insert(insert, key);
   }

void ParameterSet::put_or_replace ( std::string const & key )

Definition at line 272 of file ParameterSet.cc.

 {
   put_or_replace(key, nullptr); // Replace with nil is always OK.
 }

template<class T >

void fhicl::ParameterSet::put_or_replace	(	std::string const &	key,
		T const &	value
	)

Definition at line 197 of file ParameterSet.h.

 {
   auto insert_or_replace = [this, &value](auto const& key) {
     using detail::encode;
     this->insert_or_replace_(key, std::any(encode(value)));
     srcMapping_.erase(key);
   };
   detail::try_insert(insert_or_replace, key);
 }

template<class T >

void fhicl::ParameterSet::put_or_replace_compatible	(	std::string const &	key,
		T const &	value
	)

Definition at line 209 of file ParameterSet.h.

 {
   auto insert_or_replace_compatible = [this, &value](auto const& key) {
     using detail::encode;
     this->insert_or_replace_compatible_(key, std::any(encode(value)));
     srcMapping_.erase(key);
   };
   detail::try_insert(insert_or_replace_compatible, key);
 }

string ParameterSet::stringify_	(	std::any const &	a,
		bool	compact = `false`
	)		const

private

Definition at line 117 of file ParameterSet.cc.

 {
   string result;
   if (is_table(a)) {
     auto const& psid = any_cast<ParameterSetID>(a);
     result = '{' + ParameterSetRegistry::get(psid).to_string() + '}';
     if (compact && result.size() > (5 + ParameterSetID::max_str_size())) {
       // Replace with a reference to the ParameterSetID;
       result = std::string("@id::") + psid.to_string();
     }
   } else if (is_sequence(a)) {
     auto const& seq = any_cast<ps_sequence_t>(a);
     result = '[';
     if (!seq.empty()) {
       result.append(stringify_(*seq.begin(), compact));
       for (auto it = seq.cbegin(), e = seq.cend(); ++it != e;) {
         result.append(1, ',').append(stringify_(*it, compact));
       }
     }
     result.append(1, ']');
   } else { // is_atom(a)
     ps_atom_t const str = any_cast<ps_atom_t>(a);
     result = str == string(9, '\0') ? "@nil" : str;
   }
   return result;
 } // stringify_()

std::string fhicl::ParameterSet::to_compact_string ( ) const

inline

Definition at line 159 of file ParameterSet.h.

 {
   return to_string_(true);
 }

string ParameterSet::to_indented_string ( ) const

Definition at line 466 of file ParameterSet.cc.

 {
   return to_indented_string(0u);
 }

string ParameterSet::to_indented_string ( unsigned initial_indent_level ) const

Definition at line 472 of file ParameterSet.cc.

 {
   return to_indented_string(initial_indent_level, false);
 }

string ParameterSet::to_indented_string	(	unsigned	initial_indent_level,
		bool	annotate
	)		const

Definition at line 478 of file ParameterSet.cc.

 {
   if (annotate) {
     return to_indented_string(initial_indent_level, print_mode::annotated);
   }
   return to_indented_string(initial_indent_level, print_mode::raw);
 }

string ParameterSet::to_indented_string	(	unsigned	initial_indent_level,
		detail::print_mode	pm
	)		const

Definition at line 488 of file ParameterSet.cc.

 {
   std::string result;
   switch (pm) {
   case print_mode::raw: {
     Prettifier p{initial_indent_level};
     walk(p);
     result = p.result();
     break;
   }
   case print_mode::annotated: {
     PrettifierAnnotated p{initial_indent_level};
     walk(p);
     result = p.result();
     break;
   }
   case print_mode::prefix_annotated: {
     PrettifierPrefixAnnotated p;
     walk(p);
     result = p.result();
     break;
   }
   }
   return result;
 }

std::string fhicl::ParameterSet::to_string ( ) const

inline

Definition at line 153 of file ParameterSet.h.

 {
   return to_string_();
 }

string ParameterSet::to_string_ ( bool compact = false ) const

private

Definition at line 162 of file ParameterSet.cc.

 {
   string result;
   if (mapping_.empty()) {
     return result;
   }
   auto it = mapping_.begin();
   result.append(it->first).append(1, ':').append(
     stringify_(it->second, compact));
   for (auto const e = mapping_.end(); ++it != e;) {
     result.append(1, ' ').append(it->first).append(1, ':').append(
       stringify_(it->second, compact));
   }
   return result;
 }

void ParameterSet::walk ( ParameterSetWalker & psw ) const

Definition at line 423 of file ParameterSet.cc.

 {
   std::stack<ParameterSet const*> ps_stack;
   ps_stack.push(this);
 
   std::function<void(std::string const&, std::any const&)> act_on_element =
     [&psw, &ps_stack, &act_on_element](std::string const& key,
                                        std::any const& a) {
       auto const* ps = ps_stack.top();
       psw.do_before_action(key, a, ps);
 
       if (is_table(a)) {
         ParameterSet const* ps = &get_pset_via_any(a);
         ps_stack.push(ps);
         psw.do_enter_table(key, a);
         for (auto const& [nested_key, nested_a] : ps->mapping_) {
           act_on_element(nested_key, nested_a);
         }
         psw.do_exit_table(key, a);
         ps_stack.pop();
       } else if (is_sequence(a)) {
         psw.do_enter_sequence(key, a);
         std::size_t i{};
         for (auto const& elem : any_cast<ps_sequence_t>(a)) {
           std::string const new_key = key + "["s + std::to_string(i++) + "]";
           act_on_element(new_key, elem);
         }
         psw.do_exit_sequence(key, a);
       } else {
         psw.do_atom(key, a);
       }
 
       psw.do_after_action(key);
     };
 
   for (auto const& [key, value] : mapping_) {
     act_on_element(key, value);
   }
 }

Member Data Documentation

ParameterSetID fhicl::ParameterSet::id_

mutableprivate

Definition at line 127 of file ParameterSet.h.

map_t fhicl::ParameterSet::mapping_

private

Definition at line 125 of file ParameterSet.h.

annot_t fhicl::ParameterSet::srcMapping_

private

Definition at line 126 of file ParameterSet.h.

The documentation for this class was generated from the following files:

fhiclcpp/fhiclcpp/ParameterSet.h
fhiclcpp/fhiclcpp/ParameterSet.cc

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Function Documentation

Member Data Documentation