fhicl::intermediate_table Class Reference

#include "intermediate_table.h"

Public Types
typedef extended_value::atom_t	atom_t
typedef extended_value::complex_t	complex_t
typedef extended_value::sequence_t	sequence_t
typedef extended_value::table_t	table_t
typedef table_t::iterator	iterator
typedef table_t::const_iterator	const_iterator

Public Member Functions
	intermediate_table ()
bool	empty () const
bool	exists (std::string const &name) const
void	erase (std::string const &name, 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< tt::is_numeric< T >::value, bool >::type	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 &name, bool in_prolog, value_tag tag, boost::any const &value)
bool	insert (std::string const &name, extended_value const &value)
bool	insert (std::string const &name, extended_value &&value)
extended_value const &	find (std::string const &name) const
extended_value *	locate (std::string const &name)
extended_value &	update (std::string const &name)

Private Member Functions
extended_value *	pre_insert_ (std::string const &name, extended_value const &value)
std::pair< extended_value *, bool >	locate_ (std::string const &name, bool in_prolog=false)
std::vector< std::string >	split (std::string const &name) const

Private Attributes
extended_value	ex_val

Detailed Description

Definition at line 64 of file intermediate_table.h.

Member Typedef Documentation

typedef extended_value::atom_t fhicl::intermediate_table::atom_t

Definition at line 113 of file intermediate_table.h.

typedef extended_value::complex_t fhicl::intermediate_table::complex_t

Definition at line 114 of file intermediate_table.h.

typedef table_t::const_iterator fhicl::intermediate_table::const_iterator

Definition at line 118 of file intermediate_table.h.

typedef table_t::iterator fhicl::intermediate_table::iterator

Definition at line 117 of file intermediate_table.h.

typedef extended_value::sequence_t fhicl::intermediate_table::sequence_t

Definition at line 115 of file intermediate_table.h.

typedef extended_value::table_t fhicl::intermediate_table::table_t

Definition at line 116 of file intermediate_table.h.

Constructor & Destructor Documentation

intermediate_table::intermediate_table

(

)

Definition at line 53 of file intermediate_table.cc.

: ex_val(false, TABLE, table_t()) {}

Member Function Documentation

const_iterator intermediate_table::begin

(

)

const

Definition at line 58 of file intermediate_table.cc.

References ex_val, and fhicl::extended_value::value.

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

bool intermediate_table::empty

(

void

)

const

Definition at line 72 of file intermediate_table.cc.

References ex_val, and fhicl::extended_value::value.

Referenced by art::BasicOptionsHandler::doProcessOptions().

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

const_iterator intermediate_table::end

(

void

)

const

Definition at line 64 of file intermediate_table.cc.

References ex_val, and fhicl::extended_value::value.

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

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

Definition at line 183 of file intermediate_table.cc.

References fhicl::cant_find, ex_val, shims::map< Key, T, Compare, Allocator >::find(), fhicl::PROTECT_ERROR, fhicl::PROTECT_IGNORE, fhicl::protection_violation, s, fhicl::SEQUENCE, split(), fhicl::TABLE, and fhicl::unimplemented.

Referenced by art::BasicOutputOptionsHandler::doCheckOptions(), art::DebugOptionsHandler::doProcessOptions(), and art::FileCatalogOptionsHandler::doProcessOptions().

{
  // 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 const& key(split(name));
  auto p(&ex_val);
  auto t(boost::any_cast<table_t>(&p->value));
  auto it(t->end());
  if ((!in_prolog) &&
      (((it = t->find(key[0])) == t->end()) || it->second.in_prolog)) {
    return;
  }
  bool at_sequence(false);
  for (auto const& this_key : key) {
    if (this_key.empty())
      ;
    else if (std::isdigit(this_key[0])) {
      if (!p->is_a(SEQUENCE))
        throw exception(cant_find, name)
          << "-- not a sequence (at part \"" << this_key << "\")";
      auto& s = boost::any_cast<sequence_t&>(p->value);
      unsigned i = std::atoi(this_key.c_str());
      if (s.size() <= i) {
        return;
      }
      p = &s[i];
      at_sequence = true;
    } else { /* this_key[0] is alpha or '_' */
      if (!p->is_a(TABLE))
        throw exception(cant_find, name)
          << "-- not a table (at part \"" << this_key << "\")";
      at_sequence = false;
      t = boost::any_cast<table_t>(&p->value);
      it = t->find(this_key);
      if (it == t->end()) {
        return;
      }
      p = &it->second;
      auto prot = p->protection;
      if (prot == Protection::PROTECT_ERROR) {
        throw exception(protection_violation)
          << ((this_key != name) ? (std::string("Part \"") + this_key +
                                    "\" 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 &

name

)

const

Definition at line 149 of file intermediate_table.cc.

References shims::map< Key, T, Compare, Allocator >::end(), ex_val, shims::map< Key, T, Compare, Allocator >::find(), fhicl::extended_value::is_a(), s, fhicl::SEQUENCE, split(), fhicl::TABLE, and fhicl::extended_value::value.

Referenced by art::ensureTable(), and art::detail::exists_outside_prolog().

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

extended_value const & intermediate_table::find

(

std::string const &

name

)

const

Exceptions

if	item does not exist.

Definition at line 115 of file intermediate_table.cc.

References fhicl::cant_find, shims::map< Key, T, Compare, Allocator >::end(), ex_val, shims::map< Key, T, Compare, Allocator >::find(), fhicl::extended_value::is_a(), s, fhicl::SEQUENCE, split(), fhicl::TABLE, and fhicl::extended_value::value.

Referenced by art::BasicPostProcessor::doProcessOptions(), art::detail::exists_outside_prolog(), fhicl::detail::it_value_get< T, typename tt::disable_if< std::is_reference< T >::value|| std::is_pointer< T >::value >::type >::operator()(), 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()(), fhicl::detail::it_value_get< intermediate_table::sequence_t >::operator()(), fhicl::detail::it_value_get< intermediate_table::sequence_t const & >::operator()(), fhicl::detail::it_value_get< intermediate_table::table_t >::operator()(), and fhicl::detail::it_value_get< intermediate_table::table_t const & >::operator()().

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

template<typename T >

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

inline

Definition at line 283 of file intermediate_table.h.

Referenced by art::BasicOutputOptionsHandler::doCheckOptions(), art::BasicOutputOptionsHandler::doProcessOptions(), art::DebugOptionsHandler::doProcessOptions(), and art::FileCatalogOptionsHandler::doProcessOptions().

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

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

Definition at line 80 of file intermediate_table.cc.

Referenced by put(), putEmptySequence(), putEmptyTable(), and putNil().

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

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

Definition at line 89 of file intermediate_table.cc.

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

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

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

Definition at line 100 of file intermediate_table.cc.

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

{
  auto found_val = pre_insert_(name, 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 &  name )

inline

Returns

nullptr if not able to be updated.

Definition at line 373 of file intermediate_table.h.

References locate_().

Referenced by fhicl::detail::it_value_get< intermediate_table::sequence_t & >::operator()(), and fhicl::detail::it_value_get< intermediate_table::table_t & >::operator()().

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

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

private

Definition at line 267 of file intermediate_table.cc.

References fhicl::cant_find, ex_val, fhicl::extended_value::is_a(), fhicl::NIL, fhicl::extended_value::pretty_src_info(), fhicl::PROTECT_ERROR, fhicl::PROTECT_IGNORE, fhicl::extended_value::protection, fhicl::protection_violation, s, fhicl::SEQUENCE, fhicl::extended_value::set_prolog(), split(), fhicl::TABLE, and fhicl::extended_value::value.

Referenced by locate(), pre_insert_(), and update().

{
  std::pair<extended_value*, bool> result(nullptr, true);
  std::vector<std::string> const& key = split(name);
  extended_value*& p = result.first;
  p = &ex_val;
  for (unsigned k = 0, sz = key.size(); k != sz; ++k) {
    std::string const& this_key = key[k];
    if (this_key.empty())
      ;
    else if (std::isdigit(this_key[0])) {
      if (p->is_a(NIL)) {
        *p = empty_seq();
      }
      if (!p->is_a(SEQUENCE))
        throw exception(cant_find, name)
          << "-- not a sequence (at part \"" << this_key << "\")";
      auto& s = boost::any_cast<sequence_t&>(p->value);
      unsigned i = std::atoi(this_key.c_str());
      while (s.size() <= i) {
        s.push_back(nil_item());
      }
      p->set_prolog(in_prolog);
      p = &s[i];
    } else { /* this_key[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 \"" << this_key << "\")";
      auto& t = boost::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(this_key, nil_item()).first->second;
      p->set_prolog(in_prolog);
    }
    auto prot = p->protection;
    if (prot == Protection::PROTECT_ERROR) {
      throw exception(protection_violation)
        << ((this_key != name) ? (std::string("Part \"") + this_key +
                                  "\" of specification to be overwritten\n") :
                                 "")
        << '"' << name << "\" 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 &  name, extended_value const &  value  )

private

Definition at line 244 of file intermediate_table.cc.

References shims::map< Key, T, Compare, Allocator >::end(), shims::map< Key, T, Compare, Allocator >::erase(), ex_val, shims::map< Key, T, Compare, Allocator >::find(), fhicl::extended_value::in_prolog, locate_(), fhicl::NIL, fhicl::extended_value::protection, fhicl::protection_violation, split(), and fhicl::extended_value::value.

Referenced by insert().

{
  if (!value.in_prolog) {
    table_t& t = boost::any_cast<table_t&>(ex_val.value);
    std::vector<std::string> const& key = split(name);
    iterator it = t.find(key[0]);
    if (it != t.end() && it->second.in_prolog) {
      t.erase(it);
    }
  }
  auto located = locate_(name, value.in_prolog);
  if ((!located.first->is_a(NIL)) &&
      value.protection > located.first->protection) {
    throw exception(protection_violation)
      << '"' << name << "\" 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 290 of file intermediate_table.h.

References fhicl::detail::encode(), insert(), and fhicl::STRING.

Referenced by art::BasicOutputOptionsHandler::doCheckOptions(), art::ProcessingOptionsHandler::doProcessOptions(), art::BasicOutputOptionsHandler::doProcessOptions(), art::DebugOptionsHandler::doProcessOptions(), art::BasicSourceOptionsHandler::doProcessOptions(), art::FileCatalogOptionsHandler::doProcessOptions(), art::BasicOptionsHandler::doProcessOptions(), and put().

{
  return insert(name, 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 298 of file intermediate_table.h.

References fhicl::detail::encode(), insert(), and fhicl::STRING.

{
  return insert(name, 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 306 of file intermediate_table.h.

References fhicl::BOOL, fhicl::detail::encode(), and insert().

{
  return insert(name, 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 315 of file intermediate_table.h.

References fhicl::COMPLEX, fhicl::detail::encode(), and insert().

{
  return insert(
    name,
    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 328 of file intermediate_table.h.

References put(), putEmptySequence(), util::flags::to_string(), and fhicl::detail::atom::value().

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

template<typename T >

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

inline

Definition at line 346 of file intermediate_table.h.

References fhicl::detail::encode(), insert(), and fhicl::NUMBER.

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

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

inline

Definition at line 353 of file intermediate_table.h.

References insert(), and fhicl::SEQUENCE.

Referenced by art::ProcessingOptionsHandler::doProcessOptions(), and put().

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

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

inline

Definition at line 360 of file intermediate_table.h.

References insert(), and fhicl::TABLE.

Referenced by art::DebugOptionsHandler::doProcessOptions(), and art::ensureTable().

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

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

inline

Definition at line 366 of file intermediate_table.h.

References fhicl::detail::encode(), insert(), and fhicl::NIL.

{
  return insert(name, in_prolog, NIL, detail::encode((void*)0));
}

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

private

Definition at line 322 of file intermediate_table.cc.

References shims::isSnippetMode().

Referenced by erase(), exists(), find(), locate_(), and pre_insert_().

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

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

inline

Exceptions

if	not able to be updated.

Definition at line 384 of file intermediate_table.h.

References locate_(), and fhicl::protection_violation.

Referenced by art::BasicPostProcessor::doProcessOptions().

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

Member Data Documentation

extended_value fhicl::intermediate_table::ex_val

private

Definition at line 151 of file intermediate_table.h.

Referenced by begin(), empty(), end(), erase(), exists(), find(), locate_(), and pre_insert_().

---

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

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