Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

CalibMySQLCnvSvc Class Reference

--------------------------------------------------------------------------- More...

#include <CalibMySQLCnvSvc.h>

Inheritance diagram for CalibMySQLCnvSvc:

ICalibMetaCnvSvc ICalibMetaCnvSvc List of all members.

Public Member Functions

virtual StatusCode createAddress (long svc_type, const CLID &clid, const std::string *par, const unsigned long *ip, IOpaqueAddress *&refpAddress)
 Create an address using explicit arguments to identify a single object.
virtual StatusCode createAddress (long svc_type, const CLID &clid, const std::string *par, const unsigned long *ip, IOpaqueAddress *&refpAddress)
 Create an address using explicit arguments to identify a single object.
virtual StatusCode createCalib (DataObject *&refpObject, const std::string &fullpath, const CLID &classID, IRegistry *entry=0)
virtual StatusCode createCalib (DataObject *&refpObject, const std::string &fullpath, const CLID &classID, IRegistry *entry=0)
virtual StatusCode createObj (IOpaqueAddress *pAddress, DataObject *&refpObject)
 Create a transient representation from another rep of this object.
virtual StatusCode createObj (IOpaqueAddress *pAddress, DataObject *&refpObject)
 Create a transient representation from another rep of this object.
virtual StatusCode createRep (DataObject *pObject, IOpaqueAddress *&refpAddress)
 Convert a transient object to a requested representation.
virtual StatusCode createRep (DataObject *pObject, IOpaqueAddress *&refpAddress)
 Convert a transient object to a requested representation.
virtual StatusCode decodeDescription (const std::string &description, unsigned char &type)
 Decode the string storage type to enumerated storage type.
virtual StatusCode decodeDescription (const std::string &description, unsigned char &type)
 Decode the string storage type to enumerated storage type.
virtual StatusCode fillObjRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Resolve the references of the created transient object.
virtual StatusCode fillObjRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Resolve the references of the created transient object.
virtual StatusCode fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Resolve the references of a converted object.
virtual StatusCode fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Resolve the references of a converted object.
virtual StatusCode finalize ()
virtual StatusCode finalize ()
virtual calibUtil::Metadata * getMeta ()
virtual calibUtil::Metadata * getMeta ()
 Handle to the MySQL metadata database.
virtual StatusCode initialize ()
virtual StatusCode initialize ()
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)
virtual StatusCode updateCalib (DataObject *pObject, const std::string &fullpath, const CLID &classID, IRegistry *entry=0)
virtual StatusCode updateCalib (DataObject *pObject, const std::string &fullpath, const CLID &classID, IRegistry *entry=0)
virtual StatusCode updateObj (IOpaqueAddress *pAddress, DataObject *pObject)
 Update a transient representation from another rep of this object.
virtual StatusCode updateObj (IOpaqueAddress *pAddress, DataObject *pObject)
 Update a transient representation from another rep of this object.
virtual StatusCode updateObjRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Update the references of an updated transient object.
virtual StatusCode updateObjRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Update the references of an updated transient object.
virtual StatusCode updateRep (IOpaqueAddress *pAddress, DataObject *pObject)
 Update a converted representation of a transient object.
virtual StatusCode updateRep (IOpaqueAddress *pAddress, DataObject *pObject)
 Update a converted representation of a transient object.
virtual StatusCode updateRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Update the references of an already converted object.
virtual StatusCode updateRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
 Update the references of an already converted object.

Static Public Member Functions

const InterfaceID & interfaceID ()
 Interface ID of this class.
const InterfaceID & interfaceID ()
 Interface ID of this class.

Protected Member Functions

 CalibMySQLCnvSvc (const std::string &name, ISvcLocator *svc)
 CalibMySQLCnvSvc (const std::string &name, ISvcLocator *svc)
virtual ~CalibMySQLCnvSvc ()
virtual ~CalibMySQLCnvSvc ()

Private Attributes

std::string cal_ver
std::string m_bossver [11]
unsigned int m_calibLevelMask
std::string m_calPar [11]
bool m_crash
std::string m_dbName
std::string m_dbStatus
IDetDataSvc * m_detDataSvc
 Handle to the IDetDataSvc interface of the CalibDataSvc.
IDetDataSvc * m_detDataSvc
 Handle to the IDetDataSvc interface of the CalibDataSvc.
IConversionSvc * m_detPersSvc
 Interval in seconds Handle to the IConversionSvc interface of the DetectorPersistencySvc.
IConversionSvc * m_detPersSvc
 Interval in seconds Handle to the IConversionSvc interface of the DetectorPersistencySvc.
facilities::Timestamp * m_enterTimeEnd
facilities::Timestamp * m_enterTimeEnd
std::string m_enterTimeEndString
facilities::Timestamp * m_enterTimeStart
facilities::Timestamp * m_enterTimeStart
std::string m_enterTimeStartString
IDataProviderSvc * m_eventSvc
IDataProviderSvc * m_eventSvc
std::string m_host
 MySQL host, a job options parameter.
IInstrumentName * m_instrSvc
IInstrumentName * m_instrSvc
int m_MdcAlign_No
calibUtil::Metadata * m_meta
 Handle for metadata access.
calibUtil::Metadata * m_meta
 Handle for metadata access.
std::vector< std::string > m_qualityList
std::vector< std::string > m_qualityList
unsigned int m_qualityMask
bool m_useEventTime
 Use event time to select calibration? Normal state is TRUE.
std::string machine
std::string sft_ver

Friends

class SvcFactory<CalibMySQLCnvSvc>
 Only factories can access protected constructors.

Detailed Description

---------------------------------------------------------------------------

A conversion service for GLAST calibration metadata database persistency. Allows to create and update condition data objects (i.e. DataObjects implementing IValidity).

Adapted from LHCb class DetCond/ConditionsDBCnvSvc by Andrea Valassi

Author:
J. Bogart
Date:
November 2002

Constructor & Destructor Documentation

CalibMySQLCnvSvc::CalibMySQLCnvSvc (  const std::string &  name,
ISvcLocator *  svc
)  [protected]
  

00062   : ConversionSvc (name, svc, MYSQL_StorageType)
00063     , m_meta(0), m_useEventTime(true),m_enterTimeStart(0), m_enterTimeEnd(0),
00064     m_qualityMask(0)
00065 {
00066  // declareProperty("Host", m_host = "202.122.37.69");
00067   declareProperty("Host", m_host = "bes3db2.ihep.ac.cn");
00068   declareProperty("UseEventTime", m_useEventTime = true);
00069   declareProperty("EnterTimeEnd", m_enterTimeEndString = std::string("") );
00070   declareProperty("EnterTimeStart", m_enterTimeStartString = std::string("") );
00071 //  declareProperty("DbName", m_dbName = std::string("calib") );
00072   declareProperty("DbName", m_dbName = std::string("offlinedb") );
00073   declareProperty("QualityList", m_qualityList);
00074   declareProperty("CrashOnError", m_crash = true);
00075   declareProperty("Sft_Ver",sft_ver);
00076   declareProperty("Cal_Ver",cal_ver);
00077   declareProperty("MdcCalPar",m_calPar[0]="default");
00078   declareProperty("DeDxCalPar",m_calPar[1]="default");
00079   declareProperty("EmcCalPar",m_calPar[2]="default");
00080   declareProperty("TofCalPar",m_calPar[3]="default"); 
00081   declareProperty("MucCalPar",m_calPar[4]="default");
00082   declareProperty("EsTimeCalPar",m_calPar[5]="default");
00083   declareProperty("EstTofCalPar",m_calPar[6]="default");
00084   declareProperty("MdcAlignPar",m_calPar[7]="default");
00085   declareProperty("TofQElecPar",m_calPar[8]="default");
00086   declareProperty("TofSimPar",m_calPar[9]="default");
00087   declareProperty("DedxSimPar",m_calPar[10]="default");
00088   declareProperty("MdcBossVer",m_bossver[0]="default");
00089   declareProperty("DeDxBossVer",m_bossver[1]="default");
00090   declareProperty("EmcBossVer",m_bossver[2]="default");
00091   declareProperty("TofBossVer",m_bossver[3]="default");
00092   declareProperty("MucBossVer",m_bossver[4]="default");
00093   declareProperty("EsTimeBossVer",m_bossver[5]="default");
00094   declareProperty("EstTofBossVer",m_bossver[6]="default");
00095   declareProperty("MdcAlignBossVer",m_bossver[7]="default");
00096   declareProperty("TofQElecBossVer",m_bossver[8]="default");
00097   declareProperty("TofSimBossVer",m_bossver[9]="default");
00098   declareProperty("DedxSimBossVer",m_bossver[10]="default");
00099   declareProperty("Align_RunNo",m_MdcAlign_No=8093);
00100   declareProperty("Db_Status",m_dbStatus="OK");
00101 }

CalibMySQLCnvSvc::~CalibMySQLCnvSvc (   )  [protected, virtual]
  

00103 { }

CalibMySQLCnvSvc::CalibMySQLCnvSvc (  const std::string &  name,
ISvcLocator *  svc
)  [protected]
 

virtual CalibMySQLCnvSvc::~CalibMySQLCnvSvc (   )  [protected, virtual]
 

Member Function Documentation

virtual StatusCode CalibMySQLCnvSvc::createAddress (  long  svc_type,
const CLID &  clid,
const std::string *  par,
const unsigned long *  ip,
IOpaqueAddress *&  refpAddress
)  [virtual]
 

Create an address using explicit arguments to identify a single object.

StatusCode CalibMySQLCnvSvc::createAddress (  long  svc_type,
const CLID &  clid,
const std::string *  par,
const unsigned long *  ip,
IOpaqueAddress *&  refpAddress
)  [virtual]
 

Create an address using explicit arguments to identify a single object.

Overload ConversionSvc implementation of createAddress. Create an address using explicit arguments to identify a single object. Par[0] is full path in calibration TDS 

00406                                                                           {
00407   // First check that requested address is of type MYSQL_StorageType
00408   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00409   if ( svc_type!= MYSQL_StorageType ) {
00410     log << MSG::ERROR 
00411         << "Cannot create addresses of type " << (int)svc_type 
00412         << " which is different from " << (int)MYSQL_StorageType 
00413         << endreq;
00414     return StatusCode::FAILURE;
00415   }
00416   log << MSG::INFO
00417         << " create address in CalibMySQLCnvSvc "
00418         << endreq;
00419 
00420   refpAddress = new GenericAddress( MYSQL_StorageType, 
00421                                     clid, 
00422                                     par[0]);
00423 
00424   return StatusCode::SUCCESS;
00425 }

virtual StatusCode CalibMySQLCnvSvc::createCalib (  DataObject *&  refpObject,
const std::string &  fullpath,
const CLID &  classID,
IRegistry *  entry = 0
)  [virtual]
 

Create a calib DataObject by calib type name, flavor and time. This method does not register DataObject in the transient data store. The string storage type is discovered at runtime in the Metadata dbs.

Implements ICalibMetaCnvSvc.

StatusCode CalibMySQLCnvSvc::createCalib (  DataObject *&  refpObject,
const std::string &  fullpath,
const CLID &  classID,
IRegistry *  entry = 0
)  [virtual]
 

Create a calib DataObject by calib type name, flavor and time. This method does not register DataObject in the transient data store. The string storage type is discovered at runtime in the Metadata dbs.

Implements ICalibMetaCnvSvc.

00444 {
00445   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00446 
00447   // Look up calib object in the Metadata database
00448   //std::string flavor = CalibData::CalibModelSvc::getFlavor(fullpath);
00449   std::string cType = CalibData::CalibModelSvc::getCalibType(fullpath);
00450     
00451   // ..and extra special munging for test
00452   if (std::string("Test") == cType.substr(0, 4)) {
00453     cType = std::string("Test_Gen");
00454   }
00455 
00456   unsigned int ser;
00457   unsigned int runfrm;
00458   unsigned int runto;
00459   calibUtil::Metadata::eRet ret;
00460  
00461   MSG::Level msgLevel =  MSG::DEBUG;
00462 
00463   std::string physFmt = "UNK";
00464   std::string fmtVersion;
00465   std::string dataIdent;
00466 
00467   // Get the runNo of current event:
00468   SmartDataPtr<Event::EventHeader> evt(m_eventSvc,"/Event/EventHeader");
00469     int runNo=0;
00470       if( !evt ){
00471            log << MSG::WARNING << "Unable to read the Event for TDS" << endreq;
00472 //         return StatusCode::FAILURE;
00473             }   
00474         if( evt ){
00475              if(cType!="TofCal"&&cType!="EstTofCal"&&cType!="TofSim"&&cType!="DedxSim") runNo = fabs(evt -> runNumber());
00476              if(cType=="TofCal"||cType=="EstTofCal"||cType=="TofSim"||cType=="DedxSim") runNo = evt -> runNumber();
00477               }
00478 DatabaseRecordVector res;
00479  if(cType=="TofCal")
00480      {
00481      ret = m_meta->getReadTOFInfo(ser,&runfrm,&runto, m_calPar[3], res,runNo,m_bossver[3]);
00482      }
00483   
00484  if(cType=="EmcCal")
00485      {
00486      ret = m_meta->getReadEMCInfo(ser,&runfrm,&runto, m_calPar[2], res,runNo,m_bossver[2]);
00487      } 
00488 
00489 if(cType=="DedxCal")
00490      {
00491      ret = m_meta->getReadDedxInfo(ser,&runfrm,&runto, m_calPar[1], res,runNo,m_bossver[1]);
00492      }
00493 
00494  if(cType=="MdcCal")
00495      {
00496      ret = m_meta->getReadMDCInfo(ser,&runfrm,&runto, m_calPar[0], res,runNo,m_bossver[0]);
00497      }
00498 
00499  if(cType=="MucCal")
00500      {
00501        ret = m_meta->getReadMUCInfo(ser,&runfrm,&runto, m_calPar[4], res,runNo,m_bossver[4]);
00502      }
00503 if(cType=="EsTimeCal")
00504      {
00505        ret = m_meta->getReadEsTimeInfo(ser,&runfrm,&runto, m_calPar[5], res,runNo,m_bossver[5]);
00506      }
00507 //DatabaseRecordVector res;
00508 
00509 if(cType=="MdcAlign")
00510 {
00511 //   runNo = m_MdcAlign_No;
00512    ret = m_meta->getReadMdcAlignInfo(ser,&runfrm,&runto, m_calPar[7], res,runNo,m_bossver[7]);
00513 }
00514 if(cType=="TofQElec")
00515      { 
00516        ret = m_meta->getReadTofQElecInfo(ser,&runfrm,&runto, m_calPar[8], res,runNo,m_bossver[8]);
00517      }
00518 if(cType=="TofSim")
00519      {
00520        ret = m_meta->getReadTofSimInfo(ser,&runfrm,&runto, m_calPar[9], res,runNo,m_bossver[9]);
00521      }
00522 if(cType=="DedxSim")
00523      {
00524        ret = m_meta->getReadDedxSimInfo(ser,&runfrm,&runto, m_calPar[10], res,runNo,m_bossver[10]);
00525      }
00526 
00527 
00528 
00529 if(cType=="EstTofCal")
00530      {
00531      ret = m_meta->getReadEstTofInfo(ser,&runfrm,&runto, m_calPar[6], res,runNo,m_bossver[6]);
00532      if(ret!=calibUtil::Metadata::RETOk){
00533        log <<  MSG::INFO   << "no record of EstTofCal in the database" << endreq;
00534        IDataProviderSvc* pCDS = 0;
00535   StatusCode sc = serviceLocator()->getService("CalibDataSvc",  IID_IDataProviderSvc, (IInterface*&)pCDS);
00536   if ( !sc.isSuccess() ) {
00537     log << MSG::ERROR << "Could not locate CalibDataSvc" << endreq;
00538     return sc;
00539   } 
00540  //    sc = service("CalibDataSvc", m_pCalibDataSvc, true);
00541       IDataManagerSvc *dataManSvc = dynamic_cast<IDataManagerSvc*> (pCDS); 
00542        dataManSvc->clearSubTree("/Calib/EstTofCal");
00543        pCDS->unregisterObject("/Calib/EstTofCal");
00544        return StatusCode::FAILURE;
00545       }     
00546 }
00547 
00548 if(ret!=calibUtil::Metadata::RETOk){
00549  log <<  MSG::ERROR   << "no record in the database" << endreq;
00550  exit(1);
00551 }
00552    int sz=res.size();
00553    DatabaseRecord* records1 = res[0];
00554    sscanf((*records1)["RunFrom"], "%ld", &runfrm);
00555    sscanf((*records1)["RunTo"], "%ld", &runto);
00556 
00557   if(m_dbStatus=="OK"){
00558      if(std::string((*records1)["Status"])!="OK") {
00559        log<<MSG::FATAL<<"Status of type "<<cType<<" is "<< (*records1)["Status"]<<"  your setting is OK"<<endreq;
00560        exit(1);
00561       }
00562    }
00563 
00564 
00565    log << MSG::DEBUG << "dataIdent is:"<<dataIdent<< endreq;
00566    log << MSG::DEBUG << "runfrm is:"<<int(runfrm)<<" runto is:"<<runto<<"ser_no is:"<<ser<<endreq;
00567 unsigned char storageType;
00568   physFmt="TREE";
00569   StatusCode sc = decodeDescription(physFmt, storageType);
00570   
00571 
00572   // Depending on value of eDataFmt, figure out which private
00573   // conversion service to invoke.  Pass dataIdent and fmtVersion
00574   // as part of the opaque address.  
00575   // Create temporary address for the relevant type and classID 
00576   log << MSG::DEBUG << "Creating an address of type "
00577       << (int)storageType << " for class " << classID << endreq;
00578 
00579   IOpaqueAddress* tmpAddress;
00580   const std::string par[3] = {dataIdent, fullpath, fmtVersion};
00581   const unsigned long ipar[2] = {int(runfrm),int(runto)};
00582    log << MSG::DEBUG << "ipar is:"<<ipar[0]<<":"<<ipar[1]<<"ipar[1]"<<endreq;
00583    
00584 //  sc = addressCreator()->createAddress(storageType, classID,
00585 //                                       par, ipar, tmpAddress);
00586 
00587   tmpAddress = new TreeAddress(storageType, classID,*records1,ipar);
00588 
00589 /*
00590    if ( !sc.isSuccess() ) {
00591     log << msgLevel  << "Persistency service could not create a new address" << endreq;
00592     if (m_crash) {
00593         log << msgLevel << std::endl << "Exiting... " << std::endl << endreq;
00594       exit(1);
00595     }
00596      return sc;
00597   }
00598 */
00599   tmpAddress->addRef();
00600 
00601   // Set the transient store registry for the object associated to this address
00602   tmpAddress->setRegistry(entry);
00603 
00604 // Now create the object
00605  sc = m_detPersSvc->createObj(tmpAddress, refpObject);
00606   tmpAddress->release();
00607   if ( !sc.isSuccess() ) {
00608     log << msgLevel
00609         << "Persistency service could not create a new object" << endreq;
00610     if (m_crash) {
00611       log << msgLevel << std::endl << "Exiting... " << std::endl << endreq;
00612       exit(1);
00613     }
00614     return sc;
00615   }
00616 //  std::cout<<" CalibMySQLCnvSvc  res.size()=="<<res.size()<<std::endl;
00617   res.clear();
00618   log << MSG::DEBUG << "New object successfully created" << endreq;
00619   return StatusCode::SUCCESS;
00620 
00621 }

virtual StatusCode CalibMySQLCnvSvc::createObj (  IOpaqueAddress *  pAddress,
DataObject *&  refpObject
)  [virtual]
 

Create a transient representation from another rep of this object.

StatusCode CalibMySQLCnvSvc::createObj (  IOpaqueAddress *  pAddress,
DataObject *&  refpObject
)  [virtual]
 

Create a transient representation from another rep of this object.

Create a transient representation from another representation of an object. Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. (The typical conversion service delegates this to an appropriate converter) 

00251                                                                      {
00252 
00253   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00254 
00255 
00256   // Create the object according to calib type, flavor, time, instrument, clid.
00257   // Notice that the CalibMySQLCnvSvc has no converters of its own:
00258   // object creation is delegated to another CnvSvc via a temporary address
00259   // The IOpaqueAddress specifies calibration type and specific flavor.
00260   // The secondary storage type is always discovered dynamically
00261   StatusCode sc;
00262 
00263   sc = createCalib(refpObject,
00264                     pAddress->par()[0],
00265                     pAddress->clID(),
00266                     pAddress->registry() );
00267    
00268    
00269   if ( !sc.isSuccess() ) {
00270     log << MSG::ERROR << "Could not create calib DataObject" << endreq;
00271   }
00272   log << MSG::DEBUG << "Method createObj exiting" << endreq;
00273   return sc;
00274 }

virtual StatusCode CalibMySQLCnvSvc::createRep (  DataObject *  pObject,
IOpaqueAddress *&  refpAddress
)  [virtual]
 

Convert a transient object to a requested representation.

StatusCode CalibMySQLCnvSvc::createRep (  DataObject *  pObject,
IOpaqueAddress *&  refpAddress
)  [virtual]
 

Convert a transient object to a requested representation.

Convert a transient object to a requested representation. Not implemented. Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. 

00360                                                                           {
00361 
00362   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00363   // log << MSG::WARNING << "Method createRep is not implemented" << endreq;
00364   return StatusCode::SUCCESS;
00365 }

virtual StatusCode CalibMySQLCnvSvc::decodeDescription (  const std::string &  description,
unsigned char &  type
)  [virtual]
 

Decode the string storage type to enumerated storage type.

StatusCode CalibMySQLCnvSvc::decodeDescription (  const std::string &  description,
unsigned char &  type
)  [virtual]
 

Decode the string storage type to enumerated storage type. 

00848 {
00849   MsgStream log(msgSvc(), "CalibMySQLCnvSvc");
00850  
00851 //   description ="ROOT";
00852   if (description == std::string("XML")) {
00853     type = XML_StorageType;
00854   }
00855   else if (description == std::string("ROOT")) {
00856     type = CALIBROOT_StorageType;
00857   }
00858   else if (description == std::string("TREE")) {
00859     type = CALIBTREE_StorageType;
00860   }
00861   else {       // unsupported
00862     log << MSG::ERROR << "unsupported storage type " << description << endreq;
00863     return StatusCode::FAILURE;
00864   }
00865   return StatusCode::SUCCESS;
00866 }

virtual StatusCode CalibMySQLCnvSvc::fillObjRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Resolve the references of the created transient object.

StatusCode CalibMySQLCnvSvc::fillObjRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Resolve the references of the created transient object.

Resolve the references of the created transient object. (Actually, don't, because this operation isn't supported, nor is it needed for the conversion service.) Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. 

00281                                                                         {
00282   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00283   return StatusCode::SUCCESS;
00284 }

virtual StatusCode CalibMySQLCnvSvc::fillRepRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Resolve the references of a converted object.

StatusCode CalibMySQLCnvSvc::fillRepRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Resolve the references of a converted object.

Resolve the references of a converted object. [actually, don't. Calib data doesn't have any inter-object references.] Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. 

00372                                                                          {
00373   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00374   //  log << MSG::WARNING << "Method fillRepRefs is not implemented" << endreq;
00375   return StatusCode::SUCCESS;
00376 }

virtual StatusCode CalibMySQLCnvSvc::finalize (   )  [virtual]
 

StatusCode CalibMySQLCnvSvc::finalize (   )  [virtual]
  

00223 {
00224   MsgStream log(msgSvc(), "CalibMySQLCnvSvc");
00225   log << MSG::DEBUG << "Finalizing" << endreq;
00226   delete m_meta;
00227   m_meta = 0;
00228   return ConversionSvc::finalize();
00229 }

virtual calibUtil::Metadata* CalibMySQLCnvSvc::getMeta (   )  [virtual]
 

Implements ICalibMetaCnvSvc.

calibUtil::Metadata * CalibMySQLCnvSvc::getMeta (   )  [virtual]
 

Handle to the MySQL metadata database.

Implements ICalibMetaCnvSvc.

00870                                               {
00871   return m_meta;
00872 }

virtual StatusCode CalibMySQLCnvSvc::initialize (   )  [virtual]
 

StatusCode CalibMySQLCnvSvc::initialize (   )  [virtual]
  

00106 {
00107   // Initialize base class
00108   StatusCode sc = ConversionSvc::initialize();
00109   if ( !sc.isSuccess() ) return sc;
00110 
00111   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00112   log << MSG::INFO << "Specific initialization starting" << endreq;
00113 
00114   // Locate the Calib Data Service.  Since it inherits from DataSvc
00115   // it has to implement IDataProviderSvc
00116   IDataProviderSvc* pCDS = 0;
00117   sc = serviceLocator()->getService 
00118     ("CalibDataSvc",  IID_IDataProviderSvc, (IInterface*&)pCDS);
00119   if ( !sc.isSuccess() ) {
00120     log << MSG::ERROR << "Could not locate CalibDataSvc" << endreq;
00121     return sc;
00122   }
00123 
00124  sc = serviceLocator()->service("EventDataSvc", m_eventSvc, true);
00125    if (sc .isFailure() ) {
00126          log << MSG::ERROR << "Unable to find EventDataSvc " << endreq;
00127              return sc;
00128                }
00129 
00130    
00131   // Set the CalibDataSvc as data provider service
00132   sc = setDataProvider(pCDS);
00133   if ( !sc.isSuccess() ) {
00134     log << MSG::ERROR << "Could not set data provider" << endreq;
00135     return sc;
00136   }
00137 
00138   // Query the IDetDataSvc and IInstrumentName interfaces of the 
00139   // calib data service
00140   sc = pCDS->queryInterface(IID_IDetDataSvc, (void**) &m_detDataSvc);
00141   if ( !sc.isSuccess() ) {
00142     log << MSG::ERROR 
00143         << "Cannot query IDetDataSvc interface of CalibDataSvc" << endreq;
00144     return sc;
00145   } else {
00146     log << MSG::DEBUG << "Retrieved IDetDataSvc interface of CalibDataSvc" 
00147         << endreq;
00148   }
00149   // Locate IConversionSvc interface of the DetectorPersistencySvc
00150   sc = serviceLocator()->service 
00151     ("DetectorPersistencySvc", m_detPersSvc, true);
00152   if ( !sc.isSuccess() ) {
00153     log << MSG::ERROR 
00154         << "Cannot locate IConversionSvc interface of DetectorPersistencySvc"
00155         << endreq;
00156     return sc;
00157   } else {
00158     log << MSG::DEBUG 
00159         << "Retrieved IConversionSvc interface of DetectorPersistencySvc"
00160         << endreq;
00161   }
00162   
00163   // Query the IAddressCreator interface of the detector persistency service
00164   IAddressCreator* iAddrCreator;
00165   sc = m_detPersSvc->queryInterface(IID_IAddressCreator, 
00166                                     (void**) &iAddrCreator);
00167   if ( !sc.isSuccess() ) {
00168     log << MSG::ERROR 
00169         << "Cannot query IAddressCreator interface of DetectorPersistencySvc" 
00170         << endreq;
00171     return sc;
00172   } else {
00173     log << MSG::DEBUG 
00174         << "Retrieved IAddressCreator interface of DetectorPersistencySvc" 
00175         << endreq;
00176   }
00177   //  log << MSG::DEBUG 
00178   //    << "Set it as the address creator of the CalibMySQLCnvSvc" << endreq;
00179   sc = setAddressCreator(iAddrCreator);
00180   if ( !sc.isSuccess() ) {
00181     log << MSG::ERROR   << "Cannot set the address creator" << endreq;
00182     return sc;
00183   }
00184 
00185   // Get properties from the JobOptionsSvc
00186   sc = setProperties();
00187   if ( !sc.isSuccess() ) {
00188     log << MSG::ERROR << "Could not set jobOptions properties" << endreq;
00189     return sc;
00190   }
00191   log << MSG::DEBUG << "Properties were read from jobOptions" << endreq;
00192 
00193   // Translate list of calibration quality names to bit mask form used 
00194   // by calibUtil::Metadata::findBest     Defaults to PROD + DEV for now
00195   // (that was old fixed value)
00196   m_qualityMask = toQualityMask(m_qualityList);
00197   if (!m_qualityMask) {
00198     m_qualityMask = calibUtil::Metadata::LEVELProd |
00199       calibUtil::Metadata::LEVELDev;
00200   }
00201 
00202   // Make a calibUtil::Metadata instance 
00203   // Conceivably, could start up a different conversion service, depending 
00204   // on job options parameters, which would look very much like this one
00205   // except for having a different way to access metadata.
00206   m_meta = new calibUtil::Metadata(m_host, "*", m_dbName);
00207 
00208   if (!m_meta) {
00209     log << MSG::ERROR << "Could not open connection to metadata dbs" << endreq;
00210     return MSG::ERROR;
00211   }
00212   // Probably should get this value from job options. 
00213   // Now we do.  See m_qualityMask, m_qualityList
00214   //  m_calibLevelMask = calibUtil::Metadata::LEVELProd + 
00215   //    calibUtil::Metadata::LEVELDev;
00216 
00217   log << MSG::INFO << "Specific initialization completed" << endreq;
00218   return sc;
00219 }

const InterfaceID& ICalibMetaCnvSvc::interfaceID (   )  [inline, static, inherited]
 

Interface ID of this class. 

00048 { return IID_ICalibMetaCnvSvc; }

const InterfaceID& ICalibMetaCnvSvc::interfaceID (   )  [inline, static, inherited]
 

Interface ID of this class. 

00048 { return IID_ICalibMetaCnvSvc; }

virtual StatusCode CalibMySQLCnvSvc::queryInterface (  const InterfaceID &  riid,
void **  ppvInterface
)  [virtual]
 

StatusCode CalibMySQLCnvSvc::queryInterface (  const InterfaceID &  riid,
void **  ppvInterface
)  [virtual]
  

00234 {
00235   if ( IID_ICalibMetaCnvSvc == riid )  {
00236     // With the highest priority return the specific interface of this service
00237     *ppvInterface = (ICalibMetaCnvSvc*)this;
00238   } else  {
00239     // Interface is not directly available: try out a base class
00240     return ConversionSvc::queryInterface(riid, ppvInterface);
00241   }
00242   addRef();
00243   return StatusCode::SUCCESS;
00244 }

virtual StatusCode CalibMySQLCnvSvc::updateCalib (  DataObject *  pObject,
const std::string &  fullpath,
const CLID &  classID,
IRegistry *  entry = 0
)  [virtual]
 

Update a condition DataObject by This method does not register DataObject in the transient data store. The string storage type is discovered at runtime in the metadata dbs.

Implements ICalibMetaCnvSvc.

StatusCode CalibMySQLCnvSvc::updateCalib (  DataObject *  pObject,
const std::string &  fullpath,
const CLID &  classID,
IRegistry *  entry = 0
)  [virtual]
 

Update a condition DataObject by This method does not register DataObject in the transient data store. The string storage type is discovered at runtime in the metadata dbs.

Implements ICalibMetaCnvSvc.

00638 {
00639   using CalibData::CalibBase;
00640 
00641   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00642   StatusCode status;
00643 
00644   // Look up calib object in the Metadata database
00645   //std::string flavor = CalibData::CalibModelSvc::getFlavor(fullpath);
00646   std::string cType = CalibData::CalibModelSvc::getCalibType(fullpath);
00647 
00648   // ..and extra special munging for test
00649   if (std::string("Test") == cType.substr(0, 4)) {
00650     cType = std::string("Test_Gen");
00651   }
00652 
00653   if (0 == pObject) {
00654     log << MSG::ERROR << "There is no DataObject to update" << endreq;
00655     return StatusCode::FAILURE;
00656   }
00657   // Is object an instance of the specified class?
00658   if(pObject->clID()!=6411&& classID!=6411){
00659   if ( classID != pObject->clID() ) {
00660     log << MSG::ERROR << "Update requested for clID " << classID
00661         << " while DataObject is of clID " 
00662         << pObject->clID() << endreq;
00663     exit(1);
00664     return StatusCode::FAILURE;
00665   }
00666 }
00667   
00668   // check if already valid.  If so, we're done.
00669   //  Need access to IValidity interface
00670   CalibBase1* pBase = dynamic_cast<CalibBase1*>(pObject);
00671   if (pBase == 0) {
00672     log << MSG::WARNING
00673         << "Object to be updated is not a calib object! " << endreq;
00674     return StatusCode::FAILURE;
00675   }
00676 
00677   // Following comes from createCalib.  Perhaps create and update
00678   // should be calling common utility since much of what they do is identical.
00679   unsigned int ser;
00680   unsigned int runfrm;
00681   unsigned int runto;
00682   calibUtil::Metadata::eRet ret;
00683   
00684   //  calibUtil::Metadata::eDataFmt physFmt = calibUtil::Metadata::FMTUnknown;
00685   std::string physFmt;
00686   std::string fmtVersion;
00687   std::string dataIdent;
00688   // Get the information needed to find and interpret the bulk data:
00689   //   * physical storage type
00690   //   * version of the physical format
00691   //   * pathname or similar identifying information so the data can be found
00692 //   maqm comment remove fmtversion :
00693 //    ret = m_meta->getReadInfo(ser, physFmt, fmtVersion, dataIdent);
00694   
00695    SmartDataPtr<Event::EventHeader> evt(m_eventSvc,"/Event/EventHeader");
00696    int runNo=0;
00697    if( !evt ){
00698      log << MSG::WARNING << "Unable to read the Event for TDS" << endreq;
00699 //     return StatusCode::FAILURE;
00700    }
00701 
00702 //  eRet ret;
00703 
00704   DatabaseRecordVector res;
00705    if( evt ){
00706      if(cType!="TofCal"&&cType!="EstTofCal"&&cType!="TofSim"&&cType!="DedxSim") runNo = fabs(evt -> runNumber());
00707      if(cType=="TofCal"||cType=="EstTofCal"||cType=="TofSim"||cType=="DedxSim") runNo = evt -> runNumber();
00708    }
00709   if(cType=="TofCal")
00710      {
00711      ret = m_meta->getReadTOFInfo(ser,&runfrm,&runto, m_calPar[3], res,runNo,m_bossver[3]);
00712      }
00713   
00714  if(cType=="EmcCal")
00715      {
00716      ret = m_meta->getReadEMCInfo(ser,&runfrm,&runto, m_calPar[2], res,runNo,m_bossver[2]);
00717      }
00718 if(cType=="DedxCal")
00719      {
00720      ret = m_meta->getReadDedxInfo(ser,&runfrm,&runto, m_calPar[1], res,runNo,m_bossver[1]);
00721      }
00722  if(cType=="MdcCal")
00723      {
00724      ret = m_meta->getReadMDCInfo(ser,&runfrm,&runto, m_calPar[0], res,runNo,m_bossver[0]);
00725      }
00726  if(cType=="MucCal")
00727      {
00728        ret = m_meta->getReadMUCInfo(ser,&runfrm,&runto, m_calPar[4], res,runNo,m_bossver[4]);
00729      }
00730  if(cType=="EsTimeCal")
00731      {
00732        ret = m_meta->getReadEsTimeInfo(ser,&runfrm,&runto, m_calPar[5], res,runNo,m_bossver[5]);
00733      }
00734 //DatabaseRecordVector res;
00735  if(cType=="MdcAlign")
00736    {
00737       ret = m_meta->getReadMdcAlignInfo(ser,&runfrm,&runto, m_calPar[7], res,runNo,m_bossver[7]);
00738   }
00739 if(cType=="TofQElec")
00740      {
00741        ret = m_meta->getReadTofQElecInfo(ser,&runfrm,&runto, m_calPar[8], res,runNo,m_bossver[8]);
00742      }
00743 if(cType=="TofSim")
00744      {
00745        ret = m_meta->getReadTofSimInfo(ser,&runfrm,&runto, m_calPar[9], res,runNo,m_bossver[9]);
00746      }
00747 if(cType=="DedxSim")
00748      {
00749        ret = m_meta->getReadDedxSimInfo(ser,&runfrm,&runto, m_calPar[10], res,runNo,m_bossver[10]);
00750      }
00751 
00752 
00753  if(cType=="EstTofCal")
00754      {
00755      ret = m_meta->getReadEstTofInfo(ser,&runfrm,&runto, m_calPar[6], res,runNo,m_bossver[6]);
00756      if(ret!=calibUtil::Metadata::RETOk){
00757        log <<  MSG::INFO   << "no record of EstTofCal in the database" << endreq;
00758        IDataProviderSvc* pCDS = 0;
00759   StatusCode sc = serviceLocator()->getService("CalibDataSvc",  IID_IDataProviderSvc, (IInterface*&)pCDS);
00760   if ( !sc.isSuccess() ) {
00761     log << MSG::ERROR << "Could not locate CalibDataSvc" << endreq;
00762     return sc;
00763   } 
00764  //    sc = service("CalibDataSvc", m_pCalibDataSvc, true);
00765       IDataManagerSvc *dataManSvc = dynamic_cast<IDataManagerSvc*> (pCDS);
00766        dataManSvc->clearSubTree("/Calib/EstTofCal");
00767        pCDS->unregisterObject("/Calib/EstTofCal");
00768        return StatusCode::FAILURE;
00769       }  
00770    }
00771 
00772   if(ret!=calibUtil::Metadata::RETOk){
00773  log <<  MSG::ERROR   << "Error searching in the database" << endreq;
00774   exit(1);
00775   }
00776   
00777    physFmt="TREE";
00778   unsigned char storageType;
00779   status = decodeDescription(physFmt, storageType);
00780 
00781   // Depending on value of eDataFmt, figure out which private
00782   // conversion service to invoke.  Pass dataIdent and fmtVersion
00783   // as part of the opaque address.  
00784   // Create temporary address for the relevant type and classID 
00785   log << MSG::DEBUG << "Creating an address of type " 
00786       << (int)storageType << " for class " << classID << endreq;
00787 
00788 //   int sz=res.size();
00789    DatabaseRecord* records1 = res[0];
00790    sscanf((*records1)["RunFrom"], "%ld", &runfrm);
00791    sscanf((*records1)["RunTo"], "%ld", &runto);
00792 
00793     if(m_dbStatus=="OK"){
00794      if(std::string((*records1)["Status"])!="OK") {
00795        log<<MSG::FATAL<<"the status of type  "<<cType<<" is "<< (*records1)["Status"]<<"  your setting is OK"<<endreq;
00796        exit(1);
00797       }
00798    }
00799 
00800 
00801   IOpaqueAddress* tmpAddress;
00802   const unsigned long ipar[2] = {runfrm,runto};
00803   
00804    tmpAddress = new TreeAddress(storageType, classID,*records1,ipar);
00805   log << MSG::DEBUG << "Temporary address successfully created" << endreq;
00806   tmpAddress->addRef();
00807 
00808   // Set the transient store registry for the object associated to this address
00809   tmpAddress->setRegistry(entry);
00810 
00811   // Now update the object
00812   DataObject* pNewObject;
00813   status = m_detPersSvc->createObj(tmpAddress, pNewObject);
00814   tmpAddress->release();
00815   if ( !status.isSuccess() ) {
00816     log << MSG::ERROR 
00817         << "Persistency service could not create object" << endreq;
00818     return status;
00819   }
00820 
00821   // Since DataObject::operator= operator is not virtual, dynamic cast first!
00822   // Overloaded virtual method Condition::update() must be properly defined!
00823   // The memory pointed to by the old pointer must contain the new object    
00824   // Note this dynamic cast only gets us part-way.  The object is
00825   // actually of some type derived from CalibBase.
00826   CalibBase1* pNewBase = dynamic_cast<CalibBase1*>(pNewObject);
00827   if  (0 == pNewBase) {
00828     log << MSG::ERROR
00829         << "Cannot update objects other than Calib objects: " 
00830         << "update() must be defined!"
00831         << endreq;
00832     return StatusCode::FAILURE;
00833   }
00834 
00835   // Deep copy the new calib into the old DataObject.  To copy the *whole*
00836   // object, not just the CalibBase part, classes derived from CalibBase
00837   // must override update method.  
00838   // NOTE:  classes directly derived from CalibBase must call
00839   //        CalibBase::update in their own update method.
00840   pBase->update(*pNewBase, &log);  
00841   res.clear();
00842   delete pNewBase;
00843   return StatusCode::SUCCESS;
00844 }

virtual StatusCode CalibMySQLCnvSvc::updateObj (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update a transient representation from another rep of this object.

StatusCode CalibMySQLCnvSvc::updateObj (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update a transient representation from another rep of this object.

Update a transient representation from another representation of an object. Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. 

00290                                                                   {
00291 
00292   //  using facilities::Timestamp;
00293 
00294    MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00295    
00296    // Don't update when we're using enter time
00297    log << MSG::DEBUG << "CalibMySQLCnvSvc::updateObj starting ...."<<endreq;
00298 
00299   // Update the object according to calibration type, flavor, time, 
00300   // instrument, clid, 
00301   // Notice that the CalibMySQLCnvSvc has no converters of its own:
00302   // object creation is delegated to another CnvSvc via a temporary address
00303   // The IOpaqueAddress specifies calibration type and flavor
00304   // The secondary storage type is always discovered dynamically
00305   /*if( 0 == pObject ) {
00306     log << MSG::ERROR << "There is no object to update" << endreq;
00307     return StatusCode::FAILURE;
00308   }
00309   IValidity* pValidity = dynamic_cast<IValidity*>(pObject);
00310   if (0 == pValidity) {
00311     log << MSG::WARNING
00312         << "Object to update does not implement IValidity: assume up-to-date" 
00313         << endreq;
00314     return StatusCode::SUCCESS;
00315   }
00316   */
00317   if( 0 == pObject ) {
00318     log << MSG::ERROR << "There is no object to update" << endreq;
00319     return StatusCode::FAILURE;
00320   } 
00321 
00322   StatusCode sc = updateCalib(pObject, pAddress->par()[0], 
00323                    pAddress->clID(), pAddress->registry() );
00324   if ( !sc.isSuccess() ) {
00325     log << MSG::ERROR << "Could not update calib DataObject" << endreq;
00326     return sc;
00327   }
00328 
00329   // Last, check that everything is OK
00330   /* pValidity = dynamic_cast<IValidity*>(pObject);
00331   if ( 0 == pValidity ) {
00332     log << MSG::ERROR 
00333         << "Updated object does not implement IValidity" << endreq;
00334     return StatusCode::FAILURE;
00335   }
00336   log << MSG::DEBUG << "New calib DataObject is valid since "
00337   << pValidity->validSince().hours() 
00338   << " till " << pValidity->validTill().hours()  
00339   << endreq;
00340   */
00341   //  log << MSG::DEBUG << "Method updateObj exiting" << endreq;
00342   return StatusCode::SUCCESS;  
00343 }

virtual StatusCode CalibMySQLCnvSvc::updateObjRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update the references of an updated transient object.

StatusCode CalibMySQLCnvSvc::updateObjRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update the references of an updated transient object.

Update the references of an updated transient object. [actually, don't. Calib data doesn't have any inter-object references.] Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. 

00349                                                                            {
00350   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00351   //  log << MSG::WARNING << "Method updateObjRefs is not implemented" 
00352   // << endreq;
00353   return StatusCode::SUCCESS;
00354 }

virtual StatusCode CalibMySQLCnvSvc::updateRep (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update a converted representation of a transient object.

StatusCode CalibMySQLCnvSvc::updateRep (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update a converted representation of a transient object.

Update a converted representation of a transient object. Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. 

00382                                                                        {
00383   MsgStream log(msgSvc(), "CalibMySQLCnvSvc" );
00384   // log << MSG::WARNING << "Method updateRep is not implemented" << endreq;
00385   return StatusCode::SUCCESS;
00386 }

virtual StatusCode CalibMySQLCnvSvc::updateRepRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update the references of an already converted object.

StatusCode CalibMySQLCnvSvc::updateRepRefs (  IOpaqueAddress *  pAddress,
DataObject *  pObject
)  [virtual]
 

Update the references of an already converted object.

Update the references of an already converted object. Overloaded from ConversionSvc because CalibMySQLCnvSvc has no converters. Don't do anything because calib objects have no inter-object references. 

00393                                                                            {
00394   MsgStream log(msgSvc(), "CalibMySQLCnvSvc");
00395   //log << MSG::WARNING << "Method updateRepRefs is not implemented" << endreq;
00396   return StatusCode::SUCCESS;
00397 }

Friends And Related Function Documentation

SvcFactory<CalibMySQLCnvSvc> [friend]
 

Only factories can access protected constructors.

Member Data Documentation

std::string CalibMySQLCnvSvc::cal_ver [private]
 

std::string CalibMySQLCnvSvc::m_bossver [private]
 

unsigned int CalibMySQLCnvSvc::m_calibLevelMask [private]
 

How official does a calibration have to be in order to be acceptable Should default to calibUtil::Metadata::LEVELProd

std::string CalibMySQLCnvSvc::m_calPar [private]
 

bool CalibMySQLCnvSvc::m_crash [private]
 

std::string CalibMySQLCnvSvc::m_dbName [private]
 

std::string CalibMySQLCnvSvc::m_dbStatus [private]
 

IDetDataSvc* CalibMySQLCnvSvc::m_detDataSvc [private]
 

Handle to the IDetDataSvc interface of the CalibDataSvc.

IDetDataSvc* CalibMySQLCnvSvc::m_detDataSvc [private]
 

Handle to the IDetDataSvc interface of the CalibDataSvc.

IConversionSvc* CalibMySQLCnvSvc::m_detPersSvc [private]
 

Interval in seconds Handle to the IConversionSvc interface of the DetectorPersistencySvc.

IConversionSvc* CalibMySQLCnvSvc::m_detPersSvc [private]
 

Interval in seconds Handle to the IConversionSvc interface of the DetectorPersistencySvc.

facilities::Timestamp* CalibMySQLCnvSvc::m_enterTimeEnd [private]
 

facilities::Timestamp* CalibMySQLCnvSvc::m_enterTimeEnd [private]
 

std::string CalibMySQLCnvSvc::m_enterTimeEndString [private]
 

facilities::Timestamp* CalibMySQLCnvSvc::m_enterTimeStart [private]
 

Following only used if m_useEventTime is FALSE. In this case search for calibration using enter-time instead

facilities::Timestamp* CalibMySQLCnvSvc::m_enterTimeStart [private]
 

Following only used if m_useEventTime is FALSE. In this case search for calibration using enter-time instead

std::string CalibMySQLCnvSvc::m_enterTimeStartString [private]
 

IDataProviderSvc* CalibMySQLCnvSvc::m_eventSvc [private]
 

IDataProviderSvc* CalibMySQLCnvSvc::m_eventSvc [private]
 

std::string CalibMySQLCnvSvc::m_host [private]
 

MySQL host, a job options parameter.

IInstrumentName* CalibMySQLCnvSvc::m_instrSvc [private]
 

IInstrumentName* CalibMySQLCnvSvc::m_instrSvc [private]
 

int CalibMySQLCnvSvc::m_MdcAlign_No [private]
 

calibUtil::Metadata* CalibMySQLCnvSvc::m_meta [private]
 

Handle for metadata access.

calibUtil::Metadata* CalibMySQLCnvSvc::m_meta [private]
 

Handle for metadata access.

std::vector<std::string> CalibMySQLCnvSvc::m_qualityList [private]
 

Job option parameter; individual items may take on values "PROD", "DEV", "TEST", "SUPSED" (look only at first 3 characters)

std::vector<std::string> CalibMySQLCnvSvc::m_qualityList [private]
 

Job option parameter; individual items may take on values "PROD", "DEV", "TEST", "SUPSED" (look only at first 3 characters)

unsigned int CalibMySQLCnvSvc::m_qualityMask [private]
 

bool CalibMySQLCnvSvc::m_useEventTime [private]
 

Use event time to select calibration? Normal state is TRUE.

std::string CalibMySQLCnvSvc::machine [private]
 

std::string CalibMySQLCnvSvc::sft_ver [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 15:55:55 2011 for BOSS6.5.5 by  doxygen 1.3.9.1