TupleObj.h

Go to the documentation of this file.

// ============================================================================
#ifndef GAUDIALG_TUPLEOBJ_H
#define GAUDIALG_TUPLEOBJ_H 1
// ============================================================================
// Include files
// ============================================================================
// STD&STL
// ============================================================================
#include <cstddef>
#include <set>
#include <string>
#include <limits>
#include <array>
#include <functional>
#include <sstream>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/NTuple.h"
#include "GaudiKernel/VectorMap.h"
#include "GaudiKernel/SerializeSTL.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
{
    namespace detail {
      template <typename T> struct to_ {
          template <typename Arg>
          T operator()(Arg&& i) const
          { return T(std::forward<Arg>(i)); }
      };
      constexpr struct to_<float> to_float {};

      template <typename Iterator>
      using const_ref_t = typename std::add_const<typename std::iterator_traits<Iterator>::reference>::type;

    }
  // ==========================================================================
  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
    ( 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   ,
                        float              value  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name   ,
                        double             value  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string&   name  ,
                        short                value );
    // ========================================================================
    StatusCode column ( const std::string&  name  ,
                        short         value ,
                        short         minv  ,
                        short         maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned short     value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned short     value ,
                        unsigned short     minv  ,
                        unsigned short     maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        char               value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        char               value ,
                        char               minv  ,
                        char               maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned char      value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned char      value ,
                        unsigned char      minv  ,
                        unsigned char      maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        int                value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        int                value ,
                        int                minv  ,
                        int                maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned int       value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned int       value ,
                        unsigned int       minv  ,
                        unsigned int       maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        long               value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        long               value ,
                        long               minv  ,
                        long               maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned long      value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned long      value ,
                        unsigned long      minv  ,
                        unsigned long      maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        long long          value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        long long          value ,
                        long long          minv  ,
                        long long          maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned long long value );
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        unsigned long long value ,
                        unsigned long long minv  ,
                        unsigned long long maxv  );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name  ,
                        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  ,
                        bool               value );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column ( const std::string& name    ,
                        IOpaqueAddress*    address ) ;
    // ========================================================================
    StatusCode column ( IOpaqueAddress* address ) ;
    // ========================================================================
  public:
    // ========================================================================
    StatusCode fill( const char* format ... ) ;
    // =======================================================================
  public:
    // =======================================================================
    template <typename ITERATOR1,typename ITERATOR2>
    StatusCode farray ( const std::string& name          ,
                        ITERATOR1&&        first         ,
                        ITERATOR2&&        last          ,
                        const std::string& length        ,
                        size_t             maxv          )
    {
      return farray( name, detail::to_float,
                     std::forward<ITERATOR1>(first), std::forward<ITERATOR2>(last),
                     length, maxv );
    }
    // =======================================================================
    template <class DATA>
    StatusCode farray ( const std::string& name          ,
                        const DATA&        data          ,
                        const std::string& length        ,
                        const size_t       maxv          )
    { return farray ( name , std::begin(data) , std::end(data) , length , maxv  ) ; }
    // =======================================================================
    template <class FUNCTION, class ITERATOR>
    StatusCode farray ( const std::string& name          ,
                        const FUNCTION&    function      ,
                        ITERATOR           first         ,
                        ITERATOR           last          ,
                        const std::string& length        ,
                        size_t             maxv          )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

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

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

      // adjust the length
      *len = std::distance(first,last);

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

      // fill the array
      std::transform( first, last, std::begin(*var), std::cref(function) );

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <typename Iterator,
              typename Fun  = std::function<float(detail::const_ref_t<Iterator>)>,
              typename Item = std::pair<std::string,Fun>>
    StatusCode farray ( const std::vector<Item>& items ,
                        Iterator                 first ,
                        Iterator                 last  ,
                        const std::string&       length,
                        size_t                   maxv  )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

      // adjust the lenfth
      if( std::distance(first,last) > static_cast<std::ptrdiff_t>(maxv) ) {
        using GaudiUtils::details::ostream_joiner;
        std::ostringstream os;
        ostream_joiner( os, items, ",",
                        [](std::ostream& os, const Item& i) -> std::ostream&
                        { return os << i.first; } );
        Warning( "farray('" + os.str()
               + "'): array overflow, skipping extra entries").ignore() ;
        last = std::next(first, maxv) ;
      }

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

      // adjust the length
      *len = std::distance(first,last);

      // get the arrays themselves
      std::vector<FArray*> vars; vars.reserve(items.size());
      std::transform( items.begin(), items.end(), std::back_inserter(vars),
                      [&](const Item& item) { return this->fArray(item.first,len); } );
      if ( std::any_of( vars.begin(), vars.end(), [](const FArray* f) { return !f; } ) ) {
        return InvalidColumn ;
      }

      // fill the array
      size_t index = 0;
      while( first != last ) {
        auto var = vars.begin();
        auto item = items.begin();
        while ( var != vars.end() ) {
          (**var)[index] = item->second(*first);
          ++var;
          ++item;
        }
        ++index;
        ++first;
      }

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class FUNC1, class FUNC2, class Iterator>
    StatusCode farray ( const std::string&   name1         ,
                        const FUNC1&         func1         ,
                        const std::string&   name2         ,
                        const FUNC2&         func2         ,
                        Iterator&&           first         ,
                        Iterator&&           last          ,
                        const std::string&   length        ,
                        size_t               maxv          )
    {
        return farray( { { name1, std::cref(func1) },
                         { name2, std::cref(func2) } },
                       std::forward<Iterator>(first), std::forward<Iterator>(last),
                       length, maxv );
    }
    // =======================================================================
    template <class FUNC1, class FUNC2, class FUNC3, class Iterator>
    StatusCode farray ( const std::string& name1         ,
                        const FUNC1&       func1         ,
                        const std::string& name2         ,
                        const FUNC2&       func2         ,
                        const std::string& name3         ,
                        const FUNC3&       func3         ,
                        Iterator&&         first         ,
                        Iterator&&         last          ,
                        const std::string& length        ,
                        size_t             maxv          )
    {
        return farray( {{name1,std::cref(func1)},
                        {name2,std::cref(func2)},
                        {name3,std::cref(func3)}},
                        std::forward<Iterator>(first), std::forward<Iterator>(last),
                        length, maxv );
    }
    // =======================================================================
    template <class FUNC1, class FUNC2, class FUNC3, class FUNC4, class Iterator>
    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         ,
                        Iterator&&         first         ,
                        Iterator&&         last          ,
                        const std::string& length        ,
                        size_t             maxv          )
    {
        return farray( {{name1,std::cref(func1)},
                        {name2,std::cref(func2)},
                        {name3,std::cref(func3)},
                        {name4,std::cref(func4)}},
                        std::forward<Iterator>(first), std::forward<Iterator>(last),
                        length, maxv );
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class MATRIX>
    StatusCode fmatrix ( const std::string& name    ,
                         const MATRIX&      data    ,
                         size_t             rows    ,
                         const MIndex&      cols    ,
                         const std::string& length  ,
                         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 ( !len  ) { return InvalidColumn; }

      // adjust the length item
      *len = rows ;

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

      for ( size_t iCol = 0 ; iCol < cols ; ++iCol )
      {
        for ( MIndex iRow = 0 ; iRow < rows ; ++iRow )
        { (*var)[ iRow ] [ iCol ] = 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 ,
                         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 ( !len  ) { return InvalidColumn; }

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

      // get the array itself
      FMatrix* var  = fMatrix ( name , len , cols ) ;
      if ( !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 ,
                         size_t             maxv   )
    {
      if ( invalid () ) { return InvalidTuple     ; }
      if ( rowWise () ) { return InvalidOperation ; }

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

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

      // adjust the length item
      *len = std::distance(first,last);

      // get the array itself
      auto cols = std::distance(funF,funL);
      FMatrix* var  = fMatrix ( name , len , cols ) ;
      if ( !var ) { return InvalidColumn ; }

      size_t iRow = 0 ;
      for ( ; first != last ; ++first )
      {
        //
        for ( FUN fun = funF ; fun < funL ; ++fun )
        { (*var)[ iRow ] [ fun - funF ] = (*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!)
      auto length = std::distance(first,last);

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

      std::copy( first, last, std::begin(*var) );

      return StatusCode::SUCCESS ;
    }
    // =======================================================================
    template <class ARRAY>
    StatusCode array ( const std::string& name   ,
                       const ARRAY&       data   ,
                       const MIndex&      length )
    {
      using std::begin; // allow data to be eg. CLHEP::HepVector (which does not define HepVector::begin()!,
                        // in which case ADL prefers CLHEP::begin (yah! at least they (now) use a namespace)
                        // so one just to insure  double* CLHEP::begin(CLHEP::HepVector& v) { return &v[0]; }
                        // is visible when this function gets instantiated for CLHEP::HepVector...
      auto first = begin(data);
      return array( name, first, std::next( first, length ) );
    }
    // =======================================================================
    template <class ARRAY>
    StatusCode array ( const std::string& name  ,
                       const ARRAY&       data  )
    {
        using std::begin; using std::end;
        return array ( name , begin(data) , end(data) ) ;
    }
    // =======================================================================
  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 ( !var ) { return InvalidColumn ; }

      for ( size_t iCol = 0 ; iCol < cols ; ++iCol )
      {
        for ( size_t iRow = 0 ; iRow < rows ; ++iRow )
        { (*var)[iRow][iCol] = 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 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 ( !var   ) { return InvalidColumn ; }

      for ( size_t iCol = 0 ; iCol < D2 ; ++iCol )
      {
        for ( size_t iRow = 0 ; iRow < D1 ; ++iRow )
        { (*var)[iRow][iCol] = 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 )
    {
      using Info = std::pair<KEY,VALUE>;
      static const std::array< std::function<float(const Info&)>, 2>
         fns = { { [](const Info& i) { return i.first;  } ,
                   [](const Info& i) { return i.second; } } };
      return fmatrix( name,
                      std::begin(fns), std::end(fns),
                      std::begin(info), std::end(info),
                      length,maxv );
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class TYPE>
    StatusCode put
    ( const std::string& name , const TYPE*  obj ) ;
    // =======================================================================
  public:
    // =======================================================================
    StatusCode write () ;
    // =======================================================================
    const std::string&  name() const { return m_name ; }
    // =======================================================================
    const NTuple::Tuple* tuple() const  { return m_tuple ; }
    // =======================================================================
    NTuple::Tuple* tuple() { 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 ( std::string name ,
                   std::string type )
    { return m_items.emplace ( std::move(name) , std::move(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:
    // =======================================================================
    Int*     ints       ( const std::string& name ,
                          int                minv ,
                          int                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 () = delete;
    TupleObj            ( const TupleObj& ) = delete;
    TupleObj& operator= ( const TupleObj& ) = delete;
    // =======================================================================
  private:
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Bool>>   Bools;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Char>>   Chars;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<UChar>>  UChars;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Short>>  Shorts;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<UShort>> UShorts;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Int>>    Ints;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<UInt>>   UInts;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<LongLong>> LongLongs;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<ULongLong>> ULongLongs;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Float>>   Floats;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Double>>  Doubles;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<Address>> Addresses;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<FArray>>  FArrays;
    // =======================================================================
    typedef GaudiUtils::HashMap<std::string,std::unique_ptr<FMatrix>> FMatrices;
    // =======================================================================
  private:

    // =======================================================================
    std::string            m_name       ;
    // =======================================================================
    NTuple::Tuple*         m_tuple      ;
    // =======================================================================
    CLID                   m_clid       ;
    // =======================================================================
    Tuples::Type           m_type       ;
    // =======================================================================
    size_t                 m_refCount   = 0;
    // =======================================================================
    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
// ============================================================================