fhicl::ParameterSetRegistry Class Reference

#include "ParameterSetRegistry.h"

Public Types
using	collection_type = std::unordered_map< ParameterSetID, ParameterSet, detail::HashParameterSetID >
using	key_type = typename collection_type::key_type
using	mapped_type = typename collection_type::mapped_type
using	value_type = typename collection_type::value_type
using	size_type = typename collection_type::size_type
using	const_iterator = typename collection_type::const_iterator

Public Member Functions
	ParameterSetRegistry (ParameterSet const &)=delete
	ParameterSetRegistry (ParameterSet &&)=delete
ParameterSetRegistry &	operator= (ParameterSet const &)=delete
ParameterSetRegistry &	operator= (ParameterSet &&)=delete
	~ParameterSetRegistry ()
template<class FwdIt >
auto	put (FwdIt b, FwdIt const e) -> std::enable_if_t< std::is_same< typename std::iterator_traits< FwdIt >::value_type, mapped_type >::value >

Static Public Member Functions
static void	importFrom (sqlite3 *db)
static void	exportTo (sqlite3 *db)
static void	stageIn ()
static bool	empty ()
static size_type	size ()
static ParameterSetID const &	put (ParameterSet const &ps)
template<class FwdIt >
static std::enable_if_t< std::is_same< typename std::iterator_traits< FwdIt >::value_type, mapped_type >::value >	put (FwdIt begin, FwdIt end)
template<class FwdIt >
static std::enable_if_t< std::is_same< typename std::iterator_traits< FwdIt >::value_type, value_type >::value >	put (FwdIt begin, FwdIt end)
static void	put (collection_type const &c)
static collection_type const &	get () noexcept
static ParameterSet const &	get (ParameterSetID const &id)
static bool	get (ParameterSetID const &id, ParameterSet &ps)
static bool	has (ParameterSetID const &id)

Private Member Functions
	ParameterSetRegistry ()
const_iterator	find_ (ParameterSetID const &id)

Static Private Member Functions
static ParameterSetRegistry &	instance_ ()

Private Attributes
sqlite3 *	primaryDB_
sqlite3_stmt *	stmt_ {nullptr}
collection_type	registry_ {}

Static Private Attributes
static std::recursive_mutex	mutex_ {}

Detailed Description

Definition at line 37 of file ParameterSetRegistry.h.

Member Typedef Documentation

using fhicl::ParameterSetRegistry::collection_type = std:: unordered_map<ParameterSetID, ParameterSet, detail::HashParameterSetID>

Definition at line 47 of file ParameterSetRegistry.h.

using fhicl::ParameterSetRegistry::const_iterator = typename collection_type::const_iterator

Definition at line 52 of file ParameterSetRegistry.h.

using fhicl::ParameterSetRegistry::key_type = typename collection_type::key_type

Definition at line 48 of file ParameterSetRegistry.h.

using fhicl::ParameterSetRegistry::mapped_type = typename collection_type::mapped_type

Definition at line 49 of file ParameterSetRegistry.h.

using fhicl::ParameterSetRegistry::size_type = typename collection_type::size_type

Definition at line 51 of file ParameterSetRegistry.h.

using fhicl::ParameterSetRegistry::value_type = typename collection_type::value_type

Definition at line 50 of file ParameterSetRegistry.h.

Constructor & Destructor Documentation

fhicl::ParameterSetRegistry::ParameterSetRegistry ( ParameterSet const &  )

delete

fhicl::ParameterSetRegistry::ParameterSetRegistry ( ParameterSet &&  )

delete

fhicl::ParameterSetRegistry::~ParameterSetRegistry

(

)

Definition at line 50 of file ParameterSetRegistry.cc.

References e, and fhicl::detail::throwOnSQLiteFailure().

{
  sqlite3_finalize(stmt_);
  try {
    throwOnSQLiteFailure(primaryDB_);
  }
  catch (fhicl::exception const& e) {
    std::cerr << e.what() << '\n';
  }
  catch (...) {
  }
  int retcode;
  do {
    retcode = sqlite3_close(primaryDB_);
  } while (retcode == SQLITE_BUSY);
}

fhicl::ParameterSetRegistry::ParameterSetRegistry ( )

private

Definition at line 204 of file ParameterSetRegistry.cc.

References mutex_.

  : primaryDB_{openPrimaryDB()}
{}

Member Function Documentation

bool fhicl::ParameterSetRegistry::empty ( void  )

inlinestatic

Definition at line 101 of file ParameterSetRegistry.h.

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  return instance_().registry_.empty();
}

void fhicl::ParameterSetRegistry::exportTo ( sqlite3 *  db )

static

Definition at line 116 of file ParameterSetRegistry.cc.

References fhicl::detail::throwOnSQLiteFailure().

Referenced by fhicl::parse_file_and_fill_db(), and art::RootOutputFile::writeParameterSetRegistry().

{
  assert(db);
  std::lock_guard<decltype(mutex_)> lock{mutex_};

  cet::sqlite::Transaction txn{db};
  cet::sqlite::exec(db,
                    "DROP TABLE IF EXISTS ParameterSets;"
                    "CREATE TABLE ParameterSets(ID PRIMARY KEY, PSetBlob);");
  txn.commit();

  sqlite3_stmt* oStmt = nullptr;
  sqlite3_prepare_v2(
    db,
    "INSERT OR IGNORE INTO ParameterSets(ID, PSetBlob) VALUES(?, ?);",
    -1,
    &oStmt,
    nullptr);
  throwOnSQLiteFailure(db);
  for (auto const& p : instance_().registry_) {
    std::string id(p.first.to_string());
    std::string psBlob(p.second.to_compact_string());
    sqlite3_bind_text(oStmt, 1, id.c_str(), id.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(db);
    sqlite3_bind_text(
      oStmt, 2, psBlob.c_str(), psBlob.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(db);
    switch (sqlite3_step(oStmt)) {
      case SQLITE_DONE:
        sqlite3_reset(oStmt);
        throwOnSQLiteFailure(db);
        break; // OK
      default:
        throwOnSQLiteFailure(db);
    }
  }

  sqlite3* const primaryDB{instance_().primaryDB_};
  using namespace cet::sqlite;
  query_result<std::string, std::string> regPSes;
  regPSes << select("*").from(primaryDB, "ParameterSets");

  for (auto const& row : regPSes) {
    std::string idString;
    std::string psBlob;
    std::tie(idString, psBlob) = row;
    sqlite3_bind_text(
      oStmt, 1, idString.c_str(), idString.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(db);
    sqlite3_bind_text(
      oStmt, 2, psBlob.c_str(), psBlob.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(db);
    switch (sqlite3_step(oStmt)) {
      case SQLITE_DONE:
        sqlite3_reset(oStmt);
        throwOnSQLiteFailure(db);
        break; // OK
      default:
        throwOnSQLiteFailure(db);
    }
  }
  sqlite3_finalize(oStmt);
  throwOnSQLiteFailure(db);
}

auto fhicl::ParameterSetRegistry::find_ ( ParameterSetID const &  id )

private

Definition at line 211 of file ParameterSetRegistry.cc.

References fhicl::make_ParameterSet(), primaryDB_, registry_, stmt_, and fhicl::detail::throwOnSQLiteFailure().

{
  // No lock here -- it was already acquired by get(...).
  auto it = registry_.find(id);
  if (it == registry_.cend()) {
    // Look in primary DB for this ID and its contained IDs.
    if (stmt_ == nullptr) {
      sqlite3_prepare_v2(primaryDB_,
                         "SELECT PSetBlob FROM ParameterSets WHERE ID = ?;",
                         -1,
                         &stmt_,
                         nullptr);
      throwOnSQLiteFailure(primaryDB_);
    }
    auto idString = id.to_string();
    auto result = sqlite3_bind_text(
      stmt_, 1, idString.c_str(), idString.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(primaryDB_);
    result = sqlite3_step(stmt_);
    switch (result) {
      case SQLITE_ROW: // Found the ID in the DB.
      {
        ParameterSet pset;
        fhicl::make_ParameterSet(
          reinterpret_cast<char const*>(sqlite3_column_text(stmt_, 0)), pset);
        // Put into the registry without triggering ParameterSet::id().
        it = registry_.emplace(id, pset).first;
      } break;
      case SQLITE_DONE:
        break; // Not here.
      default:
        throwOnSQLiteFailure(primaryDB_);
    }
    sqlite3_reset(stmt_);
  }
  return it;
}

auto fhicl::ParameterSetRegistry::get ( )

inlinestaticnoexcept

Definition at line 157 of file ParameterSetRegistry.h.

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), art::ResultsProducer::doBeginJob(), art::EDAnalyzer::doBeginJob(), fhicl::detail::encode(), art::OutputWorker::OutputWorker(), art::Provenance::parameterSet(), print_pset_from_file(), and fhicl::ParameterSet::stringify_().

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  return instance_().registry_;
}

auto fhicl::ParameterSetRegistry::get ( ParameterSetID const &  id )

inlinestatic

Definition at line 164 of file ParameterSetRegistry.h.

References fhicl::cant_find.

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  auto it = instance_().find_(id);
  if (it == instance_().registry_.cend()) {
    throw exception(error::cant_find, "Can't find ParameterSet")
      << "with ID " << id.to_string() << " in the registry.";
  }
  return it->second;
}

bool fhicl::ParameterSetRegistry::get ( ParameterSetID const &  id, ParameterSet &  ps  )

inlinestatic

Definition at line 177 of file ParameterSetRegistry.h.

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  bool result{false};
  auto it = instance_().find_(id);
  if (it != instance_().registry_.cend()) {
    ps = it->second;
    result = true;
  }
  return result;
}

bool fhicl::ParameterSetRegistry::has ( ParameterSetID const &  id )

inlinestatic

Definition at line 190 of file ParameterSetRegistry.h.

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  auto const& reg = instance_().registry_;
  return reg.find(id) != reg.cend();
}

void fhicl::ParameterSetRegistry::importFrom ( sqlite3 *  db )

static

Definition at line 68 of file ParameterSetRegistry.cc.

References fhicl::detail::throwOnSQLiteFailure().

Referenced by read_all_parameter_sets().

{
  assert(db);
  std::lock_guard<decltype(mutex_)> lock{mutex_};

  // This does *not* cause anything new to be imported into the
  // registry itself, just its backing DB.
  sqlite3_stmt* oStmt = nullptr;
  sqlite3* primaryDB = instance_().primaryDB_;

  // Index constraint on ID will prevent duplicates via INSERT OR IGNORE.
  sqlite3_prepare_v2(
    primaryDB,
    "INSERT OR IGNORE INTO ParameterSets(ID, PSetBlob) VALUES(?, ?);",
    -1,
    &oStmt,
    nullptr);
  throwOnSQLiteFailure(primaryDB);

  using namespace cet::sqlite;
  query_result<std::string, std::string> inputPSes;
  inputPSes << select("*").from(db, "ParameterSets");

  for (auto const& row : inputPSes) {
    std::string idString;
    std::string psBlob;
    std::tie(idString, psBlob) = row;

    sqlite3_bind_text(
      oStmt, 1, idString.c_str(), idString.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(primaryDB);
    sqlite3_bind_text(
      oStmt, 2, psBlob.c_str(), psBlob.size() + 1, SQLITE_STATIC);
    throwOnSQLiteFailure(primaryDB);
    switch (sqlite3_step(oStmt)) {
      case SQLITE_DONE:
        break; // OK
      default:
        throwOnSQLiteFailure(primaryDB);
    }
    sqlite3_reset(oStmt);
    throwOnSQLiteFailure(primaryDB);
  }
  sqlite3_finalize(oStmt);
  throwOnSQLiteFailure(primaryDB);
}

auto fhicl::ParameterSetRegistry::instance_ ( )

inlinestaticprivate

Definition at line 198 of file ParameterSetRegistry.h.

{
  static ParameterSetRegistry s_registry;
  return s_registry;
}

ParameterSetRegistry& fhicl::ParameterSetRegistry::operator= ( ParameterSet const &  )

delete

ParameterSetRegistry& fhicl::ParameterSetRegistry::operator= ( ParameterSet &&  )

delete

auto fhicl::ParameterSetRegistry::put ( ParameterSet const &  ps )

inlinestatic

Definition at line 116 of file ParameterSetRegistry.h.

Referenced by fhicl::detail::encode(), fhicl::parse_file_and_fill_db(), put(), read_all_parameter_sets(), art::run_art(), and art::run_art_string_config().

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  return instance_().registry_.emplace(ps.id(), ps).first->first;
}

template<class FwdIt >

static std::enable_if_t< std::is_same<typename std::iterator_traits<FwdIt>::value_type, mapped_type>::value> fhicl::ParameterSetRegistry::put ( FwdIt  begin, FwdIt  end  )

static

template<class FwdIt >

static std::enable_if_t< std::is_same<typename std::iterator_traits<FwdIt>::value_type, value_type>::value> fhicl::ParameterSetRegistry::put ( FwdIt  begin, FwdIt  end  )

static

void fhicl::ParameterSetRegistry::put ( collection_type const &  c )

inlinestatic

Definition at line 150 of file ParameterSetRegistry.h.

{
  // No lock here -- it will be acquired by 3.
  put(c.cbegin(), c.cend());
}

template<class FwdIt >

auto fhicl::ParameterSetRegistry::put ( FwdIt  b, FwdIt const  e  ) -> std::enable_if_t< std::is_same<typename std::iterator_traits<FwdIt>::value_type, mapped_type>::value>

inline

Definition at line 126 of file ParameterSetRegistry.h.

References e, put(), and fhicl::detail::atom::value().

{
  // No lock here -- it will be acquired by 3.
  for (; b != e; ++b) {
    (void)put(*b);
  }
}

auto fhicl::ParameterSetRegistry::size ( void  )

inlinestatic

Definition at line 108 of file ParameterSetRegistry.h.

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};
  return instance_().registry_.size();
}

void fhicl::ParameterSetRegistry::stageIn ( )

static

Definition at line 182 of file ParameterSetRegistry.cc.

References evd::details::begin(), and fhicl::make_ParameterSet().

Referenced by read_all_parameter_sets().

{
  std::lock_guard<decltype(mutex_)> lock{mutex_};

  sqlite3* primaryDB = instance_().primaryDB_;
  auto& registry = instance_().registry_;
  using namespace cet::sqlite;
  query_result<std::string, std::string> entriesToStageIn;
  entriesToStageIn << select("*").from(primaryDB, "ParameterSets");

  cet::transform_all(entriesToStageIn,
                     std::inserter(registry, std::begin(registry)),
                     [](auto const& row) {
                       std::string idString;
                       std::string psBlob;
                       std::tie(idString, psBlob) = row;
                       ParameterSet pset;
                       fhicl::make_ParameterSet(psBlob, pset);
                       return std::make_pair(ParameterSetID{idString}, pset);
                     });
}

Member Data Documentation

std::recursive_mutex fhicl::ParameterSetRegistry::mutex_ {}

staticprivate

Definition at line 97 of file ParameterSetRegistry.h.

Referenced by ParameterSetRegistry().

sqlite3* fhicl::ParameterSetRegistry::primaryDB_

private

Definition at line 94 of file ParameterSetRegistry.h.

Referenced by find_().

collection_type fhicl::ParameterSetRegistry::registry_ {}

private

Definition at line 96 of file ParameterSetRegistry.h.

Referenced by find_().

sqlite3_stmt* fhicl::ParameterSetRegistry::stmt_ {nullptr}

private

Definition at line 95 of file ParameterSetRegistry.h.

Referenced by find_().

---

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

• fhiclcpp/ParameterSetRegistry.h
• fhiclcpp/ParameterSetRegistry.cc