Gaudi Framework, version v23r0
Home   Generated: Mon Jan 30 2012
Public Member Functions | Protected Member Functions

NTuple::Tuple Class Reference

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

#include <NTuple.h>

Inheritance diagram for NTuple::Tuple:
Inheritance graph
[legend]
Collaboration diagram for NTuple::Tuple:
Collaboration graph
[legend]

List of all members.

Public Member Functions

virtual ~Tuple ()
 Standard destructor.
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 , 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 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 , 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 >
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 >
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 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, long rows, Matrix< TYPE > &matrix, const RANGE low, const RANGE high)
 Add an variable size Matrix of data to a column wise N tuple.

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 &)

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

Constructor & Destructor Documentation

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

Standard destructor.

Definition at line 495 of file NTuple.h.

                       {
    }

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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the size of the array.
arrayReference to the Array<TYPE> datatype, which should be connected to the N-tuple.
lowLower edge of client data values allowed to fill into the N-tuple array.
highUpper 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.

    {
      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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the size of the array.
arrayReference 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.

    {
      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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the number of data columns in the matrix
rowsNumber of data rows in the Matrix.
matrixReference 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.

    {
      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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the number of data columns in the matrix
rowsNumber of data rows in the Matrix.
matrixReference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
lowLower edge of client data values allowed to fill into the N-tuple matrix.
highUpper 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.

    {
      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:
nameName of the column in the column wise N-tuple
itmReference 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.

                                                     {
      typedef Range<TYPE> _R;
      return i_addItem(name, 1, "", _R::min(), _R::max(), itm.m_ptr);
    }
StatusCode NTuple::Tuple::addItem ( const std::string &  name,
Item< IOpaqueAddress * > &  itm 
) [inline]

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

Parameters:
nameName of the column in the column wise N-tuple
itmReference 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.

                                                               {
      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:
nameName of the column in the column wise N-tuple
itmReference to the Item<TYPE> datatype, which should be connected to the N-tuple.
lowLower edge of client data values allowed to fill into the N-tuple array.
highUpper 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.

    {
      return i_addItem( name, 1, "", TYPE(low), TYPE(high), 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:
nameName of the column in the column wise N-tuple
itmReference 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.

                                                     {
      return i_addObject(name,itm.m_ptr,typeid(TYPE));
    }
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:
nameName of the column in the column wise N-tuple
dimLength of the array to be added to the N-tuple
arrayReference to the Array<TYPE> datatype, which should be connected to the N-tuple.
lowLower edge of client data values allowed to fill into the N-tuple array.
highUpper 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.

    {
      return i_addItem(name,
                       dim,
                       "",
                       TYPE(low),
                       TYPE(high),
                       array.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:
nameName of the column in the column wise N-tuple
dimLength of the array to be added to the N-tuple
arrayReference 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.

    {
      return i_addItem(name,
                       dim,
                       "",
                       Range<TYPE>::min(),
                       Range<TYPE>::max(),
                       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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the size of the array.
arrayReference to the Array<TYPE> datatype, which should be connected to the N-tuple.
lowLower edge of client data values allowed to fill into the N-tuple array.
highUpper 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.

    {
      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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the size of the array.
arrayReference 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.

    {
      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:
nameName of the column in the column wise N-tuple
colsNumber of data columns in the Matrix.
rowsNumber of data rows in the Matrix.
matrixReference 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.

    {
      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:
nameName of the column in the column wise N-tuple
colsNumber of data columns in the Matrix.
rowsNumber of data rows in the Matrix.
matrixReference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
lowLower edge of client data values allowed to fill into the N-tuple matrix.
highUpper 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.

    {
      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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the number of data columns in the matrix
matrixReference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
rowsNumber of data rows in the Matrix.
Returns:
StatusCode indicating success or failure.

Definition at line 918 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:
nameName of the column in the column wise N-tuple
indexReference to the scalar index column used to determine the number of data columns in the matrix
matrixReference to the Matrix<TYPE> datatype, which should be connected to the N-tuple.
rowsNumber of data rows in the Matrix.
lowLower edge of client data values allowed to fill into the N-tuple matrix.
highUpper 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.

    {
      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  dim1,
long  dim2,
const std::string &  index,
TYPE  low,
TYPE  high,
_Matrix< TYPE > *&  result 
) [inline, protected]

Add a _Item of data to the N tuple.

Definition at line 465 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_addItem ( const std::string &  name,
long  ,
const std::string &  ,
TYPE  low,
TYPE  high,
_Item< TYPE > *&  result 
) [inline, protected]

Add a _Item of data to the N tuple.

Definition at line 430 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 
) [inline, protected]

Add a _Item of data to the N tuple.

Definition at line 445 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_addObject ( const std::string &  name,
_Item< TYPE * > *&  result,
const std::type_info &   
) [inline, protected]

Definition at line 486 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,
_Array< TYPE > *&  result 
) const [inline, protected]

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

Definition at line 403 of file NTuple.h.

                                                                            {
      try   {
        if ( clID() == CLID_ColumnWiseTuple )   {
          result = dynamic_cast< _Array<TYPE>* > (i_find(name));
        }
      }
      catch (...)   {
        result = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Item< IOpaqueAddress * > *&  result 
) const [inline, protected]

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

Definition at line 392 of file NTuple.h.

                                                                                      {
      try   {
        result = dynamic_cast< _Item<IOpaqueAddress*>* > (i_find(name));
      }
      catch (...)   {
        result = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
template<class TYPE >
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Item< TYPE * > *&  result 
) const [inline, protected]

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

Definition at line 380 of file NTuple.h.

                                                                            {
      try   {
        _Item<void*>* p = dynamic_cast< _Item<void*>* > (i_find(name));
        result = (_Item<TYPE*>*)p;
      }
      catch (...)   {
        result = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
template<class TYPE >
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Matrix< TYPE > *&  result 
) const [inline, protected]

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

Definition at line 416 of file NTuple.h.

                                                                             {
      try   {
        if ( clID() == CLID_ColumnWiseTuple )   {
          result = dynamic_cast< _Matrix<TYPE>* > (i_find(name));
        }
      }
      catch (...)   {
        result = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
template<class TYPE >
StatusCode NTuple::Tuple::i_item ( const std::string &  name,
_Item< TYPE > *&  result 
) const [inline, protected]

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

Definition at line 369 of file NTuple.h.

                                                                           {
      try   {
        result = dynamic_cast< _Item<TYPE>* > (i_find(name));
      }
      catch (...)   {
        result = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
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 504 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 529 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 511 of file NTuple.h.

    {
      return i_item(name, result.m_ptr);
    }
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 498 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 522 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 516 of file NTuple.h.

    {
      return i_item(name, result.m_ptr);
    }
The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Generated at Mon Jan 30 2012 13:53:36 for Gaudi Framework, version v23r0 by Doxygen version 1.7.2 written by Dimitri van Heesch, © 1997-2004