HbookCnv::HCWNTupleCnv Class Reference

#include <HCWNTupleCnv.h>

Inheritance diagram for HbookCnv::HCWNTupleCnv:

[legend]

Collaboration diagram for HbookCnv::HCWNTupleCnv:

[legend]

List of all members.

Detailed Description

NTuple converter class definition.

Description: Definition of the converter for Ntuples using HBOOK

Dependencies:

Base class: Gaudi/Kernel/Converter.h

History :

      +---------+----------------------------------------------+--------+
      |    Date |                 Comment                      | Who    |
      +---------+----------------------------------------------+--------+
      | 21/10/99| Initial version.                             | MF     |
      +---------+----------------------------------------------+--------+

Author: M.Frank Version: 1.0

Definition at line 48 of file HCWNTupleCnv.h.


Public Member Functions
	HCWNTupleCnv (ISvcLocator *svc)
	Standard constructor.
virtual	~HCWNTupleCnv ()
	Standard destructor.
Static Public Member Functions
static const CLID &	classID ()
	Inquire class type.
Protected Member Functions
virtual StatusCode	load (long id, INTuple *&refpObject)
	Create the transient representation of an object.
virtual StatusCode	book (long idh, const std::string &location, INTuple *pObject)
	Book the N tuple.
virtual StatusCode	declare (long idh, INTuple *pObject)
	Declare the N tuple.
virtual StatusCode	writeData (long idh, INTuple *pObject)
	Write N tuple data.
virtual StatusCode	readData (long idh, INTuple *pObject, long ievt)
	Read N tuple data.
template<class T>
size_t	saveItem (char target, const T src, size_t len)
template<class T>
size_t	loadItem (char src, T tar, size_t len)
size_t	loadItem (char src, bool tar, size_t len)
size_t	loadItem (char src, float target, size_t len)
size_t	loadItem (char src, double target, size_t len)
size_t	loadItem (char src, long target, size_t len)
size_t	loadItem (char src, unsigned long target, size_t len)
size_t	saveItem (char target, float src, size_t len)
size_t	saveItem (char target, double src, size_t len)
size_t	saveItem (char target, long src, size_t len)
size_t	saveItem (char target, unsigned long src, size_t len)
Friends
class	CnvFactory< HCWNTupleCnv >
	Creator needs access to constructor/destructor.

Constructor & Destructor Documentation

HbookCnv::HCWNTupleCnv::HCWNTupleCnv ( ISvcLocator * svc ) [inline]

Standard constructor.

Definition at line 59 of file HCWNTupleCnv.h.

00059                                      : HNTupleCnv(svc, classID())    {
00060     }

virtual HbookCnv::HCWNTupleCnv::~HCWNTupleCnv ( ) [inline, virtual]

Standard destructor.

Definition at line 62 of file HCWNTupleCnv.h.

00062                               {
00063     }

Member Function Documentation

static const CLID& HbookCnv::HCWNTupleCnv::classID ( ) [inline, static]

Inquire class type.

Definition at line 55 of file HCWNTupleCnv.h.

00055                                     {
00056       return CLID_ColumnWiseTuple;
00057     }

StatusCode HbookCnv::HCWNTupleCnv::load	(	long	id,
		INTuple *&	refpObject
	)			`[protected, virtual]`

Create the transient representation of an object.

Implements HbookCnv::HNTupleCnv.

Definition at line 343 of file HCWNTupleCnv.cpp.

00343                                                                       {
00344 
00345   MsgStream log(msgSvc(), "HCWNTupleCnv");
00346 
00347   NTUPLEINFO tags;
00348 
00349   memset(&tags,0,sizeof(tags));
00350 
00351   std::vector<std::string> blkname;
00352   std::vector<unsigned long> bufpos;
00353   unsigned long totsize = 0;
00354 
00355   tags.id = idh;
00356   StatusCode status = ::CWNT_INFO(tags);
00357 
00358   if ( status.isSuccess() )     {
00359     NTuple::Tuple* pObj = 0;
00360     status = m_ntupleSvc->create(CLID_ColumnWiseTuple, tags.title, pObj);
00361     INTuple* ntup = dynamic_cast<INTuple*>(pObj);
00362     try {
00363       if ( status.isSuccess() && 0 != ntup )   {
00364         long total_size = 0;
00365         for ( long size = 0, i = 0; i < tags.numVar; i++, size=0 )   {
00366           INTupleItem* item = 0;
00367           switch( tags.type[i] )    {
00368           case 'L':
00369             item = createNTupleItem(tags, i, ntup, NTuple::Range<bool>::min(), NTuple::Range<bool>::max(), size);
00370           break;
00371           case 'I':
00372             // if ( tags.size[i] <= sizeof(unsigned char)*CHAR_BIT )
00373             //   item = createNTupleItem(tags, i, ntup, NTuple::Range<char>::min(), NTuple::Range<char>::max(), size);
00374             // else if ( tags.size[i] <= sizeof(unsigned short)*CHAR_BIT )
00375             //   item = createNTupleItem(tags, i, ntup, NTuple::Range<short>::min(), NTuple::Range<short>::max(), size);
00376             // else if ( tags.size[i] <= sizeof(unsigned int)*CHAR_BIT )
00377             //   item = createNTupleItem(tags, i, ntup, NTuple::Range<int>::min(), NTuple::Range<int>::max(), size);
00378             // else
00379             item = createNTupleItem(tags, i, ntup, NTuple::Range<long>::min(), NTuple::Range<long>::max(), size);
00380             break;
00381           case 'U':
00382             // if ( tags.size[i] <= sizeof(unsigned char)*CHAR_BIT )
00383             //   item = createNTupleItem(tags, i, ntup, NTuple::Range<unsigned char>::min(), NTuple::Range<unsigned char>::max(), size);
00384             // else if ( tags.size[i] <= sizeof(unsigned short)*CHAR_BIT )
00385             //   item = createNTupleItem(tags, i, ntup, NTuple::Range<unsigned short>::min(), NTuple::Range<unsigned short>::max(), size);
00386             // else if ( tags.size[i] <= sizeof(unsigned int)*CHAR_BIT )
00387             //   item = createNTupleItem(tags, i, ntup, NTuple::Range<unsigned int>::min(), NTuple::Range<unsigned int>::max(), size);
00388             // else
00389             item = createNTupleItem(tags, i, ntup, NTuple::Range<unsigned long>::min(), NTuple::Range<unsigned long>::max(), size);
00390             break;
00391           case 'R':
00392             if ( (size_t)tags.size[i] <= sizeof(float)*CHAR_BIT )
00393               item = createNTupleItem(tags, i, ntup, NTuple::Range<float>::min(), NTuple::Range<float>::max(), size);
00394             else
00395               item = createNTupleItem(tags, i, ntup, NTuple::Range<double>::min(), NTuple::Range<double>::max(), size);
00396             break;
00397           default:
00398             break;
00399     }
00400     if ( item ) {
00401       long ii;
00402       ntup->add(item);
00403       total_size += size;
00404       log << MSG::DEBUG << "Create Var[" << i << "]: "
00405           << item->typeName() << "[";
00406       for ( ii = 0; ii < item->ndim()-1; ii++ )    {
00407         log << item->dim(ii) << ", ";
00408       }
00409       if ( item->hasIndex() ) log << item->index() << "]";
00410       else                    log << item->dim(item->ndim()) << "]";
00411     } else {
00412       log << MSG::FATAL << "Cannot deduce type for Var[" << i << "]: ";
00413     }
00414 
00415 
00416     // add sizes up
00417     blkname.push_back(tags.block[i]);
00418     bufpos.push_back(totsize);
00419     totsize += size;
00420 
00421 
00422     log << " Name:"  << tags.name[i]
00423         << " Block: " << tags.block[i]
00424         << " Index:<" << tags.index[i] <<">"
00425         << " Dim:"   << tags.dim[i]
00426         << " Typ:"   << tags.type[i]
00427         << " Size:"  << tags.size[i]
00428         << " [";
00429     if ( tags.type[i] == 'I' || tags.type[i] == 'U' || tags.type[i] == 'L' )
00430       log << tags.irange[i][0] << "," << tags.irange[i][1];
00431     else if ( tags.type[i] == 'R' )
00432       log << tags.frange[i][0] << "," << tags.frange[i][1];
00433     log << "]" << endreq;
00434   }
00435   log << MSG::DEBUG << "Total buffer size of NTuple: " << total_size << " Bytes." << endreq;
00436 
00437   ntup->setBuffer(new char[total_size]);
00438   long ievt = 0;
00439 
00440   ::HBNAME(idh," ", &ievt, "$CLEAR");
00441 
00442   log << MSG::DEBUG << "Loading block " << blkname[0] << " at offset "
00443       << bufpos[0] << endreq;
00444 
00445   ::HBNAME(idh,blkname[0].c_str(),ntup->buffer(),"$SET");
00446 
00447   std::string oldblock = blkname[0];
00448   for (unsigned int ib=1; ib<bufpos.size(); ++ib) {
00449     if (blkname[ib] != oldblock) {
00450       log << MSG::DEBUG << "Loading block " << blkname[ib] << " at offset "
00451           << bufpos[ib] << endreq;
00452       ::HBNAME(idh,blkname[ib].c_str(),(ntup->buffer())+bufpos[ib],"$SET");
00453       oldblock = blkname[ib];
00454     }
00455   }
00456 
00457   refpObject = ntup;
00458   return StatusCode::SUCCESS;
00459       }
00460     }
00461     catch (...) {
00462     }
00463   }
00464   log << MSG::ERROR << "Error loading N tuple ID:" << idh << endreq;
00465   return StatusCode::FAILURE;
00466 }

StatusCode HbookCnv::HCWNTupleCnv::book	(	long	idh,
		const std::string &	location,
		INTuple *	pObject
	)			`[protected, virtual]`

Book the N tuple.

Implements HbookCnv::HNTupleCnv.

Definition at line 199 of file HCWNTupleCnv.cpp.

00199                                                                                   {
00200   MsgStream log(msgSvc(), "HCWNTupleCnv");
00201   //  log << MSG::DEBUG << "in HCWNTupleCnv::book" << endreq;
00202   if ( !::HEXIST( idh ) )   {
00203     NTUPLEINFO tags;
00204     memset(&tags,0, sizeof(tags));
00205     tags.id = idh;
00206     strncpy(tags.rzdir, loc.data()+2, loc.length()-2);
00207     strncpy(tags.title, nt->title().data(), nt->title().length());
00208     StatusCode status = ::CWNT_BOOK(tags);
00209     if ( status.isSuccess() )   {
00210       status = declare(idh, nt);
00211       if ( status.isSuccess() )  {
00212         log << MSG::INFO << "Booked Column wise HBOOK N tuple with ID:" << idh
00213             << " \"" << nt->title()
00214             << "\" in directory <" << loc << ">" << endreq;
00215         log << MSG::DEBUG;
00216         if ( log.isActive() ) ::HPRINT (idh);
00217         return StatusCode::SUCCESS;
00218       }
00219     }
00220     log << MSG::ERROR << "Column wise HBOOK N tuple " << idh
00221         << "\"" << nt->title()
00222         << "\" cannot be booked"
00223         << " in directory <" << loc << ">" << endreq;
00224     return status;
00225   }
00226   log << MSG::ERROR << "Column wise HBOOK N tuple " << idh << "\"" << nt->title()
00227       << "\" already exists in directory <" << loc << ">" << endreq;
00228   return StatusCode::FAILURE;
00229 }

StatusCode HbookCnv::HCWNTupleCnv::declare	(	long	idh,
		INTuple *	pObject
	)			`[protected, virtual]`

Declare the N tuple.

Book the N tuple.

Loop over items, add them to ntuple blocks

Definition at line 92 of file HCWNTupleCnv.cpp.

00092                                                                {
00093   MsgStream log(msgSvc(), "HCWNTupleCnv");
00094 
00095   const INTuple::ItemContainer& cols = nt->items();
00096   //  char text[64];
00097   std::string desc = "";
00098   std::string block_name,var_name;
00099   long size = 0;
00100   size_t cnt =0;
00101 
00102   long cursize, oldsize = 0;
00103   std::vector<long> item_size;
00104   std::vector<std::pair<std::string,std::string> > item_name;
00105 
00106   try   {
00107     for (INTuple::ItemContainer::const_iterator i = cols.begin(); i != cols.end(); i++ )   {
00108       std::string item = "";
00109       switch( (*i)->type() )   {
00110       case DataTypeInfo::BOOL:              // bool
00111         analyzeItem('L', dynamic_cast<const NTuple::_Data<bool>*>(*i),item,
00112                     block_name,size);
00113         break;
00114       case DataTypeInfo::CHAR:              // char
00115         analyzeItem('I', dynamic_cast<const NTuple::_Data<char>*>(*i),item,
00116                     block_name,size);
00117         break;
00118       case DataTypeInfo::INT:               // int
00119         analyzeItem('I', dynamic_cast<const NTuple::_Data<int>*>(*i),item,
00120                     block_name,size);
00121         break;
00122       case DataTypeInfo::SHORT:             // short
00123         analyzeItem('I', dynamic_cast<const NTuple::_Data<short>*>(*i),item,
00124                     block_name,size);
00125         break;
00126       case DataTypeInfo::LONG:              // long
00127         analyzeItem('I', dynamic_cast<const NTuple::_Data<long>*>(*i),item,
00128                     block_name,size);
00129         break;
00130       case DataTypeInfo::UCHAR:             // unsigned char
00131         analyzeItem('U', dynamic_cast<const NTuple::_Data<unsigned char>*>(*i),
00132                     item,block_name,size);
00133         break;
00134       case DataTypeInfo::USHORT:            // unsigned short
00135         analyzeItem('U', dynamic_cast<const NTuple::_Data<unsigned short>*>(*i),
00136                     item,block_name,size);
00137         break;
00138       case DataTypeInfo::UINT:              // unsigned int
00139         analyzeItem('U', dynamic_cast<const NTuple::_Data<unsigned int>*>(*i),
00140                     item,block_name,size);
00141         break;
00142       case DataTypeInfo::ULONG:             // unsigned long
00143         analyzeItem('U', dynamic_cast<const NTuple::_Data<unsigned long>*>(*i),
00144                     item,block_name,size);
00145         break;
00146       case DataTypeInfo::DOUBLE:            // double
00147         analyzeItem('R', dynamic_cast<const NTuple::_Data<double>*>(*i),item,
00148                     block_name,size);
00149         break;
00150       case DataTypeInfo::FLOAT:             // float
00151         analyzeItem('R', dynamic_cast<const NTuple::_Data<float>*>(*i),item,
00152                     block_name,size);
00153       default:
00154         break;
00155       }
00156       desc += item;
00157       if ( ++cnt < cols.size() )   {
00158         desc += ", ";
00159       }
00160 
00161       item_name.push_back(std::make_pair(block_name,item));
00162       cursize = size - oldsize;
00163       item_size.push_back(size-cursize);
00164       oldsize = size;
00165     }
00166     char* buff = new char[size];
00167     nt->setBuffer(buff);
00168 
00169     //    const unsigned int MAX_BLOCK_NAME = 1300;
00170     std::string block_desc = "";
00171     char *buf_pos = buff;
00172 
00173     std::vector<std::pair<std::string,std::string> >::const_iterator itr,end;
00174     end = item_name.end();
00175     int pos = 0;
00176 
00178 
00179     for (itr=item_name.begin(); itr!=end; ++itr) {
00180       buf_pos = buff + item_size[pos++];
00181       block_desc = itr->second;
00182 
00183       ::HBNAME(idh, itr->first.c_str(), buf_pos, block_desc.c_str());
00184 
00185       log << MSG::DEBUG << "CWNT " << idh << ": added "
00186           << itr->first << " : " << block_desc << endreq;
00187 
00188     }
00189 
00190     return StatusCode::SUCCESS;
00191   }
00192   catch (...)   {
00193   }
00194   return StatusCode::FAILURE;
00195 }

StatusCode HbookCnv::HCWNTupleCnv::writeData	(	long	idh,
		INTuple *	pObject
	)			`[protected, virtual]`

Write N tuple data.

Implements HbookCnv::HNTupleCnv.

Definition at line 233 of file HCWNTupleCnv.cpp.

00233                                                                   {
00234   const INTuple::ItemContainer& cols = nt->items();
00235   MsgStream log(msgSvc(), "HCWNTupleCnv");
00236   //  log << MSG::DEBUG << "in HCWNTupleCnv::writeData" << endreq;
00237   char * tar = nt->buffer();
00238   for (INTuple::ItemContainer::const_iterator i = cols.begin(); i != cols.end(); i++ )   {
00239     switch( (*i)->type() )   {
00240     case DataTypeInfo::BOOL:              // bool
00241       tar += saveItem(tar, (bool*)(*i)->buffer(),   (*i)->length());
00242       break;
00243     case DataTypeInfo::CHAR:              // char
00244       tar += saveItem(tar, (char*)(*i)->buffer(),   (*i)->length());
00245       break;
00246     case DataTypeInfo::SHORT:             // short
00247       tar += saveItem(tar, (short*)(*i)->buffer(),  (*i)->length());
00248       break;
00249     case DataTypeInfo::INT:             // short
00250       tar += saveItem(tar, (int*)(*i)->buffer(),    (*i)->length());
00251       break;
00252     case DataTypeInfo::LONG:             // short
00253       tar += saveItem(tar, (long*)(*i)->buffer(),   (*i)->length());
00254       break;
00255     case DataTypeInfo::UCHAR:             // unsigned char
00256       tar += saveItem(tar, (unsigned char*)(*i)->buffer(),  (*i)->length());
00257       break;
00258     case DataTypeInfo::USHORT:            // unsigned short
00259       tar += saveItem(tar, (unsigned short*)(*i)->buffer(), (*i)->length());
00260       break;
00261     case DataTypeInfo::UINT:            // unsigned short
00262       tar += saveItem(tar, (unsigned int*)(*i)->buffer(),   (*i)->length());
00263       break;
00264     case DataTypeInfo::ULONG:            // unsigned short
00265       tar += saveItem(tar, (unsigned long*)(*i)->buffer(),  (*i)->length());
00266       break;
00267     case DataTypeInfo::FLOAT:            // unsigned short
00268       tar += saveItem(tar, (float*)(*i)->buffer(), (*i)->length());
00269       break;
00270     case DataTypeInfo::DOUBLE:            // unsigned short
00271       tar += saveItem(tar, (double*)(*i)->buffer(), (*i)->length());
00272       break;
00273     default:
00274       break;
00275     }
00276   }
00277   ::HFNT ( idh );
00278   nt->reset();
00279   return StatusCode::SUCCESS;
00280 }

StatusCode HbookCnv::HCWNTupleCnv::readData	(	long	idh,
		INTuple *	pObject,
		long	ievt
	)			`[protected, virtual]`

Read N tuple data.

Implements HbookCnv::HNTupleCnv.

Definition at line 284 of file HCWNTupleCnv.cpp.

00284                                                                                {
00285   MsgStream log(msgSvc(), "HCWNTupleCnv");
00286 
00287   long istat = 0;
00288   ievt++;
00289   ::HGNT(idh, ievt, istat);
00290   if ( istat == 0 )   {
00291     INTuple::ItemContainer& cols = ntup->items();
00292     char * src = ntup->buffer();
00293     for (INTuple::ItemContainer::iterator i = cols.begin(); i != cols.end(); i++ )   {
00294       switch( (*i)->type() )   {
00295       case DataTypeInfo::BOOL:              // bool
00296         src += loadItem(src, (bool*)(*i)->buffer(), (*i)->length());
00297         break;
00298       case DataTypeInfo::CHAR:              // char
00299         src += loadItem(src, (char*)(*i)->buffer(), (*i)->length());
00300         break;
00301       case DataTypeInfo::SHORT:             // short
00302         src += loadItem(src, (short*)(*i)->buffer(), (*i)->length());
00303         break;
00304       case DataTypeInfo::INT:             // short
00305         src += loadItem(src, (int*)(*i)->buffer(), (*i)->length());
00306         break;
00307       case DataTypeInfo::LONG:             // short
00308         src += loadItem(src, (long*)(*i)->buffer(), (*i)->length());
00309         break;
00310       case DataTypeInfo::UCHAR:             // unsigned char
00311         src += loadItem(src, (unsigned char*)(*i)->buffer(), (*i)->length());
00312         break;
00313       case DataTypeInfo::USHORT:            // unsigned short
00314         src += loadItem(src, (unsigned short*)(*i)->buffer(), (*i)->length());
00315         break;
00316       case DataTypeInfo::UINT:            // unsigned short
00317         src += loadItem(src, (unsigned int*)(*i)->buffer(), (*i)->length());
00318         break;
00319       case DataTypeInfo::ULONG:            // unsigned short
00320         src += loadItem(src, (unsigned long*)(*i)->buffer(), (*i)->length());
00321         break;
00322       case DataTypeInfo::FLOAT:            // unsigned short
00323         src += loadItem(src, (float*)(*i)->buffer(), (*i)->length());
00324         break;
00325       case DataTypeInfo::DOUBLE:            // unsigned short
00326         src += loadItem(src, (double*)(*i)->buffer(), (*i)->length());
00327         break;
00328       default:
00329         break;
00330       }
00331     }
00332     return StatusCode::SUCCESS;
00333   }
00334 
00335   log << MSG::ERROR << "Error reading data from N tuple ID:" << idh
00336       << " " << ntup->title()
00337       << endreq;
00338   return StatusCode::FAILURE;
00339 }

template<class T>

size_t HbookCnv::HCWNTupleCnv::saveItem	(	char *	target,
		const T *	src,
		size_t	len
	)			`[inline, protected]`

Definition at line 76 of file HCWNTupleCnv.h.

00076                                                               {
00077       long* tar = (long*)target;
00078       for ( size_t i = 0; i < len; i++ )   {
00079         *(tar++) = long( *(src++));
00080       }
00081       return sizeof(long)*len;
00082     }

template<class T>

size_t HbookCnv::HCWNTupleCnv::loadItem	(	char *	src,
		T *	tar,
		size_t	len
	)			`[inline, protected]`

Definition at line 84 of file HCWNTupleCnv.h.

00084                                                      {
00085       long* s = (long*)src;
00086       for ( size_t i = 0; i < len; i++ )   {
00087         *(tar++) = T( *(s++));
00088       }
00089       return sizeof(long)*len;
00090     }

size_t HbookCnv::HCWNTupleCnv::loadItem	(	char *	src,
		bool *	tar,
		size_t	len
	)			`[inline, protected]`

Definition at line 91 of file HCWNTupleCnv.h.

00091                                                         {
00092       long* s = (long*)src;
00093       for ( size_t i = 0; i < len; i++ )   {
00094         *(tar++) = (*(s++)) ? true : false;
00095       }
00096       return sizeof(long)*len;
00097     }

size_t HbookCnv::HCWNTupleCnv::loadItem	(	char *	src,
		float *	target,
		size_t	len
	)			`[inline, protected]`

Definition at line 98 of file HCWNTupleCnv.h.

00098                                                             {
00099       memcpy(target, src, sizeof(float)*len);
00100       return sizeof(float)*len;
00101     }

size_t HbookCnv::HCWNTupleCnv::loadItem	(	char *	src,
		double *	target,
		size_t	len
	)			`[inline, protected]`

Definition at line 102 of file HCWNTupleCnv.h.

00102                                                              {
00103       memcpy(target, src, sizeof(double)*len);
00104       return sizeof(double)*len;
00105     }

size_t HbookCnv::HCWNTupleCnv::loadItem	(	char *	src,
		long *	target,
		size_t	len
	)			`[inline, protected]`

Definition at line 106 of file HCWNTupleCnv.h.

00106                                                            {
00107       memcpy(target, src, sizeof(long)*len);
00108       return sizeof(long)*len;
00109     }

size_t HbookCnv::HCWNTupleCnv::loadItem	(	char *	src,
		unsigned long *	target,
		size_t	len
	)			`[inline, protected]`

Definition at line 110 of file HCWNTupleCnv.h.

00110                                                                     {
00111       memcpy(target, src, sizeof(unsigned long)*len);
00112       return sizeof(unsigned long)*len;
00113     }

size_t HbookCnv::HCWNTupleCnv::saveItem	(	char *	target,
		float *	src,
		size_t	len
	)			`[inline, protected]`

Definition at line 115 of file HCWNTupleCnv.h.

00115                                                             {
00116       memcpy(target, src, sizeof(float)*len);
00117       return sizeof(float)*len;
00118     }

size_t HbookCnv::HCWNTupleCnv::saveItem	(	char *	target,
		double *	src,
		size_t	len
	)			`[inline, protected]`

Definition at line 119 of file HCWNTupleCnv.h.

00119                                                              {
00120       memcpy(target, src, sizeof(double)*len);
00121       return sizeof(double)*len;
00122     }

size_t HbookCnv::HCWNTupleCnv::saveItem	(	char *	target,
		long *	src,
		size_t	len
	)			`[inline, protected]`

Definition at line 123 of file HCWNTupleCnv.h.

00123                                                            {
00124       memcpy(target, src, sizeof(long)*len);
00125       return sizeof(long)*len;
00126     }

size_t HbookCnv::HCWNTupleCnv::saveItem	(	char *	target,
		unsigned long *	src,
		size_t	len
	)			`[inline, protected]`

Definition at line 127 of file HCWNTupleCnv.h.

00127                                                                     {
00128       memcpy(target, src, sizeof(unsigned long)*len);
00129       return sizeof(unsigned long)*len;
00130     }

Friends And Related Function Documentation

friend class CnvFactory< HCWNTupleCnv > [friend]

Creator needs access to constructor/destructor.

Definition at line 51 of file HCWNTupleCnv.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/HbookCnv/src/HCWNTupleCnv.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/HbookCnv/src/HCWNTupleCnv.cpp

	Gaudi Framework, version v20r4
	Generated: 8 Jan 2009

Gaudi Framework, version v20r4

HbookCnv::HCWNTupleCnv Class Reference

Detailed Description

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation