Abstract base class which allows the user to interact with the actual N tuple implementation. More...

#include <GaudiKernel/NTuple.h>

Inheritance diagram for NTuple::Tuple:

[legend]

Collaboration diagram for NTuple::Tuple:

[legend]

Public Member Functions
	~Tuple () override=default
	Standard destructor. More...

template<class TYPE >
StatusCode	item (const std::string &name, Item< TYPE > &result)
	Locate a scalar Item of data to the N tuple type safe. More...

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) More...

template<class TYPE >
StatusCode	item (const std::string &name, Array< TYPE > &result)
	Locate a Array of data to the N tuple type safe. More...

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) More...

template<class TYPE >
StatusCode	item (const std::string &name, Matrix< TYPE > &result)
	Locate a Matrix of data to the N tuple type safe. More...

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) More...

template<class TYPE >
StatusCode	addItem (const std::string &name, Item< TYPE > &itm)
	Add a scalar data item a N tuple. More...

template<class TYPE >
StatusCode	addItem (const std::string &name, Item< TYPE * > &itm)
	Add an simple object item to an N tuple. More...

StatusCode	addItem (const std::string &name, Item< IOpaqueAddress * > &itm)
	Add an address object item to an N tuple: specialized call. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

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. More...

Public Member Functions inherited from DataObject
	DataObject ()
	Standard Constructor. More...

	DataObject (const DataObject &rhs)
	Copy Constructor. More...

DataObject &	operator= (const DataObject &rhs)
	Assignment Operator. More...

	DataObject (DataObject &&rhs)
	Move Constructor. More...

DataObject &	operator= (DataObject &&rhs)
	Move Assignment Operator. More...

virtual	~DataObject ()
	Standard Destructor. More...

virtual unsigned long	addRef ()
	Add reference to object. More...

virtual unsigned long	release ()
	release reference to object More...

virtual const CLID &	clID () const
	Retrieve reference to class definition structure. More...

const std::string &	name () const
	Retreive DataObject name. It is the name when registered in the store. More...

virtual StatusCode	update ()
	Provide empty placeholder for internal object reconfiguration callback. More...

void	setRegistry (IRegistry *pRegistry)
	Set pointer to Registry. More...

IRegistry *	registry () const
	Get pointer to Registry. More...

LinkManager *	linkMgr () const
	Retrieve Link manager. More...

unsigned char	version () const
	Retrieve version number of this object representation. More...

void	setVersion (unsigned char vsn)
	Set version number of this object representation. More...

unsigned long	refCount () const
	Return the refcount. More...

virtual std::ostream &	fillStream (std::ostream &s) const
	Fill the output stream (ASCII) More...

Public Member Functions inherited from INTuple
virtual ItemContainer &	items ()=0
	Access item container. More...

virtual const ItemContainer &	items () const =0
	Access item container (CONST) More...

virtual char *	setBuffer (char *buff)=0
	Attach data buffer. More...

virtual const char *	buffer () const =0
	Access data buffer (CONST) More...

virtual char *	buffer ()=0
	Access data buffer. More...

virtual const std::string &	title () const =0
	Object title. More...

virtual void	reset ()=0
	Reset all entries to their default values. More...

virtual const INTupleItem *	find (const std::string &name) const =0
	Find an item row of the Ntuple (CONST) More...

virtual INTupleItem *	find (const std::string &name)=0
	Find an item row of the Ntuple. More...

virtual StatusCode	add (INTupleItem *item)=0
	Add an item row to the N tuple. More...

virtual StatusCode	remove (INTupleItem *item)=0
	Remove an item row (identified by pointer) from the N tuple. More...

virtual StatusCode	remove (const std::string &name)=0
	Remove an item row (identified by name) from the N tuple. More...

virtual StatusCode	attachSelector (ISelectStatement *sel)=0
	Attach selector. More...

virtual ISelectStatement *	selector ()=0
	Access selector. More...

virtual StatusCode	write ()=0
	Write record of the NTuple (Shortcut of writeRecord) More...

virtual StatusCode	writeRecord ()=0
	Write record of the NTuple. More...

virtual StatusCode	read ()=0
	Read record of the NTuple (Shortcut of readRecord) More...

virtual StatusCode	readRecord ()=0
	Read record of the NTuple. More...

virtual StatusCode	save ()=0
	Save the NTuple. More...

virtual	~INTuple ()=default

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. More...

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. More...

StatusCode	i_item (const std::string &name, _Item< IOpaqueAddress * > *&result) const
	Locate a _Column of data to the N tuple type safe. More...

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. More...

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. More...

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. More...

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. More...

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. More...

template<class TYPE >
StatusCode	i_addObject (const std::string &name, _Item< TYPE * > *&result, const std::type_info &)

Protected Member Functions inherited from INTuple
virtual INTupleItem *	i_find (const std::string &name) const =0
	Internally used by abstract classes. More...

Additional Inherited Members
Public Types inherited from INTuple
typedef std::vector< INTupleItem * >	ItemContainer

Static Public Member Functions inherited from DataObject
static const CLID &	classID ()
	Retrieve reference to class definition structure (static access) More...

Detailed Description

Abstract base class which allows the user to interact with the actual N tuple implementation.

The class is abstract, because the template methods must be instantiated by the compiler at compile time. Otherwise the references would be unresolved.

Definition at line 370 of file NTuple.h.

Constructor & Destructor Documentation

NTuple::Tuple::~Tuple ( )

overridedefault

Standard destructor.

Member Function Documentation

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

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 743 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         index->name(),
                         TYPE(low),
                         TYPE(high),
                         array.m_ptr);
     }

template<class TYPE , class INDEX >

StatusCode NTuple::Tuple::addIndexedItem	(	const std::string &	name,
		Item< INDEX > &	index,
		Array< TYPE > &	array
	)

inline

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 814 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         index->name(),
                         Range<TYPE>::min(),
                         Range<TYPE>::max(),
                         array.m_ptr);
     }

template<class TYPE , class INDEX >

StatusCode NTuple::Tuple::addIndexedItem	(	const std::string &	name,
		Item< INDEX > &	col_index,
		long	rows,
		Matrix< TYPE > &	matrix
	)

inline

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 958 of file NTuple.h.

     {
       return i_addItem( name,
                         col_index->range().distance(),
                         rows,
                         col_index->name(),
                         Range<TYPE>::min(),
                         Range<TYPE>::max(),
                         matrix.m_ptr);
     }

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

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 1049 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         rows,
                         index->name(),
                         TYPE(low),
                         TYPE(high),
                         matrix.m_ptr);
     }

template<class TYPE >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		Item< TYPE > &	itm
	)

inline

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 554 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		Item< TYPE * > &	itm
	)

inline

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 568 of file NTuple.h.

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

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

inline

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 581 of file NTuple.h.

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

template<class TYPE , class RANGE >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		Item< TYPE > &	itm,
		const RANGE	low,
		const RANGE	high
	)

inline

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 604 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		long	dim,
		Array< TYPE > &	array
	)

inline

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 626 of file NTuple.h.

     {
       return i_addItem(name,
                        dim,
                        "",
                        Range<TYPE>::min(),
                        Range<TYPE>::max(),
                        array.m_ptr);
     }

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

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 658 of file NTuple.h.

     {
       return i_addItem(name,
                        dim,
                        "",
                        TYPE(low),
                        TYPE(high),
                        array.m_ptr);
     }

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

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 703 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         index->name(),
                         TYPE(low),
                         TYPE(high),
                         array.m_ptr);
     }

template<class TYPE , class INDEX >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		Item< INDEX > &	index,
		Array< TYPE > &	array
	)

inline

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 782 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         index->name(),
                         Range<TYPE>::min(),
                         Range<TYPE>::max(),
                         array.m_ptr);
     }

template<class TYPE >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		long	cols,
		long	rows,
		Matrix< TYPE > &	matrix
	)

inline

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 844 of file NTuple.h.

     {
       return i_addItem(name,
                        cols,
                        rows,
                        "",
                        Range<TYPE>::min(),
                        Range<TYPE>::max(),
                        matrix.m_ptr);
     }

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

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 881 of file NTuple.h.

     {
       return i_addItem(name,
                        cols,
                        rows,
                        "",
                        TYPE(low),
                        TYPE(high),
                        result.m_ptr);
     }

template<class TYPE , class INDEX >

StatusCode NTuple::Tuple::addItem	(	const std::string &	name,
		Item< INDEX > &	index,
		Matrix< TYPE > &	matrix,
		long	rows
	)

inline

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 923 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         rows,
                         index->name(),
                         Range<TYPE>::min(),
                         Range<TYPE>::max(),
                         matrix.m_ptr);
     }

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

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 1005 of file NTuple.h.

     {
       return i_addItem( name,
                         index->range().distance(),
                         rows,
                         index->name(),
                         TYPE(low),
                         TYPE(high),
                         matrix.m_ptr);
     }

template<class TYPE >

StatusCode NTuple::Tuple::i_addItem	(	const std::string &	name,
		long	,
		const std::string &	,
		TYPE	low,
		TYPE	high,
		_Item< TYPE > *&	result
	)

inlineprotected

Add a _Item of data to the N tuple.

Definition at line 435 of file NTuple.h.

                                                  {
       if ( !i_find(name) )    {
         TYPE nil;
         nil = 0;
         return add( result = _Item<TYPE>::create(this, name, typeid(TYPE), low, high, nil) );
       }
       return StatusCode::FAILURE;
     }

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
	)

inlineprotected

Add a _Item of data to the N tuple.

Definition at line 450 of file NTuple.h.

                                                   {
       if ( !i_find(name) && clID() == CLID_ColumnWiseTuple )    {
         return add( result = _Array<TYPE>::create(this,
                                                   name,
                                                   typeid(TYPE),
                                                   index,
                                                   dim,
                                                   low,
                                                   high,
                                                   TYPE(0)) );
       }
       return StatusCode::FAILURE;
     }

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
	)

inlineprotected

Add a _Item of data to the N tuple.

Definition at line 470 of file NTuple.h.

                                                    {
       if ( !i_find(name) && clID() == CLID_ColumnWiseTuple )    {
         return add( result = _Matrix<TYPE>::create(this,
                                                    name,
                                                    typeid(TYPE),
                                                    index,
                                                    dim1,
                                                    dim2,
                                                    low,
                                                    high,
                                                    TYPE(0)) );
       }
       return StatusCode::FAILURE;
     }

template<class TYPE >

StatusCode NTuple::Tuple::i_addObject	(	const std::string &	name,
		_Item< TYPE * > *&	result,
		const std::type_info &
	)

inlineprotected

Definition at line 491 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::i_item	(	const std::string &	name,
		_Item< TYPE > *&	result
	)		const

inlineprotected

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

Definition at line 374 of file NTuple.h.

                                                                            {
       try   {
         result = dynamic_cast< _Item<TYPE>* > (i_find(name));
       }
       catch (...)   {
         result = nullptr;
       }
       return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
     }

template<class TYPE >

StatusCode NTuple::Tuple::i_item	(	const std::string &	name,
		_Item< TYPE * > *&	result
	)		const

inlineprotected

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

Definition at line 385 of file NTuple.h.

                                                                             {
       try   {
         _Item<void*>* p = dynamic_cast< _Item<void*>* > (i_find(name));
         result = (_Item<TYPE*>*)p;
       }
       catch (...)   {
         result = nullptr;
       }
       return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
     }

StatusCode NTuple::Tuple::i_item	(	const std::string &	name,
		_Item< IOpaqueAddress * > *&	result
	)		const

inlineprotected

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

Definition at line 397 of file NTuple.h.

                                                                                       {
       try   {
         result = dynamic_cast< _Item<IOpaqueAddress*>* > (i_find(name));
       }
       catch (...)   {
         result = nullptr;
       }
       return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
     }

template<class TYPE >

StatusCode NTuple::Tuple::i_item	(	const std::string &	name,
		_Array< TYPE > *&	result
	)		const

inlineprotected

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

Definition at line 408 of file NTuple.h.

                                                                             {
       try   {
         if ( clID() == CLID_ColumnWiseTuple )   {
           result = dynamic_cast< _Array<TYPE>* > (i_find(name));
         }
       }
       catch (...)   {
         result = nullptr;
       }
       return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
     }

template<class TYPE >

StatusCode NTuple::Tuple::i_item	(	const std::string &	name,
		_Matrix< TYPE > *&	result
	)		const

inlineprotected

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

Definition at line 421 of file NTuple.h.

                                                                              {
       try   {
         if ( clID() == CLID_ColumnWiseTuple )   {
           result = dynamic_cast< _Matrix<TYPE>* > (i_find(name));
         }
       }
       catch (...)   {
         result = nullptr;
       }
       return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
     }

template<class TYPE >

StatusCode NTuple::Tuple::item	(	const std::string &	name,
		Item< TYPE > &	result
	)

inline

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

Definition at line 503 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::item	(	const std::string &	name,
		const Item< TYPE > &	result
	)		const

inline

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

Definition at line 509 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::item	(	const std::string &	name,
		Array< TYPE > &	result
	)

inline

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

Definition at line 516 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::item	(	const std::string &	name,
		const Array< TYPE > &	result
	)		const

inline

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

Definition at line 521 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::item	(	const std::string &	name,
		Matrix< TYPE > &	result
	)

inline

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

Definition at line 527 of file NTuple.h.

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

template<class TYPE >

StatusCode NTuple::Tuple::item	(	const std::string &	name,
		const Matrix< TYPE > &	result
	)		const

inline

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

Definition at line 534 of file NTuple.h.

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

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

GaudiKernel/GaudiKernel/NTuple.h

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation