| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

NTuple::RowWiseTuple

NTuple::RowWiseTuple Class Reference

#include <NTupleImplementation.h>

Inheritance diagram for NTuple::RowWiseTuple:

[legend]
Collaboration diagram for NTuple::RowWiseTuple:
[legend]
List of all members.

inline code of class DataObject

void setRegistry (IRegistry *pRegistry)
 Set pointer to Registry.
IRegistry * registry () const
 Get pointer to Registry.
LinkManager * linkMgr () const
 Retrieve Link manager.
unsigned char version () const
 Retrieve version number of this object representation.
void setVersion (unsigned char vsn)
 Set version number of this object representation.
unsigned long refCount () const
 Return the refcount.
virtual std::ostream & fillStream (std::ostream &s) const
 Fill the output stream (ASCII).
std::ostream & operator<< (std::ostream &s, const DataObject &obj)
 Output operator (ASCII).

Public Types

typedef std::vector< INTupleItem * > ItemContainer

Public Member Functions

 RowWiseTuple (const std::string &title)
 Standard Constructor.
virtual ~RowWiseTuple ()
 Standard Destructor.
virtual const CLID & clID () const
 Retrieve Reference to class defininition structure.
virtual INTupleItem * i_find (const std::string &name) const
 Internally used by abstract classes.
ItemContainer & items ()
 Access item container.
const ItemContainer & items () const
 Access item container (CONST).
virtual const std::string & title () const
 Object title.
virtual const INTupleItem * find (const std::string &name) const
 Find an item row of the Ntuple (CONST).
virtual INTupleItem * find (const std::string &name)
 Find an item row of the Ntuple.
char * buffer ()
 Access N tuple data buffer.
const char * buffer () const
 Access N tuple data buffer (CONST).
IConversionSvc * conversionService () const
 Access conversion service.
void setConversionService (IConversionSvc *svc)
 Access conversion service.
INTupleSvc * tupleService () const
 Access conversion service.
void setTupleService (INTupleSvc *svc)
 Access conversion service.
virtual StatusCode attachSelector (ISelectStatement *sel)
 Attach selector.
virtual ISelectStatement * selector ()
 Access selector.
virtual void setBuffer (char *buff)
 Set N tuple data buffer.
virtual void reset ()
 Reset all entries to their default values.
virtual StatusCode add (INTupleItem *item)
 Add an item row to the N tuple.
virtual StatusCode remove (INTupleItem *item)
 Remove an item row (identified by pointer) from the N tuple.
virtual StatusCode remove (const std::string &name)
 Remove an item row (identified by name) from the N tuple.
virtual StatusCode write ()
 Write record of the NTuple (Shortcut of writeRecord).
virtual StatusCode writeRecord ()
 Write record of the NTuple.
virtual StatusCode read ()
 Read record of the NTuple (Shortcut of readRecord).
virtual StatusCode readRecord ()
 Read record of the NTuple.
virtual StatusCode save ()
 Save the NTuple.
template<class TYPE>
StatusCode item (const std::string &name, Item< TYPE > &result)
 Locate a scalar Item of data to the N tuple type safe.
template<class TYPE>
StatusCode item (const std::string &name, const Item< TYPE > &result) const
 Locate a scalar Item of data to the N tuple type safe (CONST).
template<class TYPE>
StatusCode item (const std::string &name, Array< TYPE > &result)
 Locate a Array of data to the N tuple type safe.
template<class TYPE>
StatusCode item (const std::string &name, const Array< TYPE > &result) const
 Locate a Array of data to the N tuple type safe (CONST).
template<class TYPE>
StatusCode item (const std::string &name, Matrix< TYPE > &result)
 Locate a Matrix of data to the N tuple type safe.
template<class TYPE>
StatusCode item (const std::string &name, const Matrix< TYPE > &result) const
 Locate a Matrix of data to the N tuple type safe (CONST).
template<class TYPE>
StatusCode addItem (const std::string &name, Item< TYPE > &itm)
 Add a scalar data item a N tuple.
template<class TYPE>
StatusCode addItem (const std::string &name, Item< TYPE * > &itm)
 Add an simple object item to an N tuple.
StatusCode addItem (const std::string &name, Item< IOpaqueAddress * > &itm)
 Add an address object item to an N tuple: specialized call.
template<class TYPE, class RANGE>
StatusCode addItem (const std::string &name, Item< TYPE > &itm, const RANGE low, const RANGE high)
 Add a scalar data item a N tuple with a range.
template<class TYPE>
StatusCode addItem (const std::string &name, long dim, Array< TYPE > &array)
 Add an fixed-size Array of data to a column wise N tuple.
template<class TYPE, class RANGE>
StatusCode addItem (const std::string &name, long dim, Array< TYPE > &array, const RANGE low, const RANGE high)
 Add an fixed-size Array of data to a column wise N tuple with a range.
template<class TYPE, class INDEX, class RANGE>
StatusCode addItem (const std::string &name, Item< INDEX > &index, Array< TYPE > &array, const RANGE low, const RANGE high)
 Add an indexed Array of data to a column wise N tuple with a range.
template<class TYPE, class INDEX>
StatusCode addItem (const std::string &name, Item< INDEX > &index, Array< TYPE > &array)
 Add an indexed Array of data to a column wise N tuple.
template<class TYPE>
StatusCode addItem (const std::string &name, long cols, long rows, Matrix< TYPE > &matrix)
 Add an fixed size Matrix of data to a column wise N tuple.
template<class TYPE, class RANGE>
StatusCode addItem (const std::string &name, long cols, long rows, Matrix< TYPE > &result, const RANGE low, const RANGE high)
 Add an fixed size Matrix of data to a column wise N tuple.
template<class TYPE, class INDEX>
StatusCode addItem (const std::string &name, Item< INDEX > &index, Matrix< TYPE > &matrix, long rows)
 Add an variable size Matrix of data to a column wise N tuple.
template<class TYPE, class INDEX, class RANGE>
StatusCode addItem (const std::string &name, Item< INDEX > &index, Matrix< TYPE > &matrix, long rows, const RANGE low, const RANGE high)
 Add an variable size Matrix of data to a column wise N tuple.
template<class TYPE, class INDEX, class RANGE>
StatusCode addIndexedItem (const std::string &name, Item< INDEX > &index, Array< TYPE > &array, const RANGE low, const RANGE high)
 Add an indexed Array of data to a column wise N tuple with a range.
template<class TYPE, class INDEX>
StatusCode addIndexedItem (const std::string &name, Item< INDEX > &index, Array< TYPE > &array)
 Add an indexed Array of data to a column wise N tuple.
template<class TYPE, class INDEX>
StatusCode addIndexedItem (const std::string &name, Item< INDEX > &col_index, long rows, Matrix< TYPE > &matrix)
 Add an variable size Matrix of data to a column wise N tuple.
template<class TYPE, class INDEX, class RANGE>
StatusCode addIndexedItem (const std::string &name, Item< INDEX > &index, long rows, Matrix< TYPE > &matrix, const RANGE low, const RANGE high)
 Add an variable size Matrix of data to a column wise N tuple.
virtual unsigned long addRef ()
 Add reference to object.
virtual unsigned long release ()
 release reference to object
const std::string & name () const
 Retreive DataObject name. It is the name when registered in the store.
virtual StreamBuffer & serialize (StreamBuffer &s)
 Serialization mechanism: Serialize the object for reading.
virtual StreamBuffer & serialize (StreamBuffer &s) const
 Serialization mechanism: Serialize the object for writing.

Static Public Member Functions

static const CLID & classID ()
 Static access to class defininition structure.

Protected Member Functions

template<class TYPE>
StatusCode i_item (const std::string &name, _Item< TYPE > *&result) const
 Locate a _Column of data to the N tuple type safe.
template<class TYPE>
StatusCode i_item (const std::string &name, _Item< TYPE * > *&result) const
 Locate a _Column of data to the N tuple type unsafe for objects.
StatusCode i_item (const std::string &name, _Item< IOpaqueAddress * > *&result) const
 Locate a _Column of data to the N tuple type safe.
template<class TYPE>
StatusCode i_item (const std::string &name, _Array< TYPE > *&result) const
 Locate a _Array of data to the N tuple type safe.
template<class TYPE>
StatusCode i_item (const std::string &name, _Matrix< TYPE > *&result) const
 Locate a _Matrix of data to the N tuple type safe.
template<class TYPE>
StatusCode i_addItem (const std::string &name, long, const std::string &, TYPE low, TYPE high, _Item< TYPE > *&result)
 Add a _Item of data to the N tuple.
template<class TYPE>
StatusCode i_addItem (const std::string &name, long dim, const std::string &index, TYPE low, TYPE high, _Array< TYPE > *&result)
 Add a _Item of data to the N tuple.
template<class TYPE>
StatusCode i_addItem (const std::string &name, long dim1, long dim2, const std::string &index, TYPE low, TYPE high, _Matrix< TYPE > *&result)
 Add a _Item of data to the N tuple.
template<class TYPE>
StatusCode i_addObject (const std::string &name, _Item< TYPE * > *&result, const std::type_info &)

Protected Attributes

ItemContainer m_items
 Container with N tuple _Columns.
bool m_isBooked
 Flag wether N tuple is booked.
std::string m_title
 N tuple title.
ISelectStatement * m_pSelector
 Possibly hanging selector.
char * m_buffer
 Buffer size.
INTupleSvc * m_ntupleSvc
 Reference to N-tuple service used.
IConversionSvc * m_cnvSvc
 Reference to the conversion service used.

Detailed Description

Definition at line 134 of file NTupleImplementation.h.

Member Typedef Documentation

typedef std::vector< INTupleItem* > INTuple::ItemContainer [inherited]

Definition at line 86 of file INTuple.h.

Constructor & Destructor Documentation

NTuple::RowWiseTuple::RowWiseTuple ( const std::string &  title  )  [inline]

Standard Constructor.

Definition at line 137 of file NTupleImplementation.h.

00137                                            : TupleImp(title)    {
00138     }

virtual NTuple::RowWiseTuple::~RowWiseTuple (  )  [inline, virtual]

Standard Destructor.

Definition at line 140 of file NTupleImplementation.h.

00140                               {
00141     }

Member Function Documentation

virtual const CLID& NTuple::RowWiseTuple::clID (  )  const [inline, virtual]

Retrieve Reference to class defininition structure.

Reimplemented from DataObject.

Definition at line 143 of file NTupleImplementation.h.

00143                                        {
00144       return RowWiseTuple::classID();
00145     }

static const CLID& NTuple::RowWiseTuple::classID (  )  [inline, static]

Static access to class defininition structure.

Reimplemented from DataObject.

Definition at line 147 of file NTupleImplementation.h.

00147                                       {
00148       return CLID_RowWiseTuple;
00149     }

virtual INTupleItem* NTuple::TupleImp::i_find ( const std::string &  name  )  const [virtual, inherited]

Internally used by abstract classes.

Implements INTuple.

ItemContainer& NTuple::TupleImp::items (  )  [inline, virtual, inherited]

Access item container.

Implements INTuple.

Definition at line 43 of file NTupleImplementation.h.

00043                               {
00044       return m_items;
00045     }

const ItemContainer& NTuple::TupleImp::items (  )  const [inline, virtual, inherited]

Access item container (CONST).

Implements INTuple.

Definition at line 47 of file NTupleImplementation.h.

00047                                             {
00048       return m_items;
00049     }

virtual const std::string& NTuple::TupleImp::title (  )  const [inline, virtual, inherited]

Object title.

Implements INTuple.

Definition at line 51 of file NTupleImplementation.h.

00051                                                       {
00052       return m_title;
00053     }

virtual const INTupleItem* NTuple::TupleImp::find ( const std::string &  name  )  const [inline, virtual, inherited]

Find an item row of the Ntuple (CONST).

Implements INTuple.

Definition at line 55 of file NTupleImplementation.h.

00055                                                                     {
00056       return i_find(name);
00057     }

virtual INTupleItem* NTuple::TupleImp::find ( const std::string &  name  )  [inline, virtual, inherited]

Find an item row of the Ntuple.

Implements INTuple.

Definition at line 59 of file NTupleImplementation.h.

00059                                                         {
00060       return i_find(name);
00061     }

char* NTuple::TupleImp::buffer (  )  [inline, virtual, inherited]

Access N tuple data buffer.

Implements INTuple.

Definition at line 63 of file NTupleImplementation.h.

00063                       {
00064       return m_buffer;
00065     }

const char* NTuple::TupleImp::buffer (  )  const [inline, virtual, inherited]

Access N tuple data buffer (CONST).

Implements INTuple.

Definition at line 67 of file NTupleImplementation.h.

00067                                  {
00068       return m_buffer;
00069     }

IConversionSvc* NTuple::TupleImp::conversionService (  )  const [inline, inherited]

Access conversion service.

Definition at line 71 of file NTupleImplementation.h.

00071                                                  {
00072       return m_cnvSvc;
00073     }

void NTuple::TupleImp::setConversionService ( IConversionSvc *  svc  )  [inline, inherited]

Access conversion service.

Definition at line 75 of file NTupleImplementation.h.

00075                                                         {
00076       m_cnvSvc = svc;
00077     }

INTupleSvc* NTuple::TupleImp::tupleService (  )  const [inline, inherited]

Access conversion service.

Definition at line 79 of file NTupleImplementation.h.

00079                                         {
00080       return m_ntupleSvc;
00081     }

void NTuple::TupleImp::setTupleService ( INTupleSvc *  svc  )  [inline, inherited]

Access conversion service.

Definition at line 83 of file NTupleImplementation.h.

00083                                                {
00084       m_ntupleSvc = svc;
00085     }

virtual StatusCode NTuple::TupleImp::attachSelector ( ISelectStatement *  sel  )  [virtual, inherited]

Attach selector.

Implements INTuple.

virtual ISelectStatement* NTuple::TupleImp::selector (  )  [virtual, inherited]

Access selector.

Implements INTuple.

virtual void NTuple::TupleImp::setBuffer ( char *  buff  )  [virtual, inherited]

Set N tuple data buffer.

Implements INTuple.

virtual void NTuple::TupleImp::reset (  )  [virtual, inherited]

Reset all entries to their default values.

Implements INTuple.

virtual StatusCode NTuple::TupleImp::add ( INTupleItem *  item  )  [virtual, inherited]

Add an item row to the N tuple.

Implements INTuple.

virtual StatusCode NTuple::TupleImp::remove ( INTupleItem *  item  )  [virtual, inherited]

Remove an item row (identified by pointer) from the N tuple.

Implements INTuple.

virtual StatusCode NTuple::TupleImp::remove ( const std::string &  name  )  [virtual, inherited]

Remove an item row (identified by name) from the N tuple.

Implements INTuple.

virtual StatusCode NTuple::TupleImp::write (  )  [virtual, inherited]

Write record of the NTuple (Shortcut of writeRecord).

Implements INTuple.

virtual StatusCode NTuple::TupleImp::writeRecord (  )  [virtual, inherited]

Write record of the NTuple.

Implements INTuple.

virtual StatusCode NTuple::TupleImp::read (  )  [virtual, inherited]

Read record of the NTuple (Shortcut of readRecord).

Implements INTuple.

virtual StatusCode NTuple::TupleImp::readRecord (  )  [virtual, inherited]

Read record of the NTuple.

Implements INTuple.

virtual StatusCode NTuple::TupleImp::save (  )  [virtual, inherited]

Save the NTuple.

Implements INTuple.

template<class TYPE>
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Item< TYPE > *&  result 
) const [inline, protected, inherited]

Locate a _Column of data to the N tuple type safe.

Definition at line 369 of file NTuple.h.

00370                                                                            {
00371       try   {
00372         result = dynamic_cast< _Item<TYPE>* > (i_find(name));
00373       }
00374       catch (...)   {
00375         result = 0;
00376       }
00377       return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
00378     }

template<class TYPE>
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Item< TYPE * > *&  result 
) const [inline, protected, inherited]

Locate a _Column of data to the N tuple type unsafe for objects.

Definition at line 380 of file NTuple.h.

00381                                                                             {
00382       try   {
00383         _Item<void*>* p = dynamic_cast< _Item<void*>* > (i_find(name));
00384         result = (_Item<TYPE*>*)p;
00385       }
00386       catch (...)   {
00387         result = 0;
00388       }
00389       return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
00390     }

StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Item< IOpaqueAddress * > *&  result 
) const [inline, protected, inherited]

Locate a _Column of data to the N tuple type safe.

Definition at line 392 of file NTuple.h.

00393                                                                                       {
00394       try   {
00395         result = dynamic_cast< _Item<IOpaqueAddress*>* > (i_find(name));
00396       }
00397       catch (...)   {
00398         result = 0;
00399       }
00400       return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
00401     }

template<class TYPE>
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Array< TYPE > *&  result 
) const [inline, protected, inherited]

Locate a _Array of data to the N tuple type safe.

Definition at line 403 of file NTuple.h.

00404                                                                             {
00405       try   {
00406         if ( clID() == CLID_ColumnWiseTuple )   {
00407           result = dynamic_cast< _Array<TYPE>* > (i_find(name));
00408         }
00409       }
00410       catch (...)   {
00411         result = 0;
00412       }
00413       return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
00414     }

template<class TYPE>
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Matrix< TYPE > *&  result 
) const [inline, protected, inherited]

Locate a _Matrix of data to the N tuple type safe.

Definition at line 416 of file NTuple.h.

00417                                                                              {
00418       try   {
00419         if ( clID() == CLID_ColumnWiseTuple )   {
00420           result = dynamic_cast< _Matrix<TYPE>* > (i_find(name));
00421         }
00422       }
00423       catch (...)   {
00424         result = 0;
00425       }
00426       return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
00427     }

template<class TYPE>
StatusCode NTuple::Tuple::i_addItem ( const std::string &  name,
long  ,
const std::string &  ,
TYPE  low,
TYPE  high,
_Item< TYPE > *&  result 
) [inline, protected, inherited]

Add a _Item of data to the N tuple.

Definition at line 430 of file NTuple.h.

00435                                                  {
00436       if ( !i_find(name) )    {
00437         TYPE nil;
00438         nil = 0;
00439         return add( result = _Item<TYPE>::create(this, name, typeid(TYPE), low, high, nil) );
00440       }
00441       return StatusCode::FAILURE;
00442     }

template<class TYPE>
StatusCode NTuple::Tuple::i_addItem ( const std::string &  name,
long  dim,
const std::string &  index,
TYPE  low,
TYPE  high,
_Array< TYPE > *&  result 
) [inline, protected, inherited]

Add a _Item of data to the N tuple.

Definition at line 445 of file NTuple.h.

00450                                                   {
00451       if ( !i_find(name) && clID() == CLID_ColumnWiseTuple )    {
00452         return add( result = _Array<TYPE>::create(this,
00453                                                   name,
00454                                                   typeid(TYPE),
00455                                                   index,
00456                                                   dim,
00457                                                   low,
00458                                                   high,
00459                                                   TYPE(0)) );
00460       }
00461       return StatusCode::FAILURE;
00462     }

template<class TYPE>
StatusCode NTuple::Tuple::i_addItem ( const std::string &  name,
long  dim1,
long  dim2,
const std::string &  index,
TYPE  low,
TYPE  high,
_Matrix< TYPE > *&  result 
) [inline, protected, inherited]

Add a _Item of data to the N tuple.

Definition at line 465 of file NTuple.h.

00471                                                    {
00472       if ( !i_find(name) && clID() == CLID_ColumnWiseTuple )    {
00473         return add( result = _Matrix<TYPE>::create(this,
00474                                                    name,
00475                                                    typeid(TYPE),
00476                                                    index,
00477                                                    dim1,
00478                                                    dim2,
00479                                                    low,
00480                                                    high,
00481                                                    TYPE(0)) );
00482       }
00483       return StatusCode::FAILURE;
00484     }

template<class TYPE>
StatusCode NTuple::Tuple::i_addObject ( const std::string &  name,
_Item< TYPE * > *&  result,
const std::type_info &   
) [inline, protected, inherited]

Definition at line 486 of file NTuple.h.

00486                                                                                             {
00487       if ( !i_find(name) && clID() == CLID_ColumnWiseTuple )    {
00488         return add( result = (_Item<TYPE*>*)_Item<void*>::create(this, name, typeid(TYPE),0,0,0) );
00489       }
00490       return StatusCode::FAILURE;
00491     }

template<class TYPE>
StatusCode NTuple::Tuple::item ( const std::string &  name,
Item< TYPE > &  result 
) [inline, inherited]

Locate a scalar Item of data to the N tuple type safe.

Definition at line 498 of file NTuple.h.

00500     {
00501       return i_item(name, result.m_ptr);
00502     }

template<class TYPE>
StatusCode NTuple::Tuple::item ( const std::string &  name,
const Item< TYPE > &  result 
) const [inline, inherited]

Locate a scalar Item of data to the N tuple type safe (CONST).

Definition at line 504 of file NTuple.h.

00506     {
00507       return i_item(name, result.m_ptr);
00508     }

template<class TYPE>
StatusCode NTuple::Tuple::item ( const std::string &  name,
Array< TYPE > &  result 
) [inline, inherited]

Locate a Array of data to the N tuple type safe.

Definition at line 511 of file NTuple.h.

00512     {
00513       return i_item(name, result.m_ptr);
00514     }

template<class TYPE>
StatusCode NTuple::Tuple::item ( const std::string &  name,
const Array< TYPE > &  result 
) const [inline, inherited]

Locate a Array of data to the N tuple type safe (CONST).

Definition at line 516 of file NTuple.h.

00518     {
00519       return i_item(name, result.m_ptr);
00520     }

template<class TYPE>
StatusCode NTuple::Tuple::item ( const std::string &  name,
Matrix< TYPE > &  result 
) [inline, inherited]

Locate a Matrix of data to the N tuple type safe.

Definition at line 522 of file NTuple.h.

00524     {
00525       return i_item(name, result.m_ptr);
00526     }

template<class TYPE>
StatusCode NTuple::Tuple::item ( const std::string &  name,
const Matrix< TYPE > &  result 
) const [inline, inherited]

Locate a Matrix of data to the N tuple type safe (CONST).

Definition at line 529 of file NTuple.h.

00531     {
00532       return i_item(name, result.m_ptr);
00533     }

template<class TYPE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< TYPE > &  itm 
) [inline, inherited]

Add a scalar data item a N tuple.

Use this entry point to connect any allowed scalar data type to an N-tuple. The value filled, may have any range. Do NOT use this entry point to specify an index column in a column wise N-tuple.

Parameters:
name Name of the column in the column wise N-tuple
itm Reference to the Item<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 549 of file NTuple.h.

00549                                                      {
00550       typedef Range<TYPE> _R;
00551       return i_addItem(name, 1, "", _R::min(), _R::max(), itm.m_ptr);
00552     }

template<class TYPE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< TYPE * > &  itm 
) [inline, inherited]

Add an simple object item to an N tuple.

Parameters:
name Name of the column in the column wise N-tuple
itm Reference to the Item<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 563 of file NTuple.h.

00563                                                      {
00564       return i_addObject(name,itm.m_ptr,typeid(TYPE));
00565     }

StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< IOpaqueAddress * > &  itm 
) [inline, inherited]

Add an address object item to an N tuple: specialized call.

Parameters:
name Name of the column in the column wise N-tuple
itm Reference to the Item<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 576 of file NTuple.h.

00576                                                                {
00577       typedef Range<IOpaqueAddress*> _R;
00578       return i_addItem(name, 1, "", _R::min(), _R::max(), itm.m_ptr);
00579     }

template<class TYPE, class RANGE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< TYPE > &  itm,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add a scalar data item a N tuple with a range.

Typically this entry point is used to specuify index column with a fixed data range for a column wise N-tuple.

Note: Checks on the data range are not implemented!

Parameters:
name Name of the column in the column wise N-tuple
itm Reference to the Item<TYPE> datatype, which should be connected to the N-tuple.
low Lower edge of client data values allowed to fill into the N-tuple array.
high Upper edge of client data values allowed to fill into the N-tuple array.
Returns:
StatusCode indicating success or failure.

Definition at line 599 of file NTuple.h.

00603     {
00604       return i_addItem( name, 1, "", TYPE(low), TYPE(high), itm.m_ptr);
00605     }

template<class TYPE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
long  dim,
Array< TYPE > &  array 
) [inline, inherited]

Add an fixed-size Array of data to a column wise N tuple.

You should use this entry point to add a FIXED SIZE ARRAY to a column wise N-tuple. The dimension of the array must be specified.

Parameters:
name Name of the column in the column wise N-tuple
dim Length of the array to be added to the N-tuple
array Reference to the Array<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 621 of file NTuple.h.

00624     {
00625       return i_addItem(name,
00626                        dim,
00627                        "",
00628                        Range<TYPE>::min(),
00629                        Range<TYPE>::max(),
00630                        array.m_ptr);
00631     }

template<class TYPE, class RANGE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
long  dim,
Array< TYPE > &  array,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add an fixed-size Array of data to a column wise N tuple with a range.

You should use this entry point to add a FIXED SIZE ARRAY to a column wise N-tuple. The dimension of the array must be specified.

Note: Checks on the data range are not implemented!

Parameters:
name Name of the column in the column wise N-tuple
dim Length of the array to be added to the N-tuple
array Reference to the Array<TYPE> datatype, which should be connected to the N-tuple.
low Lower edge of client data values allowed to fill into the N-tuple array.
high Upper edge of client data values allowed to fill into the N-tuple array.
Returns:
StatusCode indicating success or failure.

Definition at line 653 of file NTuple.h.

00658     {
00659       return i_addItem(name,
00660                        dim,
00661                        "",
00662                        TYPE(low),
00663                        TYPE(high),
00664                        array.m_ptr);
00665     }

template<class TYPE, class INDEX, class RANGE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< INDEX > &  index,
Array< TYPE > &  array,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add an indexed Array of data to a column wise N tuple with a range.

You should use this entry point to add a VARIABLE SIZE ARRAY to a column wise N-tuple. The dimension of the array is unspecified and depends on the data range, which you allowed for the index column.

Hence you have to be careful on the allowed data range of the index column, because the index column determines the total allocated memory.

Note: Checks on the data range are not implemented!

Note: Due to confusion with the entry point to connecting a fixed size array the use of this function is DEPRECATED *** please use addIndexedItem(...) instead.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the size of the array.
array Reference to the Array<TYPE> datatype, which should be connected to the N-tuple.
low Lower edge of client data values allowed to fill into the N-tuple array.
high Upper edge of client data values allowed to fill into the N-tuple array.
Returns:
StatusCode indicating success or failure.

Definition at line 698 of file NTuple.h.

00703     {
00704       return i_addItem( name,
00705                         index->range().distance(),
00706                         index->name(),
00707                         TYPE(low),
00708                         TYPE(high),
00709                         array.m_ptr);
00710     }

template<class TYPE, class INDEX>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< INDEX > &  index,
Array< TYPE > &  array 
) [inline, inherited]

Add an indexed Array of data to a column wise N tuple.

You should use this entry point to add a VARIABLE SIZE ARRAY to a column wise N-tuple. The dimension of the array is unspecified and depends on the data range, which you allowed for the index column.

Hence, you have to be careful on the allowed data range of the index column, because the index column determines the total allocated memory.

Note: Due to confusion with the entry point to connecting a fixed size array the use of this member function is DEPRECATED *** please use addIndexedItem(...) instead.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the size of the array.
array Reference to the Array<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 777 of file NTuple.h.

00780     {
00781       return i_addItem( name,
00782                         index->range().distance(),
00783                         index->name(),
00784                         Range<TYPE>::min(),
00785                         Range<TYPE>::max(),
00786                         array.m_ptr);
00787     }

template<class TYPE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
long  cols,
long  rows,
Matrix< TYPE > &  matrix 
) [inline, inherited]

Add an fixed size Matrix of data to a column wise N tuple.

You should use this entry point to add a FIXED SIZE MATRIX to a column wise N-tuple. The dimension of the matrix must be specified.

Attention: Do not confuse with entry point to add a VARIABLE SIZE MATRIX!

Parameters:
name Name of the column in the column wise N-tuple
cols Number of data columns in the Matrix.
rows Number of data rows in the Matrix.
matrix Reference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 839 of file NTuple.h.

00843     {
00844       return i_addItem(name,
00845                        cols,
00846                        rows,
00847                        "",
00848                        Range<TYPE>::min(),
00849                        Range<TYPE>::max(),
00850                        matrix.m_ptr);
00851     }

template<class TYPE, class RANGE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
long  cols,
long  rows,
Matrix< TYPE > &  result,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add an fixed size Matrix of data to a column wise N tuple.

You should use this entry point to add a FIXED SIZE MATRIX to a column wise N-tuple. The dimension of the matrix must be specified.

Note: Checks on the data range are not implemented! Attention: Do not confuse with entry point to add a VARIABLE SIZE MATRIX!

Parameters:
name Name of the column in the column wise N-tuple
cols Number of data columns in the Matrix.
rows Number of data rows in the Matrix.
matrix Reference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
low Lower edge of client data values allowed to fill into the N-tuple matrix.
high Upper edge of client data values allowed to fill into the N-tuple matrix.
Returns:
StatusCode indicating success or failure.

Definition at line 876 of file NTuple.h.

00882     {
00883       return i_addItem(name,
00884                        cols,
00885                        rows,
00886                        "",
00887                        TYPE(low),
00888                        TYPE(high),
00889                        result.m_ptr);
00890     }

template<class TYPE, class INDEX>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< INDEX > &  index,
Matrix< TYPE > &  matrix,
long  rows 
) [inline, inherited]

Add an variable size Matrix of data to a column wise N tuple.

You should use this entry point to add a VARIABLE SIZE MATRIX to a column wise N-tuple. The number of columns of the matrix is given by the allowed data range of the index column. The number of rows however, which are allowed in the matrix must be specified explicitly and cannot be variable.

Attention: Do not confuse with entry point to add a FIXED SIZE MATRIX.

Note: Due to confusion with the entry point to connecting a fixed size matrix the use of this member function is DEPRECATED *** please use addIndexedItem(...) instead.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the number of data columns in the matrix
matrix Reference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
rows Number of data rows in the Matrix.
Returns:
StatusCode indicating success or failure.

Definition at line 918 of file NTuple.h.

00922     {
00923       return i_addItem( name,
00924                         index->range().distance(),
00925                         rows,
00926                         index->name(),
00927                         Range<TYPE>::min(),
00928                         Range<TYPE>::max(),
00929                         matrix.m_ptr);
00930     }

template<class TYPE, class INDEX, class RANGE>
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< INDEX > &  index,
Matrix< TYPE > &  matrix,
long  rows,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add an variable size Matrix of data to a column wise N tuple.

You should use this entry point to add a VARIABLE SIZE MATRIX to a column wise N-tuple. The number of columns of the matrix is given by the allowed data range of the index column. The number of rows however, which are allowed in the matrix must be specified explicitly and cannot be variable. Also the range of allowed data values to be filled into the data area of the matrix can be specified.

Note: Checks on the data range are not implemented! Attention: Do not confuse with entry point to add a FIXED SIZE MATRIX.

Note: Due to confusion with the entry point to connecting a fixed size matrix the use of this member function is DEPRECATED *** please use addIndexedItem(...) instead.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the number of data columns in the matrix
matrix Reference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
rows Number of data rows in the Matrix.
low Lower edge of client data values allowed to fill into the N-tuple matrix.
high Upper edge of client data values allowed to fill into the N-tuple matrix.
Returns:
StatusCode indicating success or failure.

Definition at line 1000 of file NTuple.h.

01006     {
01007       return i_addItem( name,
01008                         index->range().distance(),
01009                         rows,
01010                         index->name(),
01011                         TYPE(low),
01012                         TYPE(high),
01013                         matrix.m_ptr);
01014     }

template<class TYPE, class INDEX, class RANGE>
StatusCode NTuple::Tuple::addIndexedItem ( const std::string &  name,
Item< INDEX > &  index,
Array< TYPE > &  array,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add an indexed Array of data to a column wise N tuple with a range.

You should use this entry point to add a VARIABLE SIZE ARRAY to a column wise N-tuple. The dimension of the array is unspecified and depends on the data range, which you allowed for the index column.

Hence you have to be careful on the allowed data range of the index column, because the index column determines the total allocated memory.

Note: Checks on the data range are not implemented!

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the size of the array.
array Reference to the Array<TYPE> datatype, which should be connected to the N-tuple.
low Lower edge of client data values allowed to fill into the N-tuple array.
high Upper edge of client data values allowed to fill into the N-tuple array.
Returns:
StatusCode indicating success or failure.

Definition at line 738 of file NTuple.h.

00743     {
00744       return i_addItem( name,
00745                         index->range().distance(),
00746                         index->name(),
00747                         TYPE(low),
00748                         TYPE(high),
00749                         array.m_ptr);
00750     }

template<class TYPE, class INDEX>
StatusCode NTuple::Tuple::addIndexedItem ( const std::string &  name,
Item< INDEX > &  index,
Array< TYPE > &  array 
) [inline, inherited]

Add an indexed Array of data to a column wise N tuple.

You should use this entry point to add a VARIABLE SIZE ARRAY to a column wise N-tuple. The dimension of the array is unspecified and depends on the data range, which you allowed for the index column.

Hence, you have to be careful on the allowed data range of the index column, because the index column determines the total allocated memory.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the size of the array.
array Reference to the Array<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 809 of file NTuple.h.

00812     {
00813       return i_addItem( name,
00814                         index->range().distance(),
00815                         index->name(),
00816                         Range<TYPE>::min(),
00817                         Range<TYPE>::max(),
00818                         array.m_ptr);
00819     }

template<class TYPE, class INDEX>
StatusCode NTuple::Tuple::addIndexedItem ( const std::string &  name,
Item< INDEX > &  col_index,
long  rows,
Matrix< TYPE > &  matrix 
) [inline, inherited]

Add an variable size Matrix of data to a column wise N tuple.

You should use this entry point to add a VARIABLE SIZE MATRIX to a column wise N-tuple. The number of columns of the matrix is given by the allowed data range of the index column. The number of rows however, which are allowed in the matrix must be specified explicitly and cannot be variable.

Attention: Do not confuse with entry point to add a FIXED SIZE MATRIX.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the number of data columns in the matrix
rows Number of data rows in the Matrix.
matrix Reference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
Returns:
StatusCode indicating success or failure.

Definition at line 953 of file NTuple.h.

00957     {
00958       return i_addItem( name,
00959                         col_index->range().distance(),
00960                         rows,
00961                         col_index->name(),
00962                         Range<TYPE>::min(),
00963                         Range<TYPE>::max(),
00964                         matrix.m_ptr);
00965     }

template<class TYPE, class INDEX, class RANGE>
StatusCode NTuple::Tuple::addIndexedItem ( const std::string &  name,
Item< INDEX > &  index,
long  rows,
Matrix< TYPE > &  matrix,
const RANGE  low,
const RANGE  high 
) [inline, inherited]

Add an variable size Matrix of data to a column wise N tuple.

You should use this entry point to add a VARIABLE SIZE MATRIX to a column wise N-tuple. The number of columns of the matrix is given by the allowed data range of the index column. The number of rows however, which are allowed in the matrix must be specified explicitly and cannot be variable. Also the range of allowed data values to be filled into the data area of the matrix can be specified.

Note: Checks on the data range are not implemented! Attention: Do not confuse with entry point to add a FIXED SIZE MATRIX.

Parameters:
name Name of the column in the column wise N-tuple
index Reference to the scalar index column used to determine the number of data columns in the matrix
rows Number of data rows in the Matrix.
matrix Reference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
low Lower edge of client data values allowed to fill into the N-tuple matrix.
high Upper edge of client data values allowed to fill into the N-tuple matrix.
Returns:
StatusCode indicating success or failure.

Definition at line 1044 of file NTuple.h.

01050     {
01051       return i_addItem( name,
01052                         index->range().distance(),
01053                         rows,
01054                         index->name(),
01055                         TYPE(low),
01056                         TYPE(high),
01057                         matrix.m_ptr);
01058     }

virtual unsigned long DataObject::addRef (  )  [virtual, inherited]

Add reference to object.

virtual unsigned long DataObject::release (  )  [virtual, inherited]

release reference to object

const std::string& DataObject::name (  )  const [inherited]

Retreive DataObject name. It is the name when registered in the store.

Reimplemented in NTuple::File, and ServiceHistory.

virtual StreamBuffer& DataObject::serialize ( StreamBuffer &  s  )  [virtual, inherited]

Serialization mechanism: Serialize the object for reading.

Reimplemented in RefTableBase< FROM, MAPENTRY >, RefTableBase< FROM, SmartRefVector< TO > >, and RefTableBase< FROM, SmartRef< TO > >.

virtual StreamBuffer& DataObject::serialize ( StreamBuffer &  s  )  const [virtual, inherited]

Serialization mechanism: Serialize the object for writing.

Reimplemented in RefTableBase< FROM, MAPENTRY >, RefTableBase< FROM, SmartRefVector< TO > >, and RefTableBase< FROM, SmartRef< TO > >.

void DataObject::setRegistry ( IRegistry *  pRegistry  )  [inline, inherited]

Set pointer to Registry.

Definition at line 67 of file DataObject.h.

00067                                             {
00068     m_pRegistry = pRegistry;
00069   }

IRegistry* DataObject::registry (  )  const [inline, inherited]

Get pointer to Registry.

Definition at line 71 of file DataObject.h.

00071                                 {
00072     return m_pRegistry;
00073   }

LinkManager* DataObject::linkMgr (  )  const [inline, inherited]

Retrieve Link manager.

Definition at line 75 of file DataObject.h.

00075                                     {
00076     return m_pLinkMgr;
00077   }

unsigned char DataObject::version (  )  const [inline, inherited]

Retrieve version number of this object representation.

Definition at line 79 of file DataObject.h.

00079                                     {
00080     return m_version;
00081   }

void DataObject::setVersion ( unsigned char  vsn  )  [inline, inherited]

Set version number of this object representation.

Definition at line 83 of file DataObject.h.

00083                                         {
00084     m_version = vsn;
00085   }

unsigned long DataObject::refCount (  )  const [inline, inherited]

Return the refcount.

Definition at line 87 of file DataObject.h.

00087                                  {
00088     return m_refCount;
00089   }

virtual std::ostream& DataObject::fillStream ( std::ostream &  s  )  const [inline, virtual, inherited]

Fill the output stream (ASCII).

Reimplemented in ObjectList< TYPE >, and ObjectVector< TYPE >.

Definition at line 91 of file DataObject.h.

00091                                                         {
00092     s << "DataObject at " << std::hex << this;
00093     return s;
00094   }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  s,
const DataObject &  obj 
) [friend, inherited]

Output operator (ASCII).

Definition at line 96 of file DataObject.h.

00096                                                                          {
00097     return obj.fillStream(s);
00098   }

Member Data Documentation

ItemContainer NTuple::TupleImp::m_items [protected, inherited]

Container with N tuple _Columns.

Definition at line 17 of file NTupleImplementation.h.

bool NTuple::TupleImp::m_isBooked [protected, inherited]

Flag wether N tuple is booked.

Definition at line 19 of file NTupleImplementation.h.

std::string NTuple::TupleImp::m_title [protected, inherited]

N tuple title.

Definition at line 21 of file NTupleImplementation.h.

ISelectStatement* NTuple::TupleImp::m_pSelector [protected, inherited]

Possibly hanging selector.

Definition at line 23 of file NTupleImplementation.h.

char* NTuple::TupleImp::m_buffer [protected, inherited]

Buffer size.

Definition at line 25 of file NTupleImplementation.h.

INTupleSvc* NTuple::TupleImp::m_ntupleSvc [protected, inherited]

Reference to N-tuple service used.

Definition at line 27 of file NTupleImplementation.h.

IConversionSvc* NTuple::TupleImp::m_cnvSvc [protected, inherited]

Reference to the conversion service used.

Definition at line 29 of file NTupleImplementation.h.

The documentation for this class was generated from the following file:
| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |
Generated on Mon Apr 11 19:57:19 2011 for GaudiKernel by doxygen 1.4.7