#include <intermediate_table.h>

Public Types
using	atom_t = extended_value::atom_t

using	complex_t = extended_value::complex_t

using	sequence_t = extended_value::sequence_t

using	table_t = extended_value::table_t

using	iterator = table_t::iterator

using	const_iterator = table_t::const_iterator

Public Member Functions
bool	empty () const

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

void	erase (std::string const &key, bool in_prolog=false)

template<typename T >
T	get (std::string const &name)

bool	put (std::string const &name, std::string const &value, bool in_prolog=false)

bool	put (std::string const &name, char const *value, bool in_prolog=false)

bool	put (std::string const &name, bool value, bool in_prolog=false)

template<typename T >
bool	put (std::string const &name, std::complex< T > const &value, bool in_prolog=false)

template<typename T >
bool	put (std::string const &name, std::vector< T > const &value, bool in_prolog=false)

template<typename T >
std::enable_if_t< tt::is_numeric< T >::value, bool >	put (std::string const &name, T value, bool in_prolog=false)

bool	putEmptySequence (std::string const &name, bool in_prolog=false)

bool	putEmptyTable (std::string const &name, bool in_prolog=false)

bool	putNil (std::string const &name, bool in_prolog=false)

const_iterator	begin () const

const_iterator	end () const

bool	insert (std::string const &key, bool in_prolog, value_tag tag, std::any const &value)

bool	insert (std::string const &key, extended_value const &value)

bool	insert (std::string const &key, extended_value &&value)

extended_value const &	find (std::string const &key) const

extended_value *	locate (std::string const &key)

extended_value &	update (std::string const &key)

template<typename T >
std::enable_if< tt::is_numeric< T >::value, bool >::type	put (std::string const &key, T const value, bool const in_prolog)

Private Member Functions
extended_value *	pre_insert_ (std::string const &key, extended_value const &value)

std::pair< extended_value *, bool >	locate_ (std::string const &key, bool in_prolog=false)

Static Private Member Functions
static std::vector< std::string >	split (std::string const &key)

Private Attributes
extended_value	ex_val {false, TABLE, table_t{}}

Detailed Description

Definition at line 65 of file intermediate_table.h.

Member Typedef Documentation

using fhicl::intermediate_table::atom_t = extended_value::atom_t

Definition at line 110 of file intermediate_table.h.

using fhicl::intermediate_table::complex_t = extended_value::complex_t

Definition at line 111 of file intermediate_table.h.

using fhicl::intermediate_table::const_iterator = table_t::const_iterator

Definition at line 115 of file intermediate_table.h.

using fhicl::intermediate_table::iterator = table_t::iterator

Definition at line 114 of file intermediate_table.h.

using fhicl::intermediate_table::sequence_t = extended_value::sequence_t

Definition at line 112 of file intermediate_table.h.

using fhicl::intermediate_table::table_t = extended_value::table_t

Definition at line 113 of file intermediate_table.h.

Member Function Documentation

const_iterator intermediate_table::begin ( ) const

Definition at line 57 of file intermediate_table.cc.

 {
   return std::any_cast<table_t const&>(ex_val.value).begin();
 }

bool intermediate_table::empty ( ) const

Definition at line 71 of file intermediate_table.cc.

 {
   return std::any_cast<table_t const&>(ex_val.value).empty();
 }

const_iterator intermediate_table::end ( ) const

Definition at line 63 of file intermediate_table.cc.

 {
   return std::any_cast<table_t const&>(ex_val.value).end();
 }

void intermediate_table::erase	(	std::string const &	key,
		bool	in_prolog = `false`
	)

Definition at line 174 of file intermediate_table.cc.

 {
   // A missing part of the "a.b.c.d" chain will not cause an error; it
   // is an error for an intermediate link in the chain *not* to be a
   // table.
   auto p(&ex_val);
   auto t(std::any_cast<table_t>(&p->value));
   auto it(t->end());
   auto const names = split(key);
   if ((!in_prolog) &&
       (((it = t->find(names[0])) == t->end()) || it->second.in_prolog)) {
     return;
   }
   bool at_sequence(false);
   for (auto const& name : names) {
     if (name.empty()) {
     } else if (std::isdigit(name[0])) {
       if (!p->is_a(SEQUENCE))
         throw exception(cant_find, name)
           << "-- not a sequence (at part \"" << name << "\")";
       auto& s = std::any_cast<sequence_t&>(p->value);
       unsigned i = std::atoi(name.c_str());
       if (s.size() <= i) {
         return;
       }
       p = &s[i];
       at_sequence = true;
     } else { /* name[0] is alpha or '_' */
       if (!p->is_a(TABLE))
         throw exception(cant_find, name)
           << "-- not a table (at part \"" << name << "\")";
       at_sequence = false;
       t = std::any_cast<table_t>(&p->value);
       it = t->find(name);
       if (it == t->end()) {
         return;
       }
       p = &it->second;
       auto prot = p->protection;
       if (prot == Protection::PROTECT_ERROR) {
         throw exception(protection_violation)
           << ((name != key) ? (std::string("Part \"") + name +
                                "\" of specification to be erased\n") :
                               "")
           << '"' << name << "\" is protected on " << p->pretty_src_info()
           << '\n';
       } else if (prot == Protection::PROTECT_IGNORE) {
         return;
       }
     }
   } // for
   if (at_sequence) {
     throw fhicl::exception(unimplemented, "erase sequence member");
   }
   if (it != t->end()) {
     t->erase(it);
   }
 }

bool intermediate_table::exists ( std::string const & key ) const

Definition at line 143 of file intermediate_table.cc.

 {
   extended_value const* p = &ex_val;
   for (auto const& name : split(key)) {
     if (name.empty()) {
     } else if (std::isdigit(name[0])) {
       if (!p->is_a(SEQUENCE)) {
         return false;
       }
       auto const& s = std::any_cast<sequence_t const&>(p->value);
       unsigned i = std::atoi(name.c_str());
       if (s.size() <= i) {
         return false;
       }
       p = &s[i];
     } else { /* name[0] is alpha or '_' */
       if (!p->is_a(TABLE)) {
         return false;
       }
       auto const& t = std::any_cast<table_t const&>(p->value);
       auto it = t.find(name);
       if (it == t.end()) {
         return false;
       }
       p = &it->second;
     }
   } // for
   return true;
 } // exists()

extended_value const & intermediate_table::find ( std::string const & key ) const

Exceptions

if	item does not exist.

Definition at line 112 of file intermediate_table.cc.

 {
   extended_value const* p = &ex_val;
   for (auto const& name : split(key)) {
     if (name.empty()) {
     } else if (std::isdigit(name[0])) {
       if (!p->is_a(SEQUENCE))
         throw exception(cant_find, key)
           << "-- not a sequence (at part \"" << name << "\")";
       auto const& s = std::any_cast<sequence_t const&>(p->value);
       unsigned i = std::atoi(name.c_str());
       if (s.size() <= i)
         throw exception(cant_find, key) << "(at part \"" << name << "\")";
       p = &s[i];
     } else { /* name[0] is alpha or '_' */
       if (!p->is_a(TABLE))
         throw exception(cant_find, key)
           << "-- not a table (at part \"" << name << "\")";
       auto const& t = std::any_cast<table_t const&>(p->value);
       auto it = t.find(name);
       if (it == t.end())
         throw exception(cant_find, key) << "(at part \"" << name << "\")";
       p = &it->second;
     }
   } // for
   return *p;
 } // find()

template<typename T >

T fhicl::intermediate_table::get ( std::string const & name )

inline

Definition at line 274 of file intermediate_table.h.

 {
   static detail::it_value_get<T> getter;
   return getter(*this, key);
 }

bool intermediate_table::insert	(	std::string const &	key,
		bool	in_prolog,
		value_tag	tag,
		std::any const &	value
	)

Definition at line 79 of file intermediate_table.cc.

 {
   return insert(key, extended_value(in_prolog, tag, value));
 }

bool intermediate_table::insert	(	std::string const &	key,
		extended_value const &	value
	)

Definition at line 88 of file intermediate_table.cc.

 {
   auto found_val = pre_insert_(key, value);
   bool result = (found_val != nullptr);
   if (result) {
     *found_val = value;
   }
   return result;
 }

bool intermediate_table::insert	(	std::string const &	key,
		extended_value &&	value
	)

Definition at line 99 of file intermediate_table.cc.

 {
   auto found_val = pre_insert_(key, value);
   bool result = (found_val != nullptr);
   if (result) {
     *found_val = std::move(value);
   }
   return result;
 }

fhicl::extended_value * fhicl::intermediate_table::locate ( std::string const & key )

inline

Returns: nullptr if not able to be updated.

Definition at line 365 of file intermediate_table.h.

 {
   extended_value* result = nullptr;
   auto located = locate_(key);
   if (located.second) {
     result = located.first;
   }
   return result;
 }

std::pair< extended_value *, bool > intermediate_table::locate_	(	std::string const &	key,
		bool	in_prolog = `false`
	)

private

Definition at line 257 of file intermediate_table.cc.

 {
   std::pair<extended_value*, bool> result(nullptr, true);
   extended_value*& p = result.first;
   p = &ex_val;
   for (auto const& name : split(key)) {
     if (name.empty()) {
     } else if (std::isdigit(name[0])) {
       if (p->is_a(NIL)) {
         *p = empty_seq();
       }
       if (!p->is_a(SEQUENCE))
         throw exception(cant_find, name)
           << "-- not a sequence (at part \"" << name << "\")";
       auto& s = std::any_cast<sequence_t&>(p->value);
       unsigned i = std::atoi(name.c_str());
       while (s.size() <= i) {
         s.push_back(nil_item());
       }
       p->set_prolog(in_prolog);
       p = &s[i];
     } else { /* name[0] is alpha or '_' */
       if (p->is_a(NIL)) {
         *p = empty_tbl();
         p->set_prolog(in_prolog);
       }
       if (!p->is_a(TABLE))
         throw exception(cant_find, name)
           << "-- not a table (at part \"" << name << "\")";
       auto& t = std::any_cast<table_t&>(p->value);
       // This will do what we need whether the key is already in the
       // map or not.
       p = &t.emplace(name, nil_item()).first->second;
       p->set_prolog(in_prolog);
     }
 
     auto prot = p->protection;
     if (prot == Protection::PROTECT_ERROR) {
       throw exception(protection_violation)
         << ((name != key) ? (std::string("Part \"") + name +
                              "\" of specification to be overwritten\n") :
                             "")
         << '"' << key << "\" is protected on " << p->pretty_src_info() << '\n';
     } else if (prot == Protection::PROTECT_IGNORE) {
       result.second = false;
       // Keep going since we might need definition location
       // information for specified item upstream.
     }
   } // for
   return result;
 } // locate_()

extended_value * intermediate_table::pre_insert_	(	std::string const &	key,
		extended_value const &	value
	)

private

Definition at line 234 of file intermediate_table.cc.

 {
   if (!value.in_prolog) {
     auto& t = std::any_cast<table_t&>(ex_val.value);
     auto const names = split(key);
     auto it = t.find(names[0]);
     if (it != t.end() && it->second.in_prolog) {
       t.erase(it);
     }
   }
   auto located = locate_(key, value.in_prolog);
   if ((!located.first->is_a(NIL)) &&
       value.protection > located.first->protection) {
     throw exception(protection_violation)
       << '"' << key << "\" cannot be assigned with increased protection"
       << "\n(previous definition on " << located.first->pretty_src_info()
       << ")\n";
   }
   return located.second ? located.first : nullptr;
 }

bool fhicl::intermediate_table::put	(	std::string const &	name,
		std::string const &	value,
		bool	in_prolog = `false`
	)

inline

Definition at line 281 of file intermediate_table.h.

 {
   return insert(key, in_prolog, STRING, detail::encode(value));
 }

bool fhicl::intermediate_table::put	(	std::string const &	name,
		char const *	value,
		bool	in_prolog = `false`
	)

inline

Definition at line 289 of file intermediate_table.h.

 {
   return insert(key, in_prolog, STRING, detail::encode(value));
 }

bool fhicl::intermediate_table::put	(	std::string const &	name,
		bool	value,
		bool	in_prolog = `false`
	)

inline

Definition at line 297 of file intermediate_table.h.

 {
   return insert(key, in_prolog, BOOL, detail::encode(value));
 }

template<typename T >

bool fhicl::intermediate_table::put	(	std::string const &	name,
		std::complex< T > const &	value,
		bool	in_prolog = `false`
	)

Definition at line 306 of file intermediate_table.h.

 {
   return insert(
     key,
     in_prolog,
     COMPLEX,
     complex_t(detail::encode(value.real()), detail::encode(value.imag())));
 }

template<typename T >

bool fhicl::intermediate_table::put	(	std::string const &	name,
		std::vector< T > const &	value,
		bool	in_prolog = `false`
	)

inline

Definition at line 319 of file intermediate_table.h.

 {
   bool result = putEmptySequence(key, in_prolog);
   if (!result) {
     return result;
   }
   size_t count(0);
   for (auto const& item : value) {
     result =
       result && put(key + "[" + std::to_string(count++) + "]", item, in_prolog);
   }
   return result;
 }

template<typename T >

std::enable_if_t<tt::is_numeric<T>::value, bool> fhicl::intermediate_table::put	(	std::string const &	name,
		T	value,
		bool	in_prolog = `false`
	)

template<typename T >

std::enable_if<tt::is_numeric<T>::value, bool>::type fhicl::intermediate_table::put	(	std::string const &	key,
		T const	value,
		bool const	in_prolog
	)

inline

Definition at line 337 of file intermediate_table.h.

 {
   return insert(key, in_prolog, NUMBER, detail::encode(value));
 }

bool fhicl::intermediate_table::putEmptySequence	(	std::string const &	name,
		bool	in_prolog = `false`
	)

inline

Definition at line 344 of file intermediate_table.h.

 {
   return insert(key, in_prolog, SEQUENCE, sequence_t{});
 }

bool fhicl::intermediate_table::putEmptyTable	(	std::string const &	name,
		bool	in_prolog = `false`
	)

inline

Definition at line 351 of file intermediate_table.h.

 {
   return insert(key, in_prolog, TABLE, table_t{});
 }

bool fhicl::intermediate_table::putNil	(	std::string const &	name,
		bool	in_prolog = `false`
	)

inline

Definition at line 358 of file intermediate_table.h.

 {
   return insert(key, in_prolog, NIL, detail::encode(nullptr));
 }

std::vector< std::string > intermediate_table::split ( std::string const & key )

staticprivate

Definition at line 310 of file intermediate_table.cc.

 {
   static std::string const splitChars{shims::isSnippetMode() ? "[]" : ".[]"};
   std::vector<std::string> result;
   boost::algorithm::split(result, key, boost::algorithm::is_any_of(splitChars));
   return result;
 }

fhicl::extended_value & fhicl::intermediate_table::update ( std::string const & key )

inline

Exceptions

if	not able to be updated.

Definition at line 376 of file intermediate_table.h.

 {
   auto located = locate_(key);
   if (!located.second) {
     throw exception(protection_violation)
       << "Requested non-modifiable item \"" << key << "\" for update.\n";
   }
   return *located.first;
 }

Member Data Documentation

extended_value fhicl::intermediate_table::ex_val {false, TABLE, table_t{}}

private

Definition at line 149 of file intermediate_table.h.

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

fhiclcpp/fhiclcpp/intermediate_table.h
fhiclcpp/fhiclcpp/intermediate_table.cc

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Function Documentation

Member Data Documentation