DTUserKeyedConfigHandler Class Reference

#include <DTUserKeyedConfigHandler.h>

Inheritance diagram for DTUserKeyedConfigHandler:

Public Member Functions
	DTUserKeyedConfigHandler (const edm::ParameterSet &ps)
void	getNewObjects () override
std::string	id () const override
void	setList (const cond::persistency::KeyList *list)
	~DTUserKeyedConfigHandler () override
Public Member Functions inherited from popcon::PopConSourceHandler< DTCCBConfig >
void	initialize (const cond::persistency::Session &dbSession, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry)
Ref	lastPayload () const
cond::LogDBEntry_t const &	logDBEntry () const
std::pair< Container const *, std::string const >	operator() (const cond::persistency::Session &session, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry) const
	PopConSourceHandler ()
Container const &	returnData ()
cond::TagInfo_t const &	tagInfo () const
std::string const &	userTextLog () const
virtual	~PopConSourceHandler ()

Private Member Functions
void	chkConfigList (const std::map< int, bool > &userBricks)
bool	userDiscardedKey (int key)

Static Private Member Functions
static bool	sameConfigList (const std::vector< DTConfigKey > &cfgl, const std::vector< DTConfigKey > &cfgr)

Private Attributes
std::string	brickContainer
DTCCBConfig *	ccbConfig
cond::persistency::ConnectionPool	connection
int	dataRun
std::string	dataTag
std::shared_ptr< coral::ISessionProxy >	isession
const cond::persistency::KeyList *	keyList = nullptr
std::string	onlineAuthentication
int	onlineAuthSys
std::string	onlineConnect
std::vector< DTConfigKey >	userConf
bool	writeData
bool	writeKeys

Additional Inherited Members
Public Types inherited from popcon::PopConSourceHandler< DTCCBConfig >
typedef std::map< Time_t, std::shared_ptr< DTCCBConfig > >	Container
typedef std::unique_ptr< DTCCBConfig >	Ref
typedef PopConSourceHandler< DTCCBConfig >	self
typedef cond::Time_t	Time_t
typedef DTCCBConfig	value_type
Protected Member Functions inherited from popcon::PopConSourceHandler< DTCCBConfig >
cond::persistency::Session &	dbSession () const
Protected Attributes inherited from popcon::PopConSourceHandler< DTCCBConfig >
Container	m_iovs
std::vector< std::pair< DTCCBConfig *, Time_t > >	m_to_transfer
std::string	m_userTextLog

Detailed Description

Description:

Date

2010/07/21 17:13:43

Revision

1.3

Author

Paolo Ronchese INFN Padova

Definition at line 46 of file DTUserKeyedConfigHandler.h.

Constructor & Destructor Documentation

DTUserKeyedConfigHandler()

DTUserKeyedConfigHandler::DTUserKeyedConfigHandler

(

const edm::ParameterSet &

ps

)

Constructor

Definition at line 48 of file DTUserKeyedConfigHandler.cc.

References DTConfigKey::confKey, DTConfigKey::confType, gather_cfg::cout, edm::ParameterSet::getParameter(), onlineAuthentication, and userConf.

    : dataRun(ps.getParameter<int>("run")),
      dataTag(ps.getParameter<std::string>("tag")),
      onlineConnect(ps.getParameter<std::string>("onlineDB")),
      onlineAuthentication(ps.getParameter<std::string>("onlineAuthentication")),
      onlineAuthSys(ps.getUntrackedParameter<int>("onlineAuthSys", 1)),
      brickContainer(ps.getParameter<std::string>("container")),
      writeKeys(ps.getParameter<bool>("writeKeys")),
      writeData(ps.getParameter<bool>("writeData")),
      connection(),
      isession() {
  std::cout << " PopCon application for DT configuration export " << onlineAuthentication << std::endl;

  std::vector<edm::ParameterSet> dtConfigKeys(ps.getParameter<std::vector<edm::ParameterSet> >("DTConfigKeys"));
  std::vector<edm::ParameterSet>::const_iterator iter = dtConfigKeys.begin();
  std::vector<edm::ParameterSet>::const_iterator iend = dtConfigKeys.end();
  while (iter != iend) {
    const edm::ParameterSet& cp = *iter++;
    int configType = cp.getUntrackedParameter<int>("configType");
    int configKey = cp.getUntrackedParameter<int>("configKey");
    std::cout << "config: " << configType << " -> " << configKey << std::endl;
    DTConfigKey userKey;
    userKey.confType = configType;
    userKey.confKey = configKey;
    userConf.push_back(userKey);
  }
}

~DTUserKeyedConfigHandler()

DTUserKeyedConfigHandler::~DTUserKeyedConfigHandler ( )

override

Destructor

Definition at line 79 of file DTUserKeyedConfigHandler.cc.

{}

Member Function Documentation

chkConfigList()

void DTUserKeyedConfigHandler::chkConfigList ( const std::map< int, bool > &  userBricks )

private

Definition at line 309 of file DTUserKeyedConfigHandler.cc.

References DTKeyedConfig::add(), brickContainer, gather_cfg::cout, cppFunctionSkipper::exception, cond::persistency::KeyList::getUsingKey(), isession, dqmdumpme::k, keyList, DTKeyedConfig::setId(), AlCaHLTBitMon_QueryRunRegistry::string, and cond::service::PoolDBOutputService::writeOneIOV().

Referenced by getNewObjects().

                                                                                {
  std::cout << "open POOL out db " << std::endl;
  edm::Service<cond::service::PoolDBOutputService> outdb;

  std::map<int, bool>::const_iterator uBrkIter = userBricks.begin();
  std::map<int, bool>::const_iterator uBrkIend = userBricks.end();

  coral::ITable& brickConfigTable = isession->nominalSchema().tableHandle("CFGBRICKS");
  std::unique_ptr<coral::IQuery> brickConfigQuery(brickConfigTable.newQuery());
  brickConfigQuery->addToOutputList("BRKID");
  brickConfigQuery->addToOutputList("BRKNAME");
  coral::ICursor& brickConfigCursor = brickConfigQuery->execute();
  std::vector<int> missingList;
  std::vector<unsigned long long> checkedKeys;
  while (brickConfigCursor.next()) {
    const coral::AttributeList& row = brickConfigCursor.currentRow();
    int brickConfigId = row["BRKID"].data<int>();
    uBrkIter = userBricks.find(brickConfigId);
    if (uBrkIter == uBrkIend)
      continue;
    if (!(uBrkIter->second))
      continue;
    std::string brickConfigName = row["BRKNAME"].data<std::string>();
    std::cout << "brick " << brickConfigId << " : " << brickConfigName << std::endl;
    bool brickFound = false;
    try {
      std::cout << "load brick " << brickConfigId << std::endl;
      std::cout << "key list " << keyList << std::endl;
      std::cout << "get brick..." << std::endl;
      std::shared_ptr<DTKeyedConfig> brickCheck = keyList->getUsingKey<DTKeyedConfig>(brickConfigId);
      if (brickCheck.get()) {
        brickFound = (brickCheck->getId() == brickConfigId);
      }
    } catch (std::exception const&) {
    }
    if (!brickFound) {
      std::cout << "brick " << brickConfigId << " missing, copy request" << std::endl;
      missingList.push_back(brickConfigId);
    }
  }

  std::vector<int>::const_iterator brickIter = missingList.begin();
  std::vector<int>::const_iterator brickIend = missingList.end();
  while (brickIter != brickIend) {
    int brickConfigId = *brickIter++;
    coral::AttributeList bindVariableList;
    bindVariableList.extend("brickId", typeid(int));
    bindVariableList["brickId"].data<int>() = brickConfigId;
    std::unique_ptr<coral::IQuery> brickDataQuery(isession->nominalSchema().newQuery());
    brickDataQuery->addToTableList("CFGRELATIONS");
    brickDataQuery->addToTableList("CONFIGCMDS");
    std::string brickCondition = "CONFIGCMDS.CMDID=CFGRELATIONS.CMDID";
    brickCondition += " and CFGRELATIONS.BRKID=:brickId";
    brickDataQuery->addToOutputList("CFGRELATIONS.BRKID");
    brickDataQuery->addToOutputList("CONFIGCMDS.CONFDATA");
    brickDataQuery->setCondition(brickCondition, bindVariableList);
    coral::ICursor& brickDataCursor = brickDataQuery->execute();
    DTKeyedConfig brickData;
    brickData.setId(brickConfigId);
    while (brickDataCursor.next()) {
      const coral::AttributeList& row = brickDataCursor.currentRow();
      brickData.add(row["CONFIGCMDS.CONFDATA"].data<std::string>());
    }
    cond::KeyedElement k(&brickData, brickConfigId);
    std::cout << "now writing brick: " << brickConfigId << std::endl;
    outdb->writeOneIOV(*(k.m_obj), k.m_key, brickContainer);
  }

  return;
}

getNewObjects()

void DTUserKeyedConfigHandler::getNewObjects ( )

overridevirtual

Operations

Implements popcon::PopConSourceHandler< DTCCBConfig >.

Definition at line 84 of file DTUserKeyedConfigHandler.cc.

References DTCCBConfig::appendConfigKey(), DTCCBConfig::begin(), looper::cfg, chkConfigList(), cond::persistency::ConnectionPool::configure(), DTConfigKey::confKey, DTConfigKey::confType, connection, gather_cfg::cout, cond::persistency::ConnectionPool::createCoralSession(), dataRun, dataTag, DTCCBConfig::end(), isession, crabWrapper::key, keyList, dqmdumpme::last, cond::TagInfo_t::lastInterval, popcon::PopConSourceHandler< DTCCBConfig >::lastPayload(), popcon::PopConSourceHandler< DTCCBConfig >::m_to_transfer, onlineAuthentication, onlineAuthSys, onlineConnect, jetsAK4_Puppi_cff::payload, hgcalTBTopologyTester_cfi::sector, DTCCBId::sectorId, cond::persistency::ConnectionPool::setAuthenticationPath(), cond::persistency::ConnectionPool::setAuthenticationSystem(), DTCCBConfig::setFullKey(), DTCCBConfig::setStamp(), cond::Iov_t::since, relativeConstraints::station, DTCCBId::stationId, AlCaHLTBitMon_QueryRunRegistry::string, popcon::PopConSourceHandler< DTCCBConfig >::tagInfo(), userConf, userDiscardedKey(), makeMuonMisalignmentScenario::wheel, DTCCBId::wheelId, writeData, and writeKeys.

                                             {
  //to access the information on the tag inside the offline database:
  cond::TagInfo_t const& ti = tagInfo();
  cond::Time_t last = ti.lastInterval.since;
  std::cout << "last configuration key already copied for run: " << last << std::endl;

  std::vector<DTConfigKey> lastKey;
  //  std::cout << "check for last " << std::endl;
  if (last == 0) {
    DTCCBConfig* dummyConf = new DTCCBConfig(dataTag);
    dummyConf->setStamp(0);
    dummyConf->setFullKey(lastKey);
    cond::Time_t snc = 1;
    if (writeKeys && (dataRun > 1))
      m_to_transfer.push_back(std::make_pair(dummyConf, snc));
  } else {
    std::cout << "get last payload" << std::endl;
    Ref payload = lastPayload();
    std::cout << "get last full key" << std::endl;
    lastKey = payload->fullKey();
    std::cout << "last key: " << std::endl;
    std::vector<DTConfigKey>::const_iterator keyIter = lastKey.begin();
    std::vector<DTConfigKey>::const_iterator keyIend = lastKey.end();
    while (keyIter != keyIend) {
      const DTConfigKey& keyList = *keyIter++;
      std::cout << keyList.confType << " : " << keyList.confKey << std::endl;
    }
  }

  std::cout << "configure DbConnection" << std::endl;
  //  conn->configure( cond::CmsDefaults );
  connection.setAuthenticationPath(onlineAuthentication);
  connection.setAuthenticationSystem(onlineAuthSys);
  connection.configure();
  std::cout << "create/open DbSession" << std::endl;
  isession = connection.createCoralSession(onlineConnect);
  std::cout << "start transaction" << std::endl;
  isession->transaction().start(true);

  // get ccb identifiers map
  std::cout << "retrieve CCB map" << std::endl;
  std::map<int, DTCCBId> ccbMap;
  coral::ITable& ccbMapTable = isession->nominalSchema().tableHandle("CCBMAP");
  std::unique_ptr<coral::IQuery> ccbMapQuery(ccbMapTable.newQuery());
  ccbMapQuery->addToOutputList("CCBID");
  ccbMapQuery->addToOutputList("WHEEL");
  ccbMapQuery->addToOutputList("SECTOR");
  ccbMapQuery->addToOutputList("STATION");
  coral::ICursor& ccbMapCursor = ccbMapQuery->execute();
  while (ccbMapCursor.next()) {
    const coral::AttributeList& row = ccbMapCursor.currentRow();
    int ccb = row["CCBID"].data<int>();
    int wheel = row["WHEEL"].data<int>();
    int sector = row["SECTOR"].data<int>();
    int station = row["STATION"].data<int>();
    DTCCBId ccbId;
    ccbId.wheelId = wheel;
    ccbId.stationId = station;
    ccbId.sectorId = sector;
    ccbMap.insert(std::pair<int, DTCCBId>(ccb, ccbId));
  }

  // get brick types
  std::cout << "retrieve brick types" << std::endl;
  std::map<int, int> bktMap;
  coral::AttributeList emptyBindVariableList;
  std::unique_ptr<coral::IQuery> brickTypeQuery(isession->nominalSchema().newQuery());
  brickTypeQuery->addToTableList("CFGBRICKS");
  brickTypeQuery->addToTableList("BRKT2CSETT");
  std::string bTypeCondition = "CFGBRICKS.BRKTYPE=BRKT2CSETT.BRKTYPE";
  brickTypeQuery->addToOutputList("CFGBRICKS.BRKID");
  brickTypeQuery->addToOutputList("BRKT2CSETT.CSETTYPE");
  brickTypeQuery->setCondition(bTypeCondition, emptyBindVariableList);
  coral::ICursor& brickTypeCursor = brickTypeQuery->execute();
  while (brickTypeCursor.next()) {
    const coral::AttributeList& row = brickTypeCursor.currentRow();
    int id = row["CFGBRICKS.BRKID"].data<int>();
    int bt = row["BRKT2CSETT.CSETTYPE"].data<short>();
    //    std::cout << "brick " << id << " type " << bt << std::endl;
    // @@FIX - TEMPORARY PATCH
    //    if ( bt > 3 ) bt = 3;
    bktMap.insert(std::pair<int, int>(id, bt));
  }

  // get ccb config keys
  std::cout << "retrieve CCB configuration keys" << std::endl;
  std::map<int, std::map<int, int>*> keyMap;
  std::map<int, int> cckMap;
  coral::ITable& ccbRelTable = isession->nominalSchema().tableHandle("CCBRELATIONS");
  std::unique_ptr<coral::IQuery> ccbRelQuery(ccbRelTable.newQuery());
  ccbRelQuery->addToOutputList("CONFKEY");
  ccbRelQuery->addToOutputList("CCBID");
  ccbRelQuery->addToOutputList("CONFCCBKEY");
  coral::ICursor& ccbRelCursor = ccbRelQuery->execute();
  // loop over all full configurations
  while (ccbRelCursor.next()) {
    const coral::AttributeList& row = ccbRelCursor.currentRow();
    int cfg = row["CONFKEY"].data<int>();
    int ccb = row["CCBID"].data<int>();
    int key = row["CONFCCBKEY"].data<int>();
    // check for used configurations
    //    if ( cfgMap.find( cfg ) == cfgMap.end() ) continue;
    if (userDiscardedKey(cfg))
      continue;
    std::map<int, std::map<int, int>*>::const_iterator keyIter = keyMap.find(cfg);
    std::map<int, std::map<int, int>*>::const_iterator keyIend = keyMap.end();
    std::map<int, int>* mapPtr = nullptr;
    // check for new full configuration
    if (keyIter != keyIend)
      mapPtr = keyIter->second;
    else
      keyMap.insert(std::pair<int, std::map<int, int>*>(cfg, mapPtr = new std::map<int, int>));
    // store ccb config key
    std::map<int, int>& mapRef(*mapPtr);
    mapRef.insert(std::pair<int, int>(ccb, key));
    // check for new ccb config key
    if (cckMap.find(key) == cckMap.end())
      cckMap.insert(std::pair<int, int>(key, ccb));
  }

  // get brick keys
  std::cout << "retrieve CCB configuration bricks" << std::endl;
  std::map<int, std::vector<int>*> brkMap;
  coral::ITable& confBrickTable = isession->nominalSchema().tableHandle("CFG2BRKREL");
  std::unique_ptr<coral::IQuery> confBrickQuery(confBrickTable.newQuery());
  confBrickQuery->addToOutputList("CONFID");
  confBrickQuery->addToOutputList("BRKID");
  coral::ICursor& confBrickCursor = confBrickQuery->execute();
  // loop over all brick keys
  while (confBrickCursor.next()) {
    const coral::AttributeList& row = confBrickCursor.currentRow();
    int key = row["CONFID"].data<int>();
    int brk = row["BRKID"].data<int>();
    // check for used ccb config key
    if (cckMap.find(key) == cckMap.end())
      continue;
    std::map<int, std::vector<int>*>::const_iterator brkIter = brkMap.find(key);
    std::map<int, std::vector<int>*>::const_iterator brkIend = brkMap.end();
    // check for new ccb config key
    std::vector<int>* brkPtr = nullptr;
    if (brkIter != brkIend)
      brkPtr = brkIter->second;
    else
      brkMap.insert(std::pair<int, std::vector<int>*>(key, brkPtr = new std::vector<int>));
    // store brick key
    brkPtr->push_back(brk);
  }

  // set run and full configuration in payload
  DTCCBConfig* fullConf = new DTCCBConfig(dataTag);
  fullConf->setStamp(1);
  fullConf->setFullKey(userConf);
  std::map<int, bool> userBricks;
  std::map<int, bool>::const_iterator uBrkIter = userBricks.begin();
  std::map<int, bool>::const_iterator uBrkIend = userBricks.end();
  std::vector<DTConfigKey>::const_iterator cfgIter = userConf.begin();
  std::vector<DTConfigKey>::const_iterator cfgIend = userConf.end();
  while (cfgIter != cfgIend) {
    const DTConfigKey& cfgEntry = *cfgIter++;
    int cft = cfgEntry.confType;
    int cfg = cfgEntry.confKey;
    // retrieve ccb config map
    std::map<int, std::map<int, int>*>::const_iterator keyIter = keyMap.find(cfg);
    std::map<int, std::map<int, int>*>::const_iterator keyIend = keyMap.end();
    std::map<int, int>* mapPtr = nullptr;
    if (keyIter != keyIend)
      mapPtr = keyIter->second;
    if (mapPtr == nullptr)
      continue;
    std::map<int, int>::const_iterator ccbIter = mapPtr->begin();
    std::map<int, int>::const_iterator ccbIend = mapPtr->end();
    while (ccbIter != ccbIend) {
      const std::pair<int, int>& ccbEntry = *ccbIter++;
      // get ccb config key
      int ccb = ccbEntry.first;
      int key = ccbEntry.second;
      // retrieve chamber id
      std::map<int, DTCCBId>::const_iterator ccbIter = ccbMap.find(ccb);
      std::map<int, DTCCBId>::const_iterator ccbIend = ccbMap.end();
      if (ccbIter == ccbIend)
        continue;
      const DTCCBId& chaId = ccbIter->second;
      // retrieve brick id list
      std::map<int, std::vector<int>*>::const_iterator brkIter = brkMap.find(key);
      std::map<int, std::vector<int>*>::const_iterator brkIend = brkMap.end();
      if (brkIter == brkIend)
        continue;
      std::vector<int>* brkPtr = brkIter->second;
      if (brkPtr == nullptr)
        continue;
      // brick id lists in payload
      std::vector<int> bkList;
      bkList.reserve(20);
      std::map<int, int>::const_iterator bktIter = bktMap.begin();
      std::map<int, int>::const_iterator bktIend = bktMap.end();
      std::vector<int>::const_iterator bkiIter = brkPtr->begin();
      std::vector<int>::const_iterator bkiIend = brkPtr->end();
      while (bkiIter != bkiIend) {
        int brickId = *bkiIter++;
        bktIter = bktMap.find(brickId);
        if (bktIter == bktIend)
          continue;
        if (bktIter->second == cft) {
          bkList.push_back(brickId);
          uBrkIter = userBricks.find(brickId);
          if (uBrkIter == uBrkIend)
            userBricks.insert(std::pair<int, bool>(brickId, true));
        }
      }
      fullConf->appendConfigKey(chaId.wheelId, chaId.stationId, chaId.sectorId, bkList);
    }
  }
  cond::Time_t snc = dataRun;
  if (writeKeys)
    m_to_transfer.push_back(std::make_pair(fullConf, snc));
  std::cout << "writing payload : " << sizeof(*fullConf) << " ( " << (fullConf->end() - fullConf->begin()) << " ) "
            << std::endl;
  if (writeData)
    chkConfigList(userBricks);

  isession->transaction().commit();

  return;
}

id()

std::string DTUserKeyedConfigHandler::id ( ) const

overridevirtual

Implements popcon::PopConSourceHandler< DTCCBConfig >.

Definition at line 380 of file DTUserKeyedConfigHandler.cc.

References dataTag.

{ return dataTag; }

sameConfigList()

bool DTUserKeyedConfigHandler::sameConfigList ( const std::vector< DTConfigKey > &  cfgl, const std::vector< DTConfigKey > &  cfgr  )

staticprivate

Definition at line 382 of file DTUserKeyedConfigHandler.cc.

References mps_splice::entry.

                                                                                  {
  if (cfgl.size() != cfgr.size())
    return false;
  std::map<int, int> lmap;
  std::vector<DTConfigKey>::const_iterator lIter = cfgl.begin();
  std::vector<DTConfigKey>::const_iterator lIend = cfgl.end();
  while (lIter != lIend) {
    const DTConfigKey& entry = *lIter++;
    lmap.insert(std::pair<int, int>(entry.confType, entry.confKey));
  }
  std::map<int, int> rmap;
  std::vector<DTConfigKey>::const_iterator rIter = cfgr.begin();
  std::vector<DTConfigKey>::const_iterator rIend = cfgr.end();
  while (rIter != rIend) {
    const DTConfigKey& entry = *rIter++;
    rmap.insert(std::pair<int, int>(entry.confType, entry.confKey));
  }
  std::map<int, int>::const_iterator lmIter = lmap.begin();
  std::map<int, int>::const_iterator lmIend = lmap.end();
  std::map<int, int>::const_iterator rmIter = rmap.begin();
  std::map<int, int>::const_iterator rmIend = rmap.end();
  while ((lmIter != lmIend) && (rmIter != rmIend)) {
    const std::pair<int, int>& lEntry = *lmIter++;
    const std::pair<int, int>& rEntry = *rmIter++;
    if (lEntry.first != rEntry.first)
      return false;
    if (lEntry.second != rEntry.second)
      return false;
  }
  return true;
}

setList()

void DTUserKeyedConfigHandler::setList

(

const cond::persistency::KeyList *

list

)

Definition at line 426 of file DTUserKeyedConfigHandler.cc.

References keyList.

Referenced by DTUserKeyedConfigPopConAnalyzer::analyze().

{ keyList = list; }

userDiscardedKey()

bool DTUserKeyedConfigHandler::userDiscardedKey ( int  key )

private

Definition at line 415 of file DTUserKeyedConfigHandler.cc.

References mps_splice::entry, crabWrapper::key, and userConf.

Referenced by getNewObjects().

                                                       {
  std::vector<DTConfigKey>::const_iterator iter = userConf.begin();
  std::vector<DTConfigKey>::const_iterator iend = userConf.end();
  while (iter != iend) {
    const DTConfigKey& entry = *iter++;
    if (entry.confKey == key)
      return false;
  }
  return true;
}

Member Data Documentation

brickContainer

std::string DTUserKeyedConfigHandler::brickContainer

private

Definition at line 70 of file DTUserKeyedConfigHandler.h.

Referenced by chkConfigList().

ccbConfig

DTCCBConfig* DTUserKeyedConfigHandler::ccbConfig

private

Definition at line 74 of file DTUserKeyedConfigHandler.h.

connection

cond::persistency::ConnectionPool DTUserKeyedConfigHandler::connection

private

Definition at line 76 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects().

dataRun

int DTUserKeyedConfigHandler::dataRun

private

Definition at line 65 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects().

dataTag

std::string DTUserKeyedConfigHandler::dataTag

private

Definition at line 66 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects(), and id().

isession

std::shared_ptr<coral::ISessionProxy> DTUserKeyedConfigHandler::isession

private

Definition at line 77 of file DTUserKeyedConfigHandler.h.

Referenced by chkConfigList(), and getNewObjects().

keyList

const cond::persistency::KeyList* DTUserKeyedConfigHandler::keyList = nullptr

private

Definition at line 82 of file DTUserKeyedConfigHandler.h.

Referenced by chkConfigList(), getNewObjects(), and setList().

onlineAuthentication

std::string DTUserKeyedConfigHandler::onlineAuthentication

private

Definition at line 68 of file DTUserKeyedConfigHandler.h.

Referenced by DTUserKeyedConfigHandler(), and getNewObjects().

onlineAuthSys

int DTUserKeyedConfigHandler::onlineAuthSys

private

Definition at line 69 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects().

onlineConnect

std::string DTUserKeyedConfigHandler::onlineConnect

private

Definition at line 67 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects().

userConf

std::vector<DTConfigKey> DTUserKeyedConfigHandler::userConf

private

Definition at line 71 of file DTUserKeyedConfigHandler.h.

Referenced by DTUserKeyedConfigHandler(), getNewObjects(), and userDiscardedKey().

writeData

bool DTUserKeyedConfigHandler::writeData

private

Definition at line 73 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects().

writeKeys

bool DTUserKeyedConfigHandler::writeKeys

private

Definition at line 72 of file DTUserKeyedConfigHandler.h.

Referenced by getNewObjects().