TupleObj.h

Go to the documentation of this file.

// $Id: TupleObj.h,v 1.23 2008/10/27 19:22:20 marcocle Exp $
// ============================================================================
// CVS tag $Name:  $, version $Revision: 1.23 $
// ============================================================================
#ifndef GAUDIALG_TUPLEOBJ_H
#define GAUDIALG_TUPLEOBJ_H 1
// ============================================================================
// Include files
// ============================================================================
// STD&STL
// ============================================================================
#include <set>
#include <string>
#include <limits>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/NTuple.h"
#include "GaudiKernel/VectorMap.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/Tuples.h"
#include "GaudiAlg/Maps.h"
// ============================================================================
// ROOT
// ============================================================================
#include "Math/Point3D.h"
#include "Math/Vector3D.h"
#include "Math/Vector4D.h"
#include "Math/SVector.h"
#include "Math/SMatrix.h"
// ============================================================================
// forward declaration
// ============================================================================
// GaudiKernel
// ============================================================================
class IOpaqueAddress   ;
// ============================================================================
// ============================================================================
namespace Tuples
{
  // ==========================================================================
  enum Type
    {
      NTUPLE  , // Analysis nTuple
      EVTCOL    // Event Collection
    };
  // ==========================================================================
  enum ErrorCodes
    {
      InvalidTuple      = 100 ,
      InvalidColumn           ,
      InvalidOperation        ,
      InvalidObject           ,
      InvalidItem             ,
      TruncateValue     = 200
    };
  // ==========================================================================
  class GAUDI_API TupleObj
  {
  public:
    // ========================================================================
    typedef NTuple::Item<bool>                  Bool      ;
    // ========================================================================
    typedef NTuple::Item<char>                  Char      ;
    // ========================================================================
    typedef NTuple::Item<unsigned char>         UChar     ;
    // ========================================================================
    typedef NTuple::Item<short>                 Short     ;
    // ========================================================================
    typedef NTuple::Item<unsigned short>        UShort    ;
    // ========================================================================
    typedef NTuple::Item<int>                   Int       ;
    // ========================================================================
    typedef NTuple::Item<unsigned int>          UInt      ;
    // ========================================================================
    typedef NTuple::Item<long long>             LongLong  ;
    // ========================================================================
    typedef NTuple::Item<unsigned long long>    ULongLong ;
    // ========================================================================
    typedef NTuple::Item<float>                 Float     ;
    // ========================================================================
    typedef NTuple::Item<double>                Double    ;
    // ========================================================================
    typedef NTuple::Item<IOpaqueAddress*>       Address   ;
    // ========================================================================
    typedef NTuple::Array<float>                FArray    ;
    // ========================================================================
    typedef NTuple::Matrix<float>               FMatrix   ;
    // ========================================================================
    // the actual type for variable size matrix indices
    typedef unsigned short                      MIndex    ;
    // ========================================================================
    // the map of all items
    typedef std::map<std::string,std::string>   ItemMap   ;
    // ========================================================================
  protected:
    // ========================================================================
    TupleObj
    ( const std::string&    name                          ,
      NTuple::Tuple*        tuple                         ,
      const CLID&           clid = CLID_ColumnWiseTuple   ,
      const Tuples::Type    type = Tuples::NTUPLE         ) ;
    // ========================================================================
  protected:
    // ========================================================================
    virtual ~TupleObj();
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name   ,
                        const float        value  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name   ,
                        const double       value  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const short          value );
    // ========================================================================
    StatusCode column ( const std::string&  name  ,
                        const short         value ,
                        const short         minv  ,
                        const short         maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned short value );
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned short value ,
                        const unsigned short minv  ,
                        const unsigned short maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const char           value );
    // ========================================================================
    StatusCode column ( const std::string&  name  ,
                        const char          value ,
                        const char          minv  ,
                        const char          maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned char  value );
    // ========================================================================
    StatusCode column ( const std::string&  name  ,
                        const unsigned char value ,
                        const unsigned char minv  ,
                        const unsigned char maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const int            value );
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const int            value ,
                        const int            minv  ,
                        const int            maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned int   value );
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned int   value ,
                        const unsigned int   minv  ,
                        const unsigned int   maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const long           value );
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const long           value ,
                        const long           minv  ,
                        const long           maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned long  value );
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const unsigned long  value ,
                        const unsigned long  minv  ,
                        const unsigned long  maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const long long      value );
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        const long long      value ,
                        const long long      minv  ,
                        const long long      maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&       name  ,
                        const unsigned long long value );
    // ========================================================================
    StatusCode column ( const std::string&       name  ,
                        const unsigned long long value ,
                        const unsigned long long minv  ,
                        const unsigned long long maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        const signed char  value )
    {
      return column
        ( name  ,
          value ,
          std::numeric_limits<signed char>::min() ,
          std::numeric_limits<signed char>::max() ) ;
    }
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        const bool         value );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&    name    ,
                        IOpaqueAddress*       address ) ;
    // ========================================================================
    StatusCode column ( IOpaqueAddress*       address ) ;
    // ========================================================================
  public:
    // ========================================================================
    StatusCode fill( const char* format ... ) ;
    // =======================================================================
  public:
    // =======================================================================
    template <class DATA>
    StatusCode farray ( const std::string& name          ,
                        DATA               first         ,
                        DATA               last          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if( first + maxv < last )
      {
        Warning( "farray('"+name+"'): array is overflow, skip extra items") ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints( length , 0 , maxv ) ;
      if( 0 == len  ) { return InvalidColumn; }

      // adjust the length item
      *len = last - first ;

      // get the array itself
      FArray* var  = fArray ( name , len ) ;
      if( 0 == var ) { return InvalidColumn ; }

      size_t index = 0 ;
      for( ; first != last ; ++first )
      { (*var)[ index ] = (float)(*first) ; ++index ; }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class DATA>
    StatusCode farray ( const std::string& name          ,
                        const DATA&        data          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    { return farray ( name , data.begin() , data.end() , length , maxv  ) ; }
    // =======================================================================
    template <class FUNCTION, class DATA>
    StatusCode farray ( const std::string& name          ,
                        const FUNCTION&    function      ,
                        DATA               first         ,
                        DATA               last          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if( first + maxv < last )
      {
        Warning("farray('"
                + name  + "'): array is overflow, skip extra entries") ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints( length , 0 , maxv ) ;
      if( 0 == len  ) { return InvalidColumn ; }

      // adjust the length
      *len = last - first ;

      // get the array itself
      FArray*  var  = fArray ( name , len ) ;
      if( 0 == var ) { return InvalidColumn ; }

      // fill the array
      size_t index = 0 ;
      for( ; first != last ; ++first )
      { (*var)[ index ] = function( *first )  ; ++index ; }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class FUNC1, class FUNC2, class DATA>
    StatusCode farray ( const std::string& name1         ,
                        const FUNC1&       func1         ,
                        const std::string& name2         ,
                        const FUNC2&       func2         ,
                        DATA               first         ,
                        DATA               last          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the lenfth
      if( first + maxv < last )
      {
        Warning("farray('"
                + name1 + ","
                + name2 + "'): array is overflow, skip extra entries").ignore() ;
        Warning("farray('"+name1+"'): array is overflow, skip extra items").ignore() ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints ( length , 0 , maxv ) ;
      if ( 0 == len  ) { return InvalidColumn ; }

      // adjust the length
      *len = last - first ;

      // get the array itself
      FArray*  var1  = fArray ( name1 , len ) ;
      if ( 0 == var1 ) { return InvalidColumn ; }

      // get the array itself
      FArray*  var2 = fArray ( name2 , len ) ;
      if ( 0 == var2 ) { return InvalidColumn ; }

      // fill the array
      size_t index = 0 ;
      for( ; first != last ; ++first )
      {
        ( *var1 ) [ index ] = func1 ( *first )  ;
        ( *var2 ) [ index ] = func2 ( *first )  ;
        ++index ;
      }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class FUNC1, class FUNC2, class FUNC3, class DATA>
    StatusCode farray ( const std::string& name1         ,
                        const FUNC1&       func1         ,
                        const std::string& name2         ,
                        const FUNC2&       func2         ,
                        const std::string& name3         ,
                        const FUNC3&       func3         ,
                        DATA               first         ,
                        DATA               last          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if( first + maxv < last )
      {
        Warning("farray('"
                + name1 + ","
                + name2 + ","
                + name3 + "'): array is overflow, skip extra entries").ignore() ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints ( length , 0 , maxv ) ;
      if( 0 == len   ) { return InvalidColumn ; }

      // adjust the length
      *len = last - first ;

      // get the array itself
      FArray*  var1  = fArray ( name1 , len ) ;
      if( 0 == var1 ) { return InvalidColumn  ; }

      // get the array itself
      FArray*  var2 = fArray ( name2 , len ) ;
      if( 0 == var2 ) { return InvalidColumn ; }

      // get the array itself
      FArray*  var3 = fArray ( name3 , len ) ;
      if( 0 == var3 ) { return InvalidColumn ; }

      // fill the array
      size_t index = 0 ;
      for( ; first != last ; ++first )
      {
        ( *var1 ) [ index ] = (float)func1 ( *first )  ;
        ( *var2 ) [ index ] = (float)func2 ( *first )  ;
        ( *var3 ) [ index ] = (float)func3 ( *first )  ;
        ++index ;
      }
      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class FUNC1, class FUNC2, class FUNC3, class FUNC4, class DATA>
    StatusCode farray ( const std::string& name1         ,
                        const FUNC1&       func1         ,
                        const std::string& name2         ,
                        const FUNC2&       func2         ,
                        const std::string& name3         ,
                        const FUNC3&       func3         ,
                        const std::string& name4         ,
                        const FUNC4&       func4         ,
                        DATA               first         ,
                        DATA               last          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if( first + maxv < last )
      {
        Warning("farray('"
                + name1 + ","
                + name2 + ","
                + name3 + ","
                + name4 + "'): array is overflow, skip extra entries").ignore() ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints ( length , 0 , maxv ) ;
      if( 0 == len  ) { return InvalidColumn ; }

      // adjust the length
      *len = last - first ;

      // get the array itself
      FArray*  var1  = fArray ( name1 , len ) ;
      if( 0 == var1 ) { return InvalidColumn ; }

      // get the array itself
      FArray*  var2 = fArray ( name2 , len ) ;
      if( 0 == var2 ) { return InvalidColumn ; }

      // get the array itself
      FArray*  var3 = fArray ( name3 , len ) ;
      if( 0 == var3 ) { return InvalidColumn ; }

      // get the array itself
      FArray*  var4 = fArray ( name4 , len ) ;
      if( 0 == var4 ) { return InvalidColumn ; }

      // fill the array
      size_t index = 0 ;
      for( ; first != last ; ++first )
      {
        ( *var1 ) [ index ] = static_cast<float> ( func1 ( *first ) );
        ( *var2 ) [ index ] = static_cast<float> ( func2 ( *first ) );
        ( *var3 ) [ index ] = static_cast<float> ( func3 ( *first ) );
        ( *var4 ) [ index ] = static_cast<float> ( func4 ( *first ) );
        ++index ;
      }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class MATRIX>
    StatusCode fmatrix ( const std::string& name    ,
                         const MATRIX&      data    ,
                         size_t             rows    ,
                         const MIndex&      cols    ,
                         const std::string& length  ,
                         const size_t       maxv    )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if ( rows >= maxv )
      {
        Warning ( "fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;
        rows = ( 0 < maxv ) ? ( maxv - 1 ) : 0 ;
      }

      // get the length item
      Int* len  = ints( length , 0 , maxv ) ;
      if ( 0 == len  ) { return InvalidColumn; }

      // adjust the length item
      *len = rows ;

      // get the array itself
      FMatrix* var  = fMatrix ( name , len  , cols ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      for ( size_t iCol = 0 ; iCol < cols ; ++iCol )
      {
        for ( MIndex iRow = 0 ; iRow < rows ; ++iRow )
        { (*var)[ iRow ] [ iCol ] = (float)(data[ iRow ][ iCol ]) ; }
      }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class DATA>
    StatusCode fmatrix ( const std::string& name   ,
                         DATA               first  ,
                         DATA               last   ,
                         const MIndex&      cols   ,
                         const std::string& length ,
                         const size_t       maxv   )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if ( first + maxv < last )
      {
        Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints( length , 0 , maxv ) ;
      if ( 0 == len  ) { return InvalidColumn; }

      // adjust the length item
      *len = last - first ;

      // get the array itself
      FMatrix* var  = fMatrix ( name , len , cols ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      size_t iRow = 0 ;
      for ( ; first != last ; ++first )
      {
        //
        for ( MIndex iCol = 0 ; iCol < cols ; ++iCol )
        { (*var)[ iRow ] [ iCol ] = (float)((*first)[ iCol ]) ; }
        //
        ++iRow ;
      }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class FUN,class DATA>
    StatusCode fmatrix ( const std::string& name   ,
                         FUN                funF   ,
                         FUN                funL   ,
                         DATA               first  ,
                         DATA               last   ,
                         const std::string& length ,
                         const size_t       maxv   )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the length
      if ( first + maxv < last )
      {
        Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items").ignore() ;
        last = first + maxv ;
      }

      // get the length item
      Int* len  = ints( length , 0 , maxv ) ;
      if ( 0 == len  ) { return InvalidColumn; }

      // adjust the length item
      *len = last - first ;

      // get the array itself
      const size_t cols = funL - funF ;
      FMatrix* var  = fMatrix ( name , len , cols ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      size_t iRow = 0 ;
      for ( ; first != last ; ++first )
      {
        //
        for ( FUN fun = funF ; fun < funL ; ++fun )
        { (*var)[ iRow ] [ fun - funF ] = (float)((*fun) ( *first )) ; }
        //
        ++iRow;
      }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class DATA>
    StatusCode array ( const std::string& name          ,
                       DATA               first         ,
                       DATA               last          )

    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // get the length (fixed!)
      const size_t length = last - first ;

      // get the array itself
      FArray* var  = fArray ( name , length ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      size_t iCol = 0 ;
      for ( ; first != last ; ++first )
      { (*var)[ iCol ] = (float)(*first) ; ++iCol ; }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class ARRAY>
    StatusCode array ( const std::string& name   ,
                       const ARRAY&       data   ,
                       const MIndex&      length )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // get the array itself
      FArray* var  = fArray ( name , length ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      for ( size_t index = 0 ; index < length ; ++index )
      { (*var)[ index ] = (float) data[index] ; }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class ARRAY>
    StatusCode array ( const std::string& name  ,
                       const ARRAY&       data  )
    { return array ( name , data.begin() , data.end() ) ; }
    // =======================================================================
  public:
    // =======================================================================
    template <class MATRIX>
    StatusCode matrix ( const std::string& name  ,
                        const MATRIX&      data  ,
                        const MIndex&      rows  ,
                        const MIndex&      cols  )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // get the matrix itself
      FMatrix* var  = fMatrix ( name , rows , cols ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      for ( size_t iCol = 0 ; iCol < cols ; ++iCol )
      {
        for ( size_t iRow = 0 ; iRow < rows ; ++iRow )
        { (*var)[iRow][iCol] = (float)(data[iRow][iCol]) ; }
      };
      return StatusCode::SUCCESS ;
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class TYPE>
    StatusCode column
    ( const std::string& name ,
      const ROOT::Math::LorentzVector<TYPE>& v )
    {
      if ( invalid() ) { return InvalidTuple ; }
      // fill all separate columns:
      StatusCode sc1 = this -> column ( name + "E" , v.E  () ) ;
      StatusCode sc2 = this -> column ( name + "X" , v.Px () ) ;
      StatusCode sc3 = this -> column ( name + "Y" , v.Py () ) ;
      StatusCode sc4 = this -> column ( name + "Z" , v.Pz () ) ;
      return
        sc1.isFailure () ? sc1 :
        sc2.isFailure () ? sc2 :
        sc3.isFailure () ? sc3 :
        sc4.isFailure () ? sc4 : StatusCode(StatusCode::SUCCESS) ;
    }
    // =======================================================================
    template <class TYPE,class TAG>
    StatusCode column
    ( const std::string& name ,
      const ROOT::Math::DisplacementVector3D<TYPE,TAG>& v )
    {
      if ( invalid() ) { return InvalidTuple ; }
      StatusCode sc1 = this -> column ( name + "X" , v.X () ) ;
      StatusCode sc2 = this -> column ( name + "Y" , v.Y () ) ;
      StatusCode sc3 = this -> column ( name + "Z" , v.Z () ) ;
      return
        sc1.isFailure () ? sc1 :
        sc2.isFailure () ? sc2 :
        sc3.isFailure () ? sc3 : StatusCode(StatusCode::SUCCESS) ;
    }
    // =======================================================================
    template <class TYPE,class TAG>
    StatusCode column
    ( const std::string& name ,
      const ROOT::Math::PositionVector3D<TYPE,TAG>& v )
    {
      if ( invalid() ) { return InvalidTuple ; }
      StatusCode sc1 = this -> column ( name + "X" , v.X () ) ;
      StatusCode sc2 = this -> column ( name + "Y" , v.Y () ) ;
      StatusCode sc3 = this -> column ( name + "Z" , v.Z () ) ;
      return
        sc1.isFailure () ? sc1 :
        sc2.isFailure () ? sc2 :
        sc3.isFailure () ? sc3 : StatusCode(StatusCode::SUCCESS) ;
    }
    // =======================================================================
    template <class TYPE,unsigned int DIM>
    StatusCode array
    ( const std::string&                   name ,
      const ROOT::Math::SVector<TYPE,DIM>& vect )
    {
      return this->array( name , vect.begin() , vect.end() ) ;
    }
    // =======================================================================
    template <class TYPE,unsigned int D1,unsigned int D2,class REP>
    StatusCode matrix
    ( const std::string&                         name ,
      const ROOT::Math::SMatrix<TYPE,D1,D2,REP>& mtrx )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // get the matrix itself
      FMatrix* var  = fMatrix ( name , (MIndex)D1 , (MIndex)D2 ) ;
      if ( 0 == var   ) { return InvalidColumn ; }

      for ( size_t iCol = 0 ; iCol < D2 ; ++iCol )
      {
        for ( size_t iRow = 0 ; iRow < D1 ; ++iRow )
        { (*var)[iRow][iCol] = (float) mtrx(iRow,iCol) ; }
      };

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class KEY, class VALUE>
    StatusCode fmatrix
    ( const std::string&                      name       ,
      const GaudiUtils::VectorMap<KEY,VALUE>& info       ,
      const std::string&                      length     ,
      const size_t                            maxv = 100 )
    {

      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      typename GaudiUtils::VectorMap<KEY,VALUE>::const_iterator begin = info.begin () ;
      typename GaudiUtils::VectorMap<KEY,VALUE>::const_iterator end   = info.end   () ;

      // adjust the length
      if ( maxv < info.size() )
      {
        Warning("fmatrix('"+name+"'): matrix is overflow, skip extra items") ;
        end = begin + maxv ;
      } ;

      // get the length item
      Int* len  = ints( length , 0 , maxv ) ;
      if ( 0 == len  ) { return InvalidColumn; }

      // adjust the length item
      *len = end - begin ;

      // get the array itself
      FMatrix* var  = fMatrix ( name , len , 2 ) ;
      if ( 0 == var ) { return InvalidColumn ; }

      size_t iRow = 0 ;
      for ( ; begin != end ; ++begin)
      {
        //
        (*var)[iRow][0] = (float) begin->first   ;
        (*var)[iRow][1] = (float) begin->second  ;
        //
        ++iRow ;
      } ;

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class TYPE>
    StatusCode put
    ( const std::string& name , const TYPE*  obj ) ;
    // =======================================================================
  public:
    // =======================================================================
    StatusCode write () ;
    // =======================================================================
    const std::string&  name() const { return m_name ; }
    // =======================================================================
    NTuple::Tuple* tuple() const  { return m_tuple ; }
    // =======================================================================
    unsigned long refCount() const { return   m_refCount ; }
    // =======================================================================
    unsigned long addRef  ()       { return ++m_refCount ; }
    // =======================================================================
    void          release () ;
    // =======================================================================
    const CLID&        clid() const { return m_clid ; }
    // =======================================================================
    Tuples::Type       type() const { return m_type ; }
    // =======================================================================
    bool columnWise() const { return CLID_ColumnWiseTuple == clid() ; }
    // =======================================================================
    bool rowWise   () const { return CLID_RowWiseTuple    == clid() ; }
    // =======================================================================
    bool evtColType() const { return Tuples::EVTCOL       == type()  ; }
    // =======================================================================
    bool valid     () const { return 0 != tuple() ; }
    // =======================================================================
    bool invalid   () const { return ! valid()    ; }
    // =======================================================================
  public:
    // =======================================================================
    bool addItem ( const std::string& name ,
                   const std::string& type )
    { return m_items.insert ( std::make_pair ( name , type ) ).second ; }
    // =======================================================================
    bool goodItem  ( const std::string& name ) const
    { return m_items.end() == m_items.find ( name ) ; }
    // =======================================================================
    const ItemMap& items() const { return m_items ; }
    // =======================================================================
  public:
    // =======================================================================
    virtual StatusCode Error
    ( const std::string& msg ,
      const StatusCode   sc  = StatusCode::FAILURE ) const = 0 ;
    // =======================================================================
    virtual StatusCode Warning
    ( const std::string& msg ,
      const StatusCode   sc  = StatusCode::FAILURE ) const = 0 ;
    // =======================================================================
  private:
    // =======================================================================
    Bool*    bools      ( const std::string& name ) ;
    // =======================================================================
    Float*   floats     ( const std::string& name ) ;
    // =======================================================================
    Double*  doubles    ( const std::string& name ) ;
    // =======================================================================
    Char*   chars     ( const std::string& name ) ;
    // =======================================================================
    Char*   chars     ( const std::string& name ,
                        const char         minv ,
                        const char         maxv ) ;
    // =======================================================================
    UChar*  uchars    ( const std::string& name ) ;
    // =======================================================================
    UChar*  uchars    ( const std::string&  name ,
                        const unsigned char minv ,
                        const unsigned char maxv ) ;
    // =======================================================================
    Short*   shorts     ( const std::string& name ) ;
    // =======================================================================
    Short*   shorts     ( const std::string& name ,
                          const short        minv ,
                          const short        maxv ) ;
    // =======================================================================
    UShort*   ushorts   ( const std::string& name ) ;
    // =======================================================================
    UShort*   ushorts   ( const std::string& name ,
                          const unsigned short minv ,
                          const unsigned short maxv ) ;
    // =======================================================================
    Int*     ints       ( const std::string& name ) ;
    // =======================================================================
    Int*     ints       ( const std::string& name ,
                          const int          minv ,
                          const int          maxv ) ;
    // =======================================================================
    UInt*     uints     ( const std::string& name ) ;
    // =======================================================================
    UInt*     uints     ( const std::string& name ,
                          const unsigned int minv ,
                          const unsigned int maxv ) ;
    // =======================================================================
    LongLong* longlongs ( const std::string& name );
    // =======================================================================
    LongLong* longlongs ( const std::string& name ,
                          const long long    minv ,
                          const long long    maxv ) ;
    // =======================================================================
    ULongLong* ulonglongs ( const std::string& name ) ;
    // =======================================================================
    ULongLong* ulonglongs ( const std::string&       name ,
                            const unsigned long long minv ,
                            const unsigned long long maxv ) ;
    // =======================================================================
    FArray*  fArray     ( const std::string& name ,
                          Int*               item ) ;
    // =======================================================================
    FArray*  fArray     ( const std::string& name ,
                          const MIndex&      rows ) ;
    // =======================================================================
    Address* addresses  ( const std::string& name ) ;
    // =======================================================================
    FMatrix* fMatrix    ( const std::string& name ,
                          Int*               item ,
                          const MIndex&      cols ) ;
    // =======================================================================
    FMatrix* fMatrix    ( const std::string& name ,
                          const MIndex&      rows ,
                          const MIndex&      cols ) ;
    // =======================================================================
  private:
    // =======================================================================
    TupleObj () ;
    // =======================================================================
    TupleObj            ( const TupleObj& ) ;
    // =======================================================================
    TupleObj& operator= ( const TupleObj& ) ;
    // =======================================================================
  private:
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Bool*>   Bools;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Char*>   Chars;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,UChar*>  UChars;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Short*>  Shorts;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,UShort*> UShorts;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Int*>    Ints;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,UInt*>   UInts;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,LongLong*> LongLongs;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,ULongLong*> ULongLongs;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Float*>   Floats;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Double*>  Doubles;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,Address*> Addresses;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,FArray*>  FArrays;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,FMatrix*> FMatrices;
    // =======================================================================
  private:
    // =======================================================================
    std::string            m_name       ;
    // =======================================================================
    NTuple::Tuple*         m_tuple      ;
    // =======================================================================
    CLID                   m_clid       ;
    // =======================================================================
    Tuples::Type           m_type       ;
    // =======================================================================
    size_t                 m_refCount   ;
    // =======================================================================
    mutable Bools          m_bools      ;
    // =======================================================================
    mutable Chars          m_chars      ;
    // =======================================================================
    mutable UChars         m_uchars     ;
    // =======================================================================
    mutable Shorts         m_shorts     ;
    // =======================================================================
    mutable UShorts        m_ushorts    ;
    // =======================================================================
    mutable Ints           m_ints       ;
    // =======================================================================
    mutable UInts          m_uints      ;
    // =======================================================================
    mutable LongLongs      m_longlongs  ;
    // =======================================================================
    mutable ULongLongs     m_ulonglongs ;
    // =======================================================================
    mutable Floats         m_floats     ;
    // =======================================================================
    mutable Doubles        m_doubles    ;
    // =======================================================================
    mutable Addresses      m_addresses  ;
    // =======================================================================
    mutable FArrays        m_farrays    ;
    // =======================================================================
    mutable FArrays        m_arraysf    ;
    // =======================================================================
    mutable FMatrices      m_fmatrices  ;
    // =======================================================================
    mutable FMatrices      m_matricesf  ;
    // =======================================================================
    ItemMap                m_items      ;
    // =======================================================================
  } ;
  // ==========================================================================
} // end of namespace Tuples
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/TuplePut.h"
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_TUPLEOBJ_H
// ============================================================================