TupleObj.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
// ============================================================================
#ifndef GAUDIALG_TUPLEOBJ_H
#define GAUDIALG_TUPLEOBJ_H 1
// ============================================================================
// Include files
// ============================================================================
// STD&STL
// ============================================================================
#include <array>
#include <cstddef>
#include <functional>
#include <limits>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/NTuple.h"
#include "GaudiKernel/SerializeSTL.h"
#include "GaudiKernel/VectorMap.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/Maps.h"
#include "GaudiAlg/Tuples.h"
// ============================================================================
// ROOT
// ============================================================================
#include "Math/Point3D.h"
#include "Math/SMatrix.h"
#include "Math/SVector.h"
#include "Math/Vector3D.h"
#include "Math/Vector4D.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 to_<float> to_float{};

    template <typename Iterator>
    using const_ref_t = std::add_const_t<typename std::iterator_traits<Iterator>::reference>;
  } // namespace detail
  // ==========================================================================
  enum Type {
    NTUPLE, // Analysis nTuple
    EVTCOL  // Event Collection
  };
  // ==========================================================================
  enum class ErrorCodes : StatusCode::code_t {
    InvalidTuple = 100,
    InvalidColumn,
    InvalidOperation,
    InvalidObject,
    InvalidItem,
    TruncateValue = 200
  };
} // namespace Tuples

STATUSCODE_ENUM_DECL( Tuples::ErrorCodes )

namespace Tuples {
  // ==========================================================================
  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 );
    // ========================================================================
  public:
    // ========================================================================
    virtual ~TupleObj();
    // ========================================================================
    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:
    // ========================================================================
    template <typename Value, typename... Args>
    StatusCode columns( Value&& value, Args&&... args ) {
      if ( sizeof...( Args ) == 0 ) return StatusCode::SUCCESS;
      std::initializer_list<StatusCode> scs{
          this->column( std::get<0>( args ), std::invoke( std::get<1>( args ), value ) )...};
      return std::accumulate( std::next( begin( scs ) ), end( scs ), *begin( scs ),
                              []( StatusCode sc, const StatusCode& i ) {
                                i.ignore();                     // make sure there are no unchecked StatusCodes...
                                return sc.isFailure() ? sc : i; // latch to the first non-success case
                              } );
    }
    // ========================================================================
  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 ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::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 ErrorCodes::InvalidColumn;

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

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

      // fill the array
      std::transform( first, last, std::begin( *var ),
                      [&]( auto&& i ) { return std::invoke( function, std::forward<decltype( i )>( i ) ); } );

      return StatusCode::SUCCESS;
    }
    // =======================================================================
    template <typename FunIterator, typename DataIterator>
    StatusCode farray_impl( FunIterator first_item, FunIterator last_item, DataIterator first, DataIterator last,
                            const std::string& length, size_t maxv ) {
      if ( invalid() ) return ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::InvalidOperation;

      // adjust the length
      if ( std::distance( first, last ) > static_cast<std::ptrdiff_t>( maxv ) ) {
        using GaudiUtils::details::ostream_joiner;
        std::ostringstream os;
        ostream_joiner( os, first_item, last_item, ",",
                        []( std::ostream& os, const auto& i ) -> decltype( auto ) { 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 ErrorCodes::InvalidColumn;

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

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

      // fill the array
      for ( size_t index = 0; first != last; ++first, ++index ) {
        auto item = first_item;
        for ( auto& var : vars ) { ( *var )[index] = std::invoke( ( item++ )->second, *first ); }
      }

      return StatusCode::SUCCESS;
    }

    template <
        typename DataIterator, template <typename, typename...> class Container = std::initializer_list,
        typename NamedFunction = std::pair<std::string, std::function<float( detail::const_ref_t<DataIterator> )>>,
        typename               = std::enable_if_t<!std::is_convertible_v<Container<NamedFunction>, std::string>>>
    StatusCode farray( const Container<NamedFunction>& funs, DataIterator first, DataIterator last,
                       const std::string& length, size_t maxv ) {
      return farray_impl( funs.begin(), funs.end(), std::forward<DataIterator>( first ),
                          std::forward<DataIterator>( last ), length, maxv );
    }

    template <typename NamedFunctions, typename DataIterator,
              typename = std::enable_if_t<!std::is_convertible_v<NamedFunctions, std::string>>>
    StatusCode farray( const NamedFunctions& funs, DataIterator first, DataIterator last, const std::string& length,
                       size_t maxv ) {
      return farray_impl( funs.begin(), funs.end(), std::forward<DataIterator>( first ),
                          std::forward<DataIterator>( last ), length, maxv );
    }
    // =======================================================================
    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 ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::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 ErrorCodes::InvalidColumn;

      // adjust the length item
      *len = rows;

      // get the array itself
      FMatrix* var = fMatrix( name, len, cols );
      if ( !var ) return ErrorCodes::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 ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::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 ErrorCodes::InvalidColumn;

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

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

      size_t iRow = 0;
      for ( ; first != last; ++first ) {
        //
        for ( MIndex iCol = 0; iCol < cols; ++iCol ) { ( *var )[iRow][iCol] = ( *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 ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::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 ErrorCodes::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 ErrorCodes::InvalidColumn;

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

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

    {
      if ( invalid() ) return ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::InvalidOperation;

      // get the length (fixed!)
      auto length = std::distance( first, last );

      // get the array itself
      FArray* var = fArray( name, length );
      if ( !var ) return ErrorCodes::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 ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::InvalidOperation;

      // get the matrix itself
      FMatrix* var = fMatrix( name, rows, cols );
      if ( !var ) return ErrorCodes::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 ) {
      return columns( v, std::make_pair( name + "E", &ROOT::Math::LorentzVector<TYPE>::E ),
                      std::make_pair( name + "X", &ROOT::Math::LorentzVector<TYPE>::Px ),
                      std::make_pair( name + "Y", &ROOT::Math::LorentzVector<TYPE>::Py ),
                      std::make_pair( name + "Z", &ROOT::Math::LorentzVector<TYPE>::Pz ) );
    }
    // =======================================================================
    template <class TYPE, class TAG>
    StatusCode column( const std::string& name, const ROOT::Math::DisplacementVector3D<TYPE, TAG>& v ) {
      return this->columns( v, std::make_pair( name + "X", &ROOT::Math::DisplacementVector3D<TYPE, TAG>::X ),
                            std::make_pair( name + "Y", &ROOT::Math::DisplacementVector3D<TYPE, TAG>::Y ),
                            std::make_pair( name + "Z", &ROOT::Math::DisplacementVector3D<TYPE, TAG>::Z ) );
    }
    // =======================================================================
    template <class TYPE, class TAG>
    StatusCode column( const std::string& name, const ROOT::Math::PositionVector3D<TYPE, TAG>& v ) {
      return this->columns( v, std::make_pair( name + "X", &ROOT::Math::PositionVector3D<TYPE, TAG>::X ),
                            std::make_pair( name + "Y", &ROOT::Math::PositionVector3D<TYPE, TAG>::Y ),
                            std::make_pair( name + "Z", &ROOT::Math::PositionVector3D<TYPE, TAG>::Z ) );
    }
    // =======================================================================
    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 ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::InvalidOperation;

      // get the matrix itself
      FMatrix* var = fMatrix( name, (MIndex)D1, (MIndex)D2 );
      if ( !var ) return ErrorCodes::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<float ( * )( const Info& ), 2> fns = {
          {[]( const Info& i ) -> float { return i.first; }, []( const Info& i ) -> float { return i.second; }}};
      return fmatrix( name, begin( fns ), end( fns ), begin( info ), 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; }
    // =======================================================================
    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 );
    // =======================================================================
    TupleObj( const TupleObj& ) = delete;
    TupleObj& operator=( const TupleObj& ) = delete;
    // =======================================================================
  private:
    // =======================================================================
    std::string m_name;
    // =======================================================================
    NTuple::Tuple* m_tuple;
    // =======================================================================
    CLID m_clid;
    // =======================================================================
    Tuples::Type m_type;
    // =======================================================================
    size_t m_refCount = 0;
    // =======================================================================
    // helper type to define the actual storage types
    template <typename T>
    using ColumnStorage = GaudiUtils::HashMap<std::string, std::unique_ptr<T>>;
    // =======================================================================
    mutable ColumnStorage<Bool> m_bools;
    // =======================================================================
    mutable ColumnStorage<Char> m_chars;
    // =======================================================================
    mutable ColumnStorage<UChar> m_uchars;
    // =======================================================================
    mutable ColumnStorage<Short> m_shorts;
    // =======================================================================
    mutable ColumnStorage<UShort> m_ushorts;
    // =======================================================================
    mutable ColumnStorage<Int> m_ints;
    // =======================================================================
    mutable ColumnStorage<UInt> m_uints;
    // =======================================================================
    mutable ColumnStorage<LongLong> m_longlongs;
    // =======================================================================
    mutable ColumnStorage<ULongLong> m_ulonglongs;
    // =======================================================================
    mutable ColumnStorage<Float> m_floats;
    // =======================================================================
    mutable ColumnStorage<Double> m_doubles;
    // =======================================================================
    mutable ColumnStorage<Address> m_addresses;
    // =======================================================================
    mutable ColumnStorage<FArray> m_farrays;
    // =======================================================================
    mutable ColumnStorage<FArray> m_arraysf;
    // =======================================================================
    mutable ColumnStorage<FMatrix> m_fmatrices;
    // =======================================================================
    mutable ColumnStorage<FMatrix> m_matricesf;
    // =======================================================================
    ItemMap m_items;
    // =======================================================================
  };
  // ==========================================================================
} // end of namespace Tuples

// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/TuplePut.h"
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_TUPLEOBJ_H