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 <fmt/format.h>
#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:
    // ========================================================================
    using Bool      = NTuple::Item<bool>;
    using Char      = NTuple::Item<char>;
    using UChar     = NTuple::Item<unsigned char>;
    using Short     = NTuple::Item<short>;
    using UShort    = NTuple::Item<unsigned short>;
    using Int       = NTuple::Item<int>;
    using UInt      = NTuple::Item<unsigned int>;
    using LongLong  = NTuple::Item<long long>;
    using ULongLong = NTuple::Item<unsigned long long>;
    using Float     = NTuple::Item<float>;
    using Double    = NTuple::Item<double>;
    using Address   = NTuple::Item<IOpaqueAddress*>;
    using FArray    = NTuple::Array<float>;
    using FMatrix   = NTuple::Matrix<float>;
    // ========================================================================
    // the actual type for variable size matrix indices
    typedef unsigned short MIndex;
    // ========================================================================
    // the map of all items
    typedef std::map<std::string, std::string, std::less<>> 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( std::string_view name, float value );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, double value );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, short value );
    // ========================================================================
    StatusCode column( std::string_view name, short value, short minv, short maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, unsigned short value );
    // ========================================================================
    StatusCode column( std::string_view name, unsigned short value, unsigned short minv, unsigned short maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, char value );
    // ========================================================================
    StatusCode column( std::string_view name, char value, char minv, char maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, unsigned char value );
    // ========================================================================
    StatusCode column( std::string_view name, unsigned char value, unsigned char minv, unsigned char maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, int value );
    // ========================================================================
    StatusCode column( std::string_view name, int value, int minv, int maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, unsigned int value );
    // ========================================================================
    StatusCode column( std::string_view name, unsigned int value, unsigned int minv, unsigned int maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, long value );
    // ========================================================================
    StatusCode column( std::string_view name, long value, long minv, long maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, unsigned long value );
    // ========================================================================
    StatusCode column( std::string_view name, unsigned long value, unsigned long minv, unsigned long maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, long long value );
    // ========================================================================
    StatusCode column( std::string_view name, long long value, long long minv, long long maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, unsigned long long value );
    // ========================================================================
    StatusCode column( std::string_view name, unsigned long long value, unsigned long long minv,
                       unsigned long long maxv );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, signed char value ) {
      return column( name, value, std::numeric_limits<signed char>::min(), std::numeric_limits<signed char>::max() );
    }
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view name, bool value );
    // ========================================================================
  public:
    // ========================================================================
    StatusCode column( std::string_view 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:
    // ========================================================================
    template <typename Arg, typename... Args>
    StatusCode fill( std::string_view fmt, Arg arg, Args... args ) {
      constexpr auto separators = " ,;";
      // split into token, and remainder
      auto token = fmt.substr( 0, fmt.find_first_of( separators ) );
      fmt.remove_prefix( std::min( token.size() + 1, fmt.size() ) );
 
      if ( !token.empty() ) {
        // check the underlying tuple
        if ( invalid() ) return ErrorCodes::InvalidTuple;
        return column( token, arg ).andThen( [&] {
          if constexpr ( sizeof...( Args ) != 0 ) { return fill( fmt, args... ); }
          // no more args to deal with -- so check that there is nothing usefull left in fmt, and if so, call it a
          // success...
          if ( fmt.find_first_not_of( separators ) != std::string_view::npos )
            throw std::runtime_error{ "TupleObj::fill: bad format -- too few arguments for specified format" };
          return StatusCode{ StatusCode::SUCCESS };
        } );
      } else if ( !fmt.empty() ) {
        // got a separator at the front of fmt -- try again now that it is removed from fmt...
        return fill( fmt, arg, args... );
      } else {
        // empty token, and nothing left in fmt -- but we still where called with (at least) one argument...
        throw std::runtime_error{ "TupleObj::fill: bad format -- too many arguments for specified format" };
        return StatusCode::SUCCESS;
      }
    }
 
    // =======================================================================
  public:
    // =======================================================================
    template <typename ITERATOR1, typename ITERATOR2>
    StatusCode farray( std::string_view name, ITERATOR1&& first, ITERATOR2&& last, std::string_view 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( std::string_view name, const DATA& data, std::string_view length, const size_t maxv ) {
      return farray( name, std::begin( data ), std::end( data ), length, maxv );
    }
    // =======================================================================
    template <class FUNCTION, class ITERATOR>
    StatusCode farray( std::string_view name, const FUNCTION& function, ITERATOR first, ITERATOR last,
                       std::string_view 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( fmt::format( "farray('{}'): array is overflow, skip extra entries", name ) )
            .ignore( /* AUTOMATICALLY ADDED FOR gaudi/Gaudi!763 */ );
        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,
                            std::string_view 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_view, std::function<float( detail::const_ref_t<DataIterator> )>>,
        typename               = std::enable_if_t<!std::is_convertible_v<Container<NamedFunction>, std::string_view>>>
    StatusCode farray( const Container<NamedFunction>& funs, DataIterator first, DataIterator last,
                       std::string_view 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_view>>>
    StatusCode farray( const NamedFunctions& funs, DataIterator first, DataIterator last, std::string_view 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( std::string_view name1, const FUNC1& func1, std::string_view name2, const FUNC2& func2,
                       Iterator&& first, Iterator&& last, std::string_view 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( std::string_view name1, const FUNC1& func1, std::string_view name2, const FUNC2& func2,
                       std::string_view name3, const FUNC3& func3, Iterator&& first, Iterator&& last,
                       std::string_view 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( std::string_view name1, const FUNC1& func1, std::string_view name2, const FUNC2& func2,
                       std::string_view name3, const FUNC3& func3, std::string_view name4, const FUNC4& func4,
                       Iterator&& first, Iterator&& last, std::string_view 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( std::string_view name, const MATRIX& data, size_t rows, const MIndex& cols,
                        std::string_view length, size_t maxv ) {
      if ( invalid() ) return ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::InvalidOperation;
 
      // adjust the length
      if ( rows >= maxv ) {
        Warning( fmt::format( "fmatrix('{}'): matrix is overflow, skip extra items", name ) ).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( std::string_view name, DATA first, DATA last, const MIndex& cols, std::string_view length,
                        size_t maxv ) {
      if ( invalid() ) return ErrorCodes::InvalidTuple;
      if ( rowWise() ) return ErrorCodes::InvalidOperation;
 
      // adjust the length
      if ( first + maxv < last ) {
        Warning( fmt::format( "fmatrix('{}'): matrix is overflow, skip extra items", name ) ).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( std::string_view name, FUN funF, FUN funL, DATA first, DATA last, std::string_view 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( fmt::format( "fmatrix('{}'): matrix is overflow, skip extra items", name ) ).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( std::string_view 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( std::string_view 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( std::string_view name, const ARRAY& data ) {
      using std::begin;
      using std::end;
      return array( name, begin( data ), end( data ) );
    }
    // =======================================================================
  public:
    // =======================================================================
    template <class MATRIX>
    StatusCode matrix( std::string_view 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( std::string_view name, const ROOT::Math::LorentzVector<TYPE>& v ) {
      return columns( v, std::pair{ fmt::format( "{}E", name ), &ROOT::Math::LorentzVector<TYPE>::E },
                      std::pair{ fmt::format( "{}X", name ), &ROOT::Math::LorentzVector<TYPE>::Px },
                      std::pair{ fmt::format( "{}Y", name ), &ROOT::Math::LorentzVector<TYPE>::Py },
                      std::pair{ fmt::format( "{}Z", name ), &ROOT::Math::LorentzVector<TYPE>::Pz } );
    }
    // =======================================================================
    template <class TYPE, class TAG>
    StatusCode column( std::string_view name, const ROOT::Math::DisplacementVector3D<TYPE, TAG>& v ) {
      return this->columns( v, std::pair{ fmt::format( "{}X", name ), &ROOT::Math::DisplacementVector3D<TYPE, TAG>::X },
                            std::pair{ fmt::format( "{}Y", name ), &ROOT::Math::DisplacementVector3D<TYPE, TAG>::Y },
                            std::pair{ fmt::format( "{}Z", name ), &ROOT::Math::DisplacementVector3D<TYPE, TAG>::Z } );
    }
    // =======================================================================
    template <class TYPE, class TAG>
    StatusCode column( std::string_view name, const ROOT::Math::PositionVector3D<TYPE, TAG>& v ) {
      return this->columns( v, std::pair{ fmt::format( "{}X", name ), &ROOT::Math::PositionVector3D<TYPE, TAG>::X },
                            std::pair{ fmt::format( "{}Y", name ), &ROOT::Math::PositionVector3D<TYPE, TAG>::Y },
                            std::pair{ fmt::format( "{}Z", name ), &ROOT::Math::PositionVector3D<TYPE, TAG>::Z } );
    }
    // =======================================================================
    template <class TYPE, unsigned int D1, unsigned int D2, class REP>
    StatusCode matrix( std::string_view 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( std::string_view name, const GaudiUtils::VectorMap<KEY, VALUE>& info, std::string_view 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( std::string_view 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( std::string_view 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( std::string_view name, int minv, int maxv );
    // =======================================================================
    FArray* fArray( std::string_view name, Int* item );
    // =======================================================================
    FArray* fArray( std::string_view name, const MIndex& rows );
    // =======================================================================
    Address* addresses( std::string_view name );
    // =======================================================================
    FMatrix* fMatrix( std::string_view name, Int* item, const MIndex& cols );
    // =======================================================================
    FMatrix* fMatrix( std::string_view 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>
    class ColumnStorage {
      std::unordered_map<std::string_view, std::pair<T, std::string>> m_map;
 
    public:
      using element_type = T;
      T* find( std::string_view sv ) {
        auto i = m_map.find( sv );
        return i != m_map.end() ? &i->second.first : nullptr;
      }
      T*                  end() { return nullptr; }
      std::pair<T*, bool> emplace( std::string_view k, T v = T{} ) {
        // tricky way to insert a string_view key which points to the
        // string contained in the mapped type... all just to make find(string_view) work in C++17...
        auto [i, b] = m_map.try_emplace( k, std::move( v ), std::string{ k } );
        if ( !b ) return { static_cast<T*>( nullptr ), false };
        auto nh  = m_map.extract( i );
        nh.key() = nh.mapped().second; // "re-point" key to the string contained value_type
        auto r   = m_map.insert( std::move( nh ) );
        return { &r.position->second.first, r.inserted };
      }
    };
 
    // =======================================================================
    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