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_v< typename std::iterator_traits< FwdIt >::value_type, mapped_type >>

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_v< typename std::iterator_traits< FwdIt >::value_type, mapped_type > >	put (FwdIt begin, FwdIt end)
template<class FwdIt >
static std::enable_if_t< std::is_same_v< typename std::iterator_traits< FwdIt >::value_type, value_type > >	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 46 of file ParameterSetRegistry.h.

Member Typedef Documentation

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

Definition at line 56 of file ParameterSetRegistry.h.

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

Definition at line 61 of file ParameterSetRegistry.h.

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

Definition at line 57 of file ParameterSetRegistry.h.

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

Definition at line 58 of file ParameterSetRegistry.h.

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

Definition at line 60 of file ParameterSetRegistry.h.

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

Definition at line 59 of file ParameterSetRegistry.h.

Constructor & Destructor Documentation

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

delete

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

delete

fhicl::ParameterSetRegistry::~ParameterSetRegistry

(

)

Definition at line 65 of file ParameterSetRegistry.cc.

{
  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 209 of file ParameterSetRegistry.cc.

  : primaryDB_{openPrimaryDB()}
{}

Member Function Documentation

bool fhicl::ParameterSetRegistry::empty ( )

inlinestatic

Definition at line 110 of file ParameterSetRegistry.h.

{
  std::lock_guard sentry{mutex_};
  return instance_().registry_.empty();
}

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

static

Definition at line 127 of file ParameterSetRegistry.cc.

{
  assert(db);
  std::lock_guard sentry{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& [idString, psBlob] : regPSes) {
    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 214 of file ParameterSetRegistry.cc.

{
  // 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.
    {
      auto const pset = ParameterSet::make(
        reinterpret_cast<char const*>(sqlite3_column_text(stmt_, 0)));
      // 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 165 of file ParameterSetRegistry.h.

{
  std::lock_guard sentry{mutex_};
  return instance_().registry_;
}

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

inlinestatic

Definition at line 172 of file ParameterSetRegistry.h.

{
  std::lock_guard sentry{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 185 of file ParameterSetRegistry.h.

{
  std::lock_guard sentry{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 198 of file ParameterSetRegistry.h.

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

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

static

Definition at line 83 of file ParameterSetRegistry.cc.

{
  assert(db);
  std::lock_guard sentry{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& [idString, psBlob] : inputPSes) {
    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 206 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 125 of file ParameterSetRegistry.h.

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

template<class FwdIt >

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

static

template<class FwdIt >

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

static

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

inlinestatic

Definition at line 158 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_v<typename std::iterator_traits<FwdIt>::value_type, mapped_type>>

inline

Definition at line 135 of file ParameterSetRegistry.h.

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

auto fhicl::ParameterSetRegistry::size ( )

inlinestatic

Definition at line 117 of file ParameterSetRegistry.h.

{
  std::lock_guard sentry{mutex_};
  return instance_().registry_.size();
}

void fhicl::ParameterSetRegistry::stageIn ( )

static

Definition at line 190 of file ParameterSetRegistry.cc.

{
  std::lock_guard sentry{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) {
                       auto const& [idString, psBlob] = row;
                       auto const pset = ParameterSet::make(psBlob);
                       return std::make_pair(ParameterSetID{idString}, pset);
                     });
}

Member Data Documentation

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

staticprivate

Definition at line 106 of file ParameterSetRegistry.h.

sqlite3* fhicl::ParameterSetRegistry::primaryDB_

private

Definition at line 103 of file ParameterSetRegistry.h.

collection_type fhicl::ParameterSetRegistry::registry_ {}

private

Definition at line 105 of file ParameterSetRegistry.h.

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

private

Definition at line 104 of file ParameterSetRegistry.h.

---

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

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