|
Gaudi Framework, version v22r2 |
| Home | Generated: Tue May 10 2011 |
|
|
Gaudi Framework, version v22r2 |
| Home | Generated: Tue May 10 2011 |
NTuple converter class definition. More...
#include <PoolDb/PoolDbNTupleCnv.h>
Public Member Functions | |
| PoolDbNTupleCnv (long typ, const CLID &clid, ISvcLocator *svc) | |
| Standard constructor. | |
| virtual | ~PoolDbNTupleCnv () |
| Standard destructor. | |
| virtual StatusCode | createRep (DataObject *pObject, IOpaqueAddress *&refpAddress) |
| Converter overrides: Convert the transient object to the requested representation. | |
| virtual StatusCode | fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject) |
| Resolve the references of the converted object. | |
| virtual StatusCode | createObj (IOpaqueAddress *pAddress, DataObject *&refpObject) |
| Converter overrides: Update the references of an updated transient object. | |
| virtual StatusCode | fillObjRefs (IOpaqueAddress *, DataObject *) |
| Converter overrides: Update the references of an updated transient object. | |
| virtual StatusCode | updateObj (IOpaqueAddress *pAddress, DataObject *pObject) |
| Update the transient object: NTuples end here when reading records. | |
| virtual StatusCode | updateObjRefs (IOpaqueAddress *, DataObject *) |
| Converter overrides: Update the references of an updated transient object. | |
| virtual StatusCode | updateRep (IOpaqueAddress *, DataObject *) |
| Converter overrides: Update the converted representation of a transient object. | |
| virtual StatusCode | updateRepRefs (IOpaqueAddress *, DataObject *) |
| Converter overrides: Update the converted representation of a transient object. | |
Protected Member Functions | |
| StatusCode | bindRead (INTuple *pTuple, PoolDbTupleCallback *call) |
| Callback to bind N-tuple data for reading. | |
| StatusCode | readData (INTuple *pTuple, PoolDbTupleCallback *call) |
| Callback to extract N-tuple data which needed to be put into BLOBs. | |
| StatusCode | bindWrite (INTuple *pTuple, PoolDbTupleCallback *call) |
| Callback to bind N-tuple data for writing. | |
NTuple converter class definition.
Description: Definition of the generic converter for row wise and column wise Ntuples.
Definition at line 30 of file PoolDbNTupleCnv.h.
| PoolDbNTupleCnv::PoolDbNTupleCnv | ( | long | typ, |
| const CLID & | clid, | ||
| ISvcLocator * | svc | ||
| ) |
Standard constructor.
| clid | [IN] Class ID of the object type to be converted. |
| db | [IN] Pointer to POOL database interface |
| svc | [IN] Pointer to Gaudi service locator |
Definition at line 222 of file PoolDbNTupleCnv.cpp.
: PoolDbStatCnv(typ, clid, svc) { m_class = 0; }
| PoolDbNTupleCnv::~PoolDbNTupleCnv | ( | ) | [virtual] |
| StatusCode PoolDbNTupleCnv::bindRead | ( | INTuple * | pTuple, |
| PoolDbTupleCallback * | call | ||
| ) | [protected] |
Callback to bind N-tuple data for reading.
| pTuple | [IN] Pointer to N-tuple structure |
| call | [IN] Pointer to N-tuple callback structure |
Definition at line 663 of file PoolDbNTupleCnv.cpp.
{
typedef INTuple::ItemContainer Cont;
int cnt = 0;
//pool::DbBlob& s = cb->stream();
std::vector<void*>& addr = cb->addresses();
std::vector<PoolDbTokenWrap*>& links = cb->links();
const std::vector<int>& mapping = cb->mapping();
Cont& items = nt->items();
for (Cont::iterator i = items.begin(); i != items.end(); ++i, ++cnt ) {
int count = mapping[cnt];
if ( count >= 0 ) {
char* buf = (char*)(*i)->buffer();
switch( (*i)->type() ) {
case DataTypeInfo::OBJECT_ADDR:
addr[count] = &links[cnt];
break;
default:
addr[count] = buf;
break;
}
}
}
return S_OK;
}
| StatusCode PoolDbNTupleCnv::bindWrite | ( | INTuple * | pTuple, |
| PoolDbTupleCallback * | call | ||
| ) | [protected] |
Callback to bind N-tuple data for writing.
| pTuple | [IN] Pointer to N-tuple structure |
| call | [IN] Pointer to N-tuple callback structure |
Definition at line 743 of file PoolDbNTupleCnv.cpp.
{
int cnt = 0;
pool::DbBlob& s = cb->stream();
std::vector<void*>& addr = cb->addresses();
std::vector<PoolDbTokenWrap*>& links = cb->links();
const std::vector<int>& mapping = cb->mapping();
const INTuple::ItemContainer& items = nt->items();
INTuple::ItemContainer::const_iterator i;
s.setMode(pool::DbBlob::WRITING);
for(i = items.begin(); i != items.end(); ++i, ++cnt ) {
char* b = (char*)(*i)->buffer();
int len = (*i)->filled();
long ndim = (*i)->ndim();
int count = mapping[cnt];
void* ptr = 0;
switch( (*i)->type() ) {
case DataTypeInfo::UCHAR: ptr=save<unsigned char >(s,b,len,ndim>0); break;
case DataTypeInfo::USHORT: ptr=save<unsigned short>(s,b,len,ndim>0); break;
case DataTypeInfo::UINT: ptr=save<unsigned int >(s,b,len,ndim>0); break;
case DataTypeInfo::ULONG: ptr=save<unsigned long >(s,b,len,ndim>0); break;
case DataTypeInfo::CHAR: ptr=save<char >(s,b,len,ndim>0); break;
case DataTypeInfo::SHORT: ptr=save<short >(s,b,len,ndim>0); break;
case DataTypeInfo::INT: ptr=save<int >(s,b,len,ndim>0); break;
case DataTypeInfo::LONG: ptr=save<long >(s,b,len,ndim>0); break;
case DataTypeInfo::BOOL: ptr=save<bool >(s,b,len,ndim>0); break;
case DataTypeInfo::FLOAT: ptr=save<float >(s,b,len,ndim>0); break;
case DataTypeInfo::DOUBLE: ptr=save<double >(s,b,len,ndim>0); break;
case DataTypeInfo::STRING: ptr=save<std::string >(s,b,len,ndim>0); break;
case DataTypeInfo::NTCHAR: ptr=save<char* >(s,b,len,ndim>0); break;
case DataTypeInfo::POINTER: ptr=*(void**)b; break;
case DataTypeInfo::OBJECT_ADDR: ptr=save(b,links[count]); break;
case DataTypeInfo::UNKNOWN: break;
default: /* Do we have to take some action here ? */ break;
}
if ( count >= 0 ) {
addr[count] = ptr;
}
}
return S_OK;
}
| StatusCode PoolDbNTupleCnv::createObj | ( | IOpaqueAddress * | pAddress, |
| DataObject *& | refpObject | ||
| ) | [virtual] |
Converter overrides: Update the references of an updated transient object.
| pAddress | [IN] Valid pointer to the object's opaque address |
| refpObject | [OUT] Location to store pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 233 of file PoolDbNTupleCnv.cpp.
{
StatusCode status = S_FAIL;
PoolDbAddress* pdbA = dynamic_cast<PoolDbAddress*>(pAddress);
if ( 0 != pdbA ) {
const pool::Token* tok = pdbA->token();
if ( tok ) {
pool::DbContainer cntH(tok->technology());
status = m_dbMgr->connect(tok->dbID(),tok->contID(),cntH);
if ( status.isSuccess() ) {
std::string par_val, par_guid, par_typ;
std::auto_ptr<pool::DbSelect> iter(m_dbMgr->createSelect("*", tok->dbID(), "GaudiStatisticsDescription"));
if ( iter.get() ) {
pool::Token* token;
ROOT::Reflex::Type typ = pool::DbReflex::forTypeName("PoolDbNTupleDescriptor");
pool::DbObjectCallBack* call = new pool::DbObjectCallBack(typ);
while( iter->next(token).isSuccess() ) {
typedef pool::DbObjectHandle<pool::DbObject> ObjH;
pool::DbContainer& cH = iter->container();
if ( ObjH::openEx(cH, *token, call, pool::READ).isSuccess() ) {
PoolDbNTupleDescriptor* ref = (PoolDbNTupleDescriptor*)call->object();
if ( ref->container == tok->contID() ) {
par_val = ref->description;
par_typ = ref->optional;
par_guid = ref->guid;
token->release();
call->release();
call = 0;
delete ref;
break;
}
delete ref;
}
token->release();
}
if ( call ) call->release();
}
if ( !par_val.empty() && !par_guid.empty() && !par_typ.empty() )
{
SmartIF<INTupleSvc> ntupleSvc(dataProvider());
if ( ntupleSvc.isValid() ) {
char c;
CLID clid;
int siz, typ;
std::string title;
NTuple::Tuple* nt = 0;
std::istringstream is(par_val);
std::getline(is, title, ';') >> clid >> c >> siz >> c;
status = ntupleSvc->create(clid, title, nt);
for ( int j = 0; j < siz && status.isSuccess(); j++ ) {
is >> c;
std::getline(is, title, ';') >> typ >> c;
switch ( typ ) {
case DataTypeInfo::UCHAR:
status = createItem(nt, is, title, (unsigned char)0);
break;
case DataTypeInfo::USHORT:
status = createItem(nt, is, title, (unsigned short)0);
break;
case DataTypeInfo::UINT:
status = createItem(nt, is, title, (unsigned int)0);
break;
case DataTypeInfo::ULONG:
status = createItem(nt, is, title, (unsigned long)0);
break;
case DataTypeInfo::CHAR:
status = createItem(nt, is, title, char(0));
break;
case DataTypeInfo::SHORT:
status = createItem(nt, is, title, short(0));
break;
case DataTypeInfo::INT:
status = createItem(nt, is, title, int(0));
break;
case DataTypeInfo::LONG:
status = createItem(nt, is, title, long(0));
break;
case DataTypeInfo::BOOL:
status = createItem(nt, is, title, false);
break;
case DataTypeInfo::FLOAT:
status = createItem(nt, is, title, float(0.0));
break;
case DataTypeInfo::DOUBLE:
status = createItem(nt, is, title, double(0.0));
break;
/*
case DataTypeInfo::NTCHAR:
case DataTypeInfo::LONG_NTCHAR:
status =
createItem(nt, is, title, (char*)0);
break;
case DataTypeInfo::STRING:
case DataTypeInfo::LONG_STRING:
status =
createItem(nt, is, title, std::string(""));
break;
*/
case DataTypeInfo::OBJECT_ADDR:
status = createItem(nt, is, title, (IOpaqueAddress*)0);
break;
case DataTypeInfo::POINTER:
status = createItem(nt, is, title, (void*)0);
break;
case DataTypeInfo::UNKNOWN:
default:
status = S_FAIL;
break;
}
if ( !status.isSuccess() ) {
MsgStream err(msgSvc(),"NTupleCnv");
err << MSG::FATAL
<< "Error connecting (Unknown) column:" << j << endmsg
<< par_val << endmsg;
return makeError("createObj[NTuple]> Cannot determine column!");
}
}
if ( status.isSuccess() ) {
PoolDbTupleCallback* hdlr = new PoolDbTupleCallback(nt);
const pool::DbTypeInfo* typ1 = pool::DbTypeInfo::fromString(par_typ);
hdlr->configure(nt, typ1, cntH);
pdbA->setHandler(hdlr);
refpObject = nt;
}
else {
refpObject = 0;
if ( nt ) nt->release();
}
}
}
}
}
}
return status;
}
| StatusCode PoolDbNTupleCnv::createRep | ( | DataObject * | pObject, |
| IOpaqueAddress *& | refpAddress | ||
| ) | [virtual] |
Converter overrides: Convert the transient object to the requested representation.
Convert the transient object to the requested representation.
| pObject | [IN] Valid pointer to DataObject |
| refpAddress | [OUT] Location to store pointer to the object's opaque address |
Reimplemented from PoolDbBaseCnv.
Definition at line 412 of file PoolDbNTupleCnv.cpp.
{
IRegistry* pRegistry = pObj->registry();
if ( 0 != pRegistry ) {
pAddr = pRegistry->address();
PoolDbAddress* pdbA = dynamic_cast<PoolDbAddress*>(pAddr);
if ( 0 == pdbA ) {
const INTuple* nt = dynamic_cast<const INTuple*>(pObj);
if ( 0 != nt ) {
const INTuple::ItemContainer& items = nt->items();
std::vector<const pool::DbColumn*> cols;
std::vector<int> item_map(items.size()+1,-1);
std::ostringstream os;
int pool_type = 0;
size_t item_no;
os << nt->title()<<';'<<pObj->clID()<<';'<<items.size()<< ';';
for(item_no = 0; item_no < items.size(); ++item_no ) {
pool::DbColumn* col = 0;
INTupleItem* it = items[item_no];
os << '{'
<< it->name() << ';'
<< it->type() << ';'
<< it->length() << ';'
<< it->ndim() << ';'
<< it->hasIndex() << ';';
if ( it->hasIndex() ) {
os << it->index() << ';';
INTupleItem* itm = it->indexItem();
switch( itm->type() ) {
case DataTypeInfo::UCHAR:
putRange(os, dynamic_cast<NTuple::_Data<unsigned char>*>(itm));
break;
case DataTypeInfo::USHORT:
putRange(os, dynamic_cast<NTuple::_Data<unsigned short>*>(itm));
break;
case DataTypeInfo::UINT:
putRange(os, dynamic_cast<NTuple::_Data<unsigned int>*>(itm));
break;
case DataTypeInfo::ULONG:
putRange(os, dynamic_cast<NTuple::_Data<unsigned long>*>(itm));
break;
case DataTypeInfo::CHAR:
putRange(os, dynamic_cast<NTuple::_Data<char>*>(itm));
break;
case DataTypeInfo::SHORT:
putRange(os, dynamic_cast<NTuple::_Data<short>*>(itm));
break;
case DataTypeInfo::INT:
putRange(os, dynamic_cast<NTuple::_Data<int>*>(itm));
break;
case DataTypeInfo::LONG:
putRange(os, dynamic_cast<NTuple::_Data<long>*>(itm));
break;
default: {
MsgStream err(msgSvc(), "NTuple:"+pRegistry->name());
err << MSG::ERROR << "Column " << it->index()
<< " is not a valid index column!" << endmsg;
return S_FAIL;
}
}
}
for ( long k = 0; k < it->ndim(); k++ ) {
os << it->dim(k) << ';';
}
switch(it->type()) {
case DataTypeInfo::STRING:
pool_type = pool::DbColumn::STRING;
os << 0 << ';' << 0 << ';';
break;
case DataTypeInfo::NTCHAR:
pool_type = pool::DbColumn::NTCHAR;
os << 0 << ';' << 0 << ';';
break;
case DataTypeInfo::OBJECT_ADDR:
if ( it->length() == 1 ) {
col = new pool::DbColumn(it->name(),
pool::typeName(typeid(PoolDbTokenWrap)),
pool::DbColumn::POINTER,
0);
item_map[item_no] = cols.size();
cols.push_back(col);
}
os << 0 << ';' << 0 << ';';
break;
case DataTypeInfo::POINTER:
if ( it->length() == 1 ) {
ROOT::Reflex::Type typ = ROOT::Reflex::Type::ByName(it->typeName());
col = new pool::DbColumn(it->name(),
typ.Name(ROOT::Reflex::SCOPED),
pool::DbColumn::POINTER,
0);
item_map[item_no] = cols.size();
cols.push_back(col);
os << 0 << ';' << 0 << ';';
}
break;
case DataTypeInfo::UCHAR:
pool_type = pool::DbColumn::UCHAR;
putRange(os, dynamic_cast<NTuple::_Data<unsigned char>*>(it));
goto MakeCol;
case DataTypeInfo::USHORT:
pool_type = pool::DbColumn::USHORT;
putRange(os, dynamic_cast<NTuple::_Data<unsigned short>*>(it));
goto MakeCol;
case DataTypeInfo::UINT:
pool_type = pool::DbColumn::UINT;
putRange(os, dynamic_cast<NTuple::_Data<unsigned int>*>(it));
goto MakeCol;
case DataTypeInfo::ULONG:
pool_type = pool::DbColumn::ULONG;
putRange(os, dynamic_cast<NTuple::_Data<unsigned long>*>(it));
goto MakeCol;
case DataTypeInfo::CHAR:
pool_type = pool::DbColumn::CHAR;
putRange(os, dynamic_cast<NTuple::_Data<char>*>(it));
goto MakeCol;
case DataTypeInfo::SHORT:
pool_type = pool::DbColumn::SHORT;
putRange(os, dynamic_cast<NTuple::_Data<short>*>(it));
goto MakeCol;
case DataTypeInfo::INT:
pool_type = pool::DbColumn::INT;
putRange(os, dynamic_cast<NTuple::_Data<int>*>(it));
goto MakeCol;
case DataTypeInfo::LONG:
pool_type = pool::DbColumn::LONG;
putRange(os, dynamic_cast<NTuple::_Data<long>*>(it));
goto MakeCol;
case DataTypeInfo::BOOL:
pool_type = pool::DbColumn::BOOL;
putRange(os, dynamic_cast<NTuple::_Data<bool>*>(it));
goto MakeCol;
case DataTypeInfo::FLOAT:
pool_type = pool::DbColumn::FLOAT;
putRange(os, dynamic_cast<NTuple::_Data<float>*>(it));
goto MakeCol;
case DataTypeInfo::DOUBLE:
pool_type = pool::DbColumn::DOUBLE;
putRange(os, dynamic_cast<NTuple::_Data<double>*>(it));
goto MakeCol;
MakeCol:
if ( it->length() == 1 ) {
col = new pool::DbColumn(it->name(),
pool_type,
0,
DataTypeInfo::size(it->type()));
item_map[item_no] = cols.size();
cols.push_back(col);
}
// Everything else CANNOT be identified using SQL
break;
case DataTypeInfo::UNKNOWN:
default:
std::cout << "Create item[FAIL]]: " << it->name()
<< " Typ:" << it->type() << std::endl;
break;
}
os << '}';
}
item_map[item_no] = cols.size();
pool::DbColumn* col =
new pool::DbColumn("BlobData",
pool::DbColumn::BLOB,
0,
DataTypeInfo::size(pool::DbColumn::BLOB));
cols.push_back(col);
pool::Guid guid;
std::string cntName = containerName(pRegistry);
std::string path = fileName(pRegistry);
genMD5(os.str(), &guid);
const pool::DbTypeInfo* typH = pool::DbTypeInfo::createEx(guid, cols);
StatusCode sc = saveDescription(path,
cntName,
os.str(),
typH->toString(),
guid,
pObj->clID(),
"UPDATE");
if ( sc.isSuccess() ) {
// Check if the database container can be connected
pool::DbContainer cntH(POOL_StorageType);
sc = m_dbMgr->connectContainer(IPoolDbMgr::UNKNOWN,
path,
cntName,
pool::RECREATE|pool::UPDATE,
typH,
cntH);
if ( sc.isSuccess() ) {
PoolDbTupleCallback* hdlr = new PoolDbTupleCallback(pObj);
pool::Token* tok = new pool::Token(cntH.token());
PoolDbAddress* add = new PoolDbAddress(tok);
hdlr->configure(nt, typH, cntH);
tok->oid().second = 0;
tok->release();
pAddr = add;
add->setHandler(hdlr);
return m_dbMgr->commitOutput(path, true);
}
return S_FAIL;
}
return sc;
}
}
else {
return S_OK;
}
}
return S_FAIL;
}
| virtual StatusCode PoolDbNTupleCnv::fillObjRefs | ( | IOpaqueAddress * | , |
| DataObject * | |||
| ) | [inline, virtual] |
Converter overrides: Update the references of an updated transient object.
| pAddress | [IN] Valid pointer to the object's opaque address |
| pObject | [IN] Valid pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 117 of file PoolDbNTupleCnv.h.
{ return StatusCode::SUCCESS; }
| StatusCode PoolDbNTupleCnv::fillRepRefs | ( | IOpaqueAddress * | pAddress, |
| DataObject * | pObject | ||
| ) | [virtual] |
Resolve the references of the converted object.
| pAddress | [IN] Valid pointer to the object's opaque address |
| pObject | [IN] Valid pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 623 of file PoolDbNTupleCnv.cpp.
{
INTuple* pTuple = dynamic_cast<INTuple*>(pObj);
if ( pTuple ) {
IRegistry* pRegistry = pObj->registry();
if ( 0 != pRegistry ) {
pAddr = pRegistry->address();
PoolDbAddress* pdbA = dynamic_cast<PoolDbAddress*>(pAddr);
if ( 0 != pdbA ) {
PoolDbTupleCallback* cb = dynamic_cast<PoolDbTupleCallback*>(pdbA->handler());
if ( cb ) {
const pool::DbTypeInfo* typH = dynamic_cast<const pool::DbTypeInfo*>(cb->shape());
if ( typH ) {
if ( bindWrite(pTuple, cb).isSuccess() ) {
std::string path = fileName(pRegistry);
std::string cntName = containerName(pRegistry);
if ( !m_dbMgr->connectOutput(path, "UPDATE").isSuccess() ) {
MsgStream log(msgSvc(), "PoolDbNTupleCnv");
log << MSG::ERROR << "Error: connectOutput(path, UPDATE)" << endmsg;
return S_FAIL;
}
if ( m_dbMgr->markWrite(cb->clone(), cntName, &pdbA).isSuccess() ) {
if ( m_dbMgr->commitOutput(path, true).isSuccess() ) {
typedef INTuple::ItemContainer Cont;
Cont& it = pTuple->items();
for(Cont::iterator i = it.begin(); i != it.end(); ++i) {
(*i)->reset();
}
return S_OK;
}
}
}
}
}
}
}
}
return S_FAIL;
}
| StatusCode PoolDbNTupleCnv::readData | ( | INTuple * | pTuple, |
| PoolDbTupleCallback * | call | ||
| ) | [protected] |
Callback to extract N-tuple data which needed to be put into BLOBs.
| pTuple | [IN] Pointer to N-tuple structure |
| call | [IN] Pointer to N-tuple callback structure |
Definition at line 690 of file PoolDbNTupleCnv.cpp.
{
typedef INTuple::ItemContainer Cont;
int cnt = 0;
pool::DbBlob& s = cb->stream();
std::vector<PoolDbTokenWrap*>& links = cb->links();
const std::vector<int>& mapping = cb->mapping();
INTuple::ItemContainer& items = nt->items();
for (Cont::iterator i = items.begin(); i != items.end(); ++i, ++cnt ) {
int count = mapping[cnt];
int typ = (*i)->type();
if(count < 0 || typ == DataTypeInfo::OBJECT_ADDR || typ == DataTypeInfo::POINTER) {
char* buf = (char*)(*i)->buffer();
int sc = 11;
switch( (*i)->type() ) {
case DataTypeInfo::UCHAR: sc=load<unsigned char> (s,buf); break;
case DataTypeInfo::USHORT: sc=load<unsigned short>(s,buf); break;
case DataTypeInfo::UINT: sc=load<unsigned int> (s,buf); break;
case DataTypeInfo::ULONG: sc=load<unsigned long> (s,buf); break;
case DataTypeInfo::CHAR: sc=load<char> (s,buf); break;
case DataTypeInfo::SHORT: sc=load<short> (s,buf); break;
case DataTypeInfo::INT: sc=load<int> (s,buf); break;
case DataTypeInfo::LONG: sc=load<long> (s,buf); break;
case DataTypeInfo::BOOL: sc=load<bool> (s,buf); break;
case DataTypeInfo::FLOAT: sc=load<float> (s,buf); break;
case DataTypeInfo::DOUBLE: sc=load<double> (s,buf); break;
case DataTypeInfo::STRING: sc=load<std::string> (s,buf); break;
case DataTypeInfo::NTCHAR: sc=load<char*> (s,buf); break;
case DataTypeInfo::OBJECT_ADDR: sc=load(buf,links[cnt]); break;
case DataTypeInfo::POINTER: sc = 0; break;
case DataTypeInfo::UNKNOWN: break;
default: break;
}
if ( 0 != sc ) {
MsgStream log(msgSvc(), "PoolDbNTupleCnv");
log << MSG::DEBUG;
switch (sc) {
case 10:
log << "CANNOT Set Ntuple token: dynamic_cast<GenericAddress*> is NULL";
break;
case 11:
log << "CANNOT Set Ntuple token: invalid address buffer";
break;
}
log << endmsg;
}
}
}
return S_OK;
}
| StatusCode PoolDbNTupleCnv::updateObj | ( | IOpaqueAddress * | pAddress, |
| DataObject * | pObject | ||
| ) | [virtual] |
Update the transient object: NTuples end here when reading records.
| pAddress | [IN] Valid pointer to the object's opaque address |
| pObject | [IN] Valid pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 371 of file PoolDbNTupleCnv.cpp.
{
INTuple* tupl = dynamic_cast<INTuple*>(pObj);
PoolDbAddress* pdbA = dynamic_cast<PoolDbAddress*>(pAddr);
if ( 0 != tupl && 0 != pdbA ) {
PoolDbTupleCallback* hdlr = dynamic_cast<PoolDbTupleCallback*>(pdbA->handler());
if ( 0 != hdlr ) {
pool::DbSelect* it = hdlr->iterator();
if ( 0 == it ) {
it = hdlr->select(tupl->selector());
}
if ( it ) {
pool::Token* t = 0;
if ( hdlr->iterator()->next(t).isSuccess() ) {
std::auto_ptr<pool::Token> next(t);
// Now reload!
if ( bindRead(tupl, hdlr).isSuccess() ) {
// No support for SmartRefs<T> for N-tuples
//pushCurrentDataObject((DataObject**)&pObj);
if ( m_dbMgr->read(hdlr, *next.get()).isSuccess() ) {
if ( readData(tupl, hdlr).isSuccess() ) {
//popCurrentDataObject();
return S_OK;
}
//popCurrentDataObject();
return makeError("updateObj> Cannot interprete data.");
}
//popCurrentDataObject();
return makeError("updateObj> Cannot read data.");
}
return makeError("updateObj> Cannot bind data.");
}
}
return S_FAIL;
}
return makeError("updateObj> Token selection failed!");
}
return makeError("updateObj> Invalid Tuple reference.");
}
| virtual StatusCode PoolDbNTupleCnv::updateObjRefs | ( | IOpaqueAddress * | , |
| DataObject * | |||
| ) | [inline, virtual] |
Converter overrides: Update the references of an updated transient object.
| pAddress | [IN] Valid pointer to the object's opaque address |
| pObject | [IN] Valid pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 139 of file PoolDbNTupleCnv.h.
{ return StatusCode::SUCCESS; }
| virtual StatusCode PoolDbNTupleCnv::updateRep | ( | IOpaqueAddress * | , |
| DataObject * | |||
| ) | [inline, virtual] |
Converter overrides: Update the converted representation of a transient object.
| pAddress | [IN] Valid pointer to the object's opaque address |
| pObject | [IN] Valid pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 151 of file PoolDbNTupleCnv.h.
{ return StatusCode::SUCCESS; }
| virtual StatusCode PoolDbNTupleCnv::updateRepRefs | ( | IOpaqueAddress * | , |
| DataObject * | |||
| ) | [inline, virtual] |
Converter overrides: Update the converted representation of a transient object.
| pAddress | [IN] Valid pointer to the object's opaque address |
| pObject | [IN] Valid pointer to DataObject |
Reimplemented from PoolDbBaseCnv.
Definition at line 163 of file PoolDbNTupleCnv.h.
{ return StatusCode::SUCCESS; }