NTuple.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/DataObject.h>
#include <GaudiKernel/DataTypeInfo.h>
#include <GaudiKernel/INTuple.h>
#include <GaudiKernel/IOpaqueAddress.h>
#include <GaudiKernel/SmartDataPtr.h>
#include <algorithm>
#include <cfloat>
#include <limits>
#include <stdexcept>
#include <string>
 
class NTupleFile;
class NTupleDirectory;

namespace NTuple {
  // local forward declarations
  template <class TYP>
  class Range;
  template <class TYP>
  class _Data;
  template <class TYP>
  class _Item;
  template <class TYP>
  class _Array;
  template <class TYP>
  class _Matrix;
  template <class TYP>
  class _Accessor;
  template <class TYP>
  class Item;
  template <class TYP>
  class Array;
  template <class TYP>
  class Matrix;

  template <class TYP>
  class Range {
    /*const*/ TYP m_lower;
    /*const*/ TYP m_upper;
 
  public:
    Range( TYP low, TYP upper ) : m_lower( std::move( low ) ), m_upper( std::move( upper ) ) {}
    Range( const Range<TYP>& copy ) : m_lower( copy.m_lower ), m_upper( copy.m_upper ) {}
    Range& operator=( const Range<TYP>& copy ) {
      m_lower = copy.m_lower;
      m_upper = copy.m_upper;
      return *this;
    }

    virtual ~Range() = default;
    TYP lower() const { return m_lower; }
    TYP upper() const { return m_upper; }
    TYP distance() const { return m_upper - m_lower; } // cppcheck-suppress CastIntegerToAddressAtReturn
    static TYP min() { return std::numeric_limits<TYP>::min(); }
    static TYP max() { return std::numeric_limits<TYP>::max(); }
  };
 
  template <>
  class Range<bool> {
  public:
    Range( const bool /* low */, const bool /* upper */ ) {}
    Range( const Range<bool>& /* copy */ ) {}
    virtual ~Range() = default;
    bool lower() const { return false; }
    bool upper() const { return true; }
    bool distance() const { return true; }
    static bool min() { return false; }
    static bool max() { return true; }
  };
 
  template <>
  inline IOpaqueAddress* Range<IOpaqueAddress*>::min() {
    return (IOpaqueAddress*)0x0;
  }
  template <>
  inline IOpaqueAddress* Range<IOpaqueAddress*>::max() {
    return (IOpaqueAddress*)0xffffffff;
  }

  template <class TYP>
  class GAUDI_API _Data : virtual public INTupleItem {
  protected:
    TYP* m_buffer = nullptr;
 
  public:
    typedef Range<TYP> ItemRange;
    virtual void setDefault( const TYP d ) = 0; // cppcheck-suppress passedByValue; small type
    virtual const ItemRange& range() const = 0;
  };

  template <class TYP>
  class GAUDI_API _Item : virtual public _Data<TYP> {
  public:
    static _Item* create( INTuple* tup, const std::string& name, const std::type_info& info, TYP min, TYP max,
                          TYP def );
    template <class T>
    _Item<TYP>& operator=( const _Item<T>& copy ) {
      *this->m_buffer = copy.get();
      return *this;
    }

    void set( const TYP& item ) { *this->m_buffer = item; }
    virtual TYP get() const { return *this->m_buffer; }
  };

  template <class TYP>
  class GAUDI_API _Array : virtual public _Data<TYP> {
  public:
    static _Array* create( INTuple* tup, const std::string& name, const std::type_info& info, const std::string& index,
                           long len, TYP min, TYP max, TYP def );
    template <class T>
    _Array<TYP>& operator=( const _Array<T>& copy ) {
      long len = this->length();
      if ( len == copy.length() ) {
        const T* source = (const T*)copy.buffer();
        std::copy_n( source, len, this->m_buffer );
        return *this;
      }
      throw std::out_of_range( "N-tuple matrix cannot be copied! The index range does not match!" );
      return *this;
    }

    const TYP& data( long i ) const { return this->m_buffer[i]; }
    TYP& data( long i ) { return this->m_buffer[i]; }
 
    TYP* begin() { return this->m_buffer; }
    TYP* end() { return this->m_buffer + this->length(); }
  };

  template <class TYP>
  class GAUDI_API _Matrix : virtual public _Data<TYP> {
  protected:
    long m_rows;
 
  public:
    static _Matrix* create( INTuple* tup, const std::string& name, const std::type_info& info, const std::string& index,
                            long ncol, long nrow, TYP min, TYP max, TYP def );
    template <class T>
    _Matrix<TYP>& operator=( const _Matrix<T>& copy ) {
      long len = this->length();
      if ( len == copy.length() ) {
        const T* source = (const T*)copy.buffer();
        std::copy_n( source, len, this->m_buffer );
        return *this;
      }
      throw std::out_of_range( "N-tuple matrix cannot be copied! The index range does not match!" );
      return *this;
    }

    TYP* column( long i ) { return this->m_buffer + i * m_rows; }
    const TYP* column( long i ) const { return this->m_buffer + i * m_rows; }
  };

  template <class TYP>
  class _Accessor {
    friend class Tuple;
 
  private:
    _Accessor<TYP>& operator=( const _Accessor<TYP>& ) = delete;
 
  protected:
    mutable TYP* m_ptr = nullptr;
 
  public:
    _Accessor() = default;
    virtual ~_Accessor() = default;
    _Accessor( const _Accessor& ) = default;
    bool operator!() const { return m_ptr != 0; }
    operator const void*() const { return m_ptr; }
    TYP* operator->() { return m_ptr; }
    const TYP* operator->() const { return m_ptr; }
    const Range<TYP>& range() const { return m_ptr->range(); }
  };

  template <class TYP>
  class Item : virtual public _Accessor<_Item<TYP>> {
    typedef Item<TYP> _My;
 
  public:
    Item() = default;
    operator const TYP() const { return this->m_ptr->get(); }
    TYP operator*() { return this->m_ptr->get(); }
    const TYP operator*() const { return this->m_ptr->get(); }
    // Arithmetic operators defined on NTuple column entries
    Item& operator++() { return *this += TYP( 1 ); }
    Item& operator++( int ) { return *this += TYP( 1 ); }
    Item& operator--() { return *this -= TYP( 1 ); }
    Item& operator--( int ) { return *this -= TYP( 1 ); }
    Item& operator=( const TYP data ) {
      this->m_ptr->set( data );
      return *this;
    }

    template <class T>
    Item& operator=( const Item<T>& data ) {
      this->m_ptr->set( data->get() );
      return *this;
    }
    Item<TYP>& operator+=( const TYP data ) {
      this->m_ptr->set( this->m_ptr->get() + data );
      return *this;
    }
    Item<TYP>& operator-=( const TYP data ) {
      this->m_ptr->set( this->m_ptr->get() - data );
      return *this;
    }
    Item<TYP>& operator*=( const TYP data ) {
      this->m_ptr->set( this->m_ptr->get() * data );
      return *this;
    }
    Item<TYP>& operator/=( const TYP data ) {
      this->m_ptr->set( this->m_ptr->get() / data );
      return *this;
    }
  };

  template <>
  class Item<bool> : virtual public _Accessor<_Item<bool>> {
    typedef Item<bool> _My;
 
  public:
    Item() = default;
    operator bool() const { return this->m_ptr->get(); }
    Item& operator=( const bool data ) {
      this->m_ptr->set( data );
      return *this;
    }

    template <class T>
    Item& operator=( const Item<T>& data ) {
      this->m_ptr->set( data->get() );
      return *this;
    }
  };

  template <class TYP>
  class Array : virtual public _Accessor<_Array<TYP>> {
  public:
    Array() = default;
    template <class T>
    Array& operator=( const Array<T>& copy ) {
      *( this->m_ptr ) = *( copy.operator->() );
      return *this;
    }

    template <class T>
    TYP& operator[]( const T i ) {
      return this->m_ptr->data( i );
    }

    template <class T>
    const TYP& operator[]( const T i ) const {
      return this->m_ptr->data( i );
    }
 
    TYP* begin() { return this->m_ptr->begin(); }
    TYP* end() { return this->m_ptr->end(); }
  };

  template <class TYP>
  class Matrix : virtual public _Accessor<_Matrix<TYP>> {
  public:
    Matrix() = default;
    template <class T>
    Matrix& operator=( const Matrix<T>& copy ) {
      *( this->m_ptr ) = *( copy.operator->() );
      return *this;
    }

    template <class T>
    TYP* operator[]( const T i ) {
      return this->m_ptr->column( i );
    }

    template <class T>
    const TYP* operator[]( const T i ) const {
      return this->m_ptr->column( i );
    }
  };

  class Tuple : public DataObject, virtual public INTuple {
 
  protected:
    template <class TYPE>
    StatusCode i_item( const std::string& name, _Item<TYPE>*& result ) const {
      try {
        result = dynamic_cast<_Item<TYPE>*>( i_find( name ) );
      } catch ( ... ) { result = nullptr; }
      return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
    }

    template <class TYPE>
    StatusCode i_item( const std::string& name, _Item<TYPE*>*& result ) const {
      try {
        _Item<void*>* p = dynamic_cast<_Item<void*>*>( i_find( name ) );
        result          = (_Item<TYPE*>*)p;
      } catch ( ... ) { result = nullptr; }
      return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
    }

    StatusCode i_item( const std::string& name, _Item<IOpaqueAddress*>*& result ) const {
      try {
        result = dynamic_cast<_Item<IOpaqueAddress*>*>( i_find( name ) );
      } catch ( ... ) { result = nullptr; }
      return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
    }

    template <class TYPE>
    StatusCode i_item( const std::string& name, _Array<TYPE>*& result ) const {
      try {
        if ( clID() == CLID_ColumnWiseTuple ) { result = dynamic_cast<_Array<TYPE>*>( i_find( name ) ); }
      } catch ( ... ) { result = nullptr; }
      return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
    }

    template <class TYPE>
    StatusCode i_item( const std::string& name, _Matrix<TYPE>*& result ) const {
      try {
        if ( clID() == CLID_ColumnWiseTuple ) { result = dynamic_cast<_Matrix<TYPE>*>( i_find( name ) ); }
      } catch ( ... ) { result = nullptr; }
      return result ? StatusCode::SUCCESS : StatusCode::FAILURE;
    }

    template <class TYPE>
    StatusCode i_addItem( const std::string& name, long, const std::string&, TYPE low, TYPE high,
                          _Item<TYPE>*& result ) {
      if ( !i_find( name ) ) {
        TYPE nil;
        nil = 0;
        return add( result = _Item<TYPE>::create( this, name, typeid( TYPE ), low, high, nil ) );
      }
      return StatusCode::FAILURE;
    }

    template <class TYPE>
    StatusCode i_addItem( const std::string& name, long dim, const std::string& index, TYPE low, TYPE high,
                          _Array<TYPE>*& result ) {
      if ( !i_find( name ) && clID() == CLID_ColumnWiseTuple ) {
        return add( result = _Array<TYPE>::create( this, name, typeid( TYPE ), index, dim, low, high, TYPE( 0 ) ) );
      }
      return StatusCode::FAILURE;
    }

    template <class TYPE>
    StatusCode i_addItem( const std::string& name, long dim1, long dim2, const std::string& index, TYPE low, TYPE high,
                          _Matrix<TYPE>*& result ) {
      if ( !i_find( name ) && clID() == CLID_ColumnWiseTuple ) {
        return add( result =
                        _Matrix<TYPE>::create( this, name, typeid( TYPE ), index, dim1, dim2, low, high, TYPE( 0 ) ) );
      }
      return StatusCode::FAILURE;
    }
    template <class TYPE>
    StatusCode i_addObject( const std::string& name, _Item<TYPE*>*& result, const std::type_info& /* typ */ ) {
      if ( !i_find( name ) && clID() == CLID_ColumnWiseTuple ) {
        return add( result = (_Item<TYPE*>*)_Item<void*>::create( this, name, typeid( TYPE ), 0, 0, 0 ) );
      }
      return StatusCode::FAILURE;
    }
 
  public:
    template <class TYPE>
    StatusCode item( const std::string& name, Item<TYPE>& result ) {
      return i_item( name, result.m_ptr );
    }

    template <class TYPE>
    StatusCode item( const std::string& name, const Item<TYPE>& result ) const {
      return i_item( name, result.m_ptr );
    }

    template <class TYPE>
    StatusCode item( const std::string& name, Array<TYPE>& result ) {
      return i_item( name, result.m_ptr );
    }

    template <class TYPE>
    StatusCode item( const std::string& name, const Array<TYPE>& result ) const {
      return i_item( name, result.m_ptr );
    }

    template <class TYPE>
    StatusCode item( const std::string& name, Matrix<TYPE>& result ) {
      return i_item( name, result.m_ptr );
    }

    template <class TYPE>
    StatusCode item( const std::string& name, const Matrix<TYPE>& result ) const {
      return i_item( name, result.m_ptr );
    }

    template <class TYPE>
    StatusCode addItem( const std::string& name, Item<TYPE>& itm ) {
      typedef Range<TYPE> _R;
      return i_addItem( name, 1, "", _R::min(), _R::max(), itm.m_ptr );
    }

    template <class TYPE>
    StatusCode addItem( const std::string& name, Item<TYPE*>& itm ) {
      return i_addObject( name, itm.m_ptr, typeid( TYPE ) );
    }

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

    template <class TYPE, class RANGE>
    StatusCode addItem( const std::string& name, Item<TYPE>& itm, const RANGE low, const RANGE high ) {
      return i_addItem( name, 1, "", TYPE( low ), TYPE( high ), itm.m_ptr );
    }

    template <class TYPE>
    StatusCode addItem( const std::string& name, long dim, Array<TYPE>& array ) {
      return i_addItem( name, dim, "", Range<TYPE>::min(), Range<TYPE>::max(), array.m_ptr );
    }

    template <class TYPE, class RANGE>
    StatusCode addItem( const std::string& name, long dim, Array<TYPE>& array, const RANGE low, const RANGE high ) {
      return i_addItem( name, dim, "", TYPE( low ), TYPE( high ), array.m_ptr );
    }

    template <class TYPE, class INDEX, class RANGE>
    StatusCode addItem( const std::string& name, Item<INDEX>& index, Array<TYPE>& array, const RANGE low,
                        const RANGE high ) {
      return i_addItem( name, index->range().distance(), index->name(), TYPE( low ), TYPE( high ), array.m_ptr );
    }

    template <class TYPE, class INDEX, class RANGE>
    StatusCode addIndexedItem( const std::string& name, Item<INDEX>& index, Array<TYPE>& array, const RANGE low,
                               const RANGE high ) {
      return i_addItem( name, index->range().distance(), index->name(), TYPE( low ), TYPE( high ), array.m_ptr );
    }

    template <class TYPE, class INDEX>
    StatusCode addItem( const std::string& name, Item<INDEX>& index, Array<TYPE>& array ) {
      return i_addItem( name, index->range().distance(), index->name(), Range<TYPE>::min(), Range<TYPE>::max(),
                        array.m_ptr );
    }

    template <class TYPE, class INDEX>
    StatusCode addIndexedItem( const std::string& name, Item<INDEX>& index, Array<TYPE>& array ) {
      return i_addItem( name, index->range().distance(), index->name(), Range<TYPE>::min(), Range<TYPE>::max(),
                        array.m_ptr );
    }

    template <class TYPE>
    StatusCode addItem( const std::string& name, long cols, long rows, Matrix<TYPE>& matrix ) {
      return i_addItem( name, cols, rows, "", Range<TYPE>::min(), Range<TYPE>::max(), matrix.m_ptr );
    }

    template <class TYPE, class RANGE>
    StatusCode addItem( const std::string& name, long cols, long rows, Matrix<TYPE>& result, const RANGE low,
                        const RANGE high ) {
      return i_addItem( name, cols, rows, "", TYPE( low ), TYPE( high ), result.m_ptr );
    }

    template <class TYPE, class INDEX>
    StatusCode addItem( const std::string& name, Item<INDEX>& index, Matrix<TYPE>& matrix, long rows ) {
      return i_addItem( name, index->range().distance(), rows, index->name(), Range<TYPE>::min(), Range<TYPE>::max(),
                        matrix.m_ptr );
    }

    template <class TYPE, class INDEX>
    StatusCode addIndexedItem( const std::string& name, Item<INDEX>& col_index, long rows, Matrix<TYPE>& matrix ) {
      return i_addItem( name, col_index->range().distance(), rows, col_index->name(), Range<TYPE>::min(),
                        Range<TYPE>::max(), matrix.m_ptr );
    }

    template <class TYPE, class INDEX, class RANGE>
    StatusCode addItem( const std::string& name, Item<INDEX>& index, Matrix<TYPE>& matrix, long rows, const RANGE low,
                        const RANGE high ) {
      return i_addItem( name, index->range().distance(), rows, index->name(), TYPE( low ), TYPE( high ), matrix.m_ptr );
    }

    template <class TYPE, class INDEX, class RANGE>
    StatusCode addIndexedItem( const std::string& name, Item<INDEX>& index, long rows, Matrix<TYPE>& matrix,
                               const RANGE low, const RANGE high ) {
      return i_addItem( name, index->range().distance(), rows, index->name(), TYPE( low ), TYPE( high ), matrix.m_ptr );
    }
  };

  struct Directory : DataObject {
    static const CLID& classID() { return CLID_NTupleDirectory; }
    const CLID& clID() const override { return classID(); }
  };

  class File : public Directory {
  protected:
    std::string m_name;
    std::string m_logName;
    long m_type = 0;
    bool m_isOpen = false;
 
  public:
    File() = default;
    File( long type, std::string name, std::string logName )
        : m_name( std::move( name ) ), m_logName( std::move( logName ) ), m_type( type ) {}

    static const CLID& classID() { return CLID_NTupleFile; }
    const CLID& clID() const override { return classID(); }
    void setType( const long typ ) { m_type = typ; }
    long type() const { return m_type; }
    const std::string& name() const { return m_name; }
    void setName( std::string nam ) { m_name = std::move( nam ); }
    const std::string& logicalName() const { return m_logName; }
    void setLogicalName( std::string l ) { m_logName = std::move( l ); }
    void setOpen( bool flag ) { m_isOpen = flag; }
    bool isOpen() const { return m_isOpen; }
  };
 
  // inhibit certain types by defining specialized templates which do not
  // allow for construction.
  template <>
  class Array<IOpaqueAddress*> {
    Array() = delete;
 
  public:
    virtual ~Array()     = default;
    virtual void dummy() = 0;
  };
  template <>
  class Matrix<IOpaqueAddress*> {
    Matrix() = delete;
 
  public:
    virtual ~Matrix()    = default;
    virtual void dummy() = 0;
  };
 
#ifndef ALLOW_ALL_TYPES
#else
  typedef Item<bool>               BoolItem;
  typedef Item<char>               CharItem;
  typedef Item<unsigned char>      UCharItem;
  typedef Item<short>              ShortItem;
  typedef Item<unsigned short>     UShortItem;
  typedef Item<long>               LongItem;
  typedef Item<long long>          LongLongItem;
  typedef Item<unsigned long>      ULongItem;
  typedef Item<unsigned long long> ULongLongItem;
  typedef Item<int>                IntItem;
  typedef Item<unsigned int>       UIntItem;
  typedef Item<float>              FloatItem;
  typedef Item<double>             DoubleItem;
  typedef Array<bool>              BoolArray;
  typedef Array<char>              CharArray;
  typedef Array<unsigned char>     UCharArray;
  typedef Array<short>             ShortArray;
  typedef Array<unsigned short>    UShortArray;
  typedef Array<long>              LongArray;
  typedef Array<unsigned long>     ULongArray;
  typedef Array<int>               IntArray;
  typedef Array<unsigned int>      UIntArray;
  typedef Array<float>             FloatArray;
  typedef Array<double>            DoubleArray;
  typedef Matrix<bool>             BoolMatrix;
  typedef Matrix<char>             CharMatrix;
  typedef Matrix<unsigned char>    UCharMatrix;
  typedef Matrix<short>            ShortMatrix;
  typedef Matrix<unsigned short>   UShortMatrix;
  typedef Matrix<long>             LongMatrix;
  typedef Matrix<unsigned long>    ULongMatrix;
  typedef Matrix<int>              IntMatrix;
  typedef Matrix<unsigned int>     UIntMatrix;
  typedef Matrix<float>            FloatMatrix;
  typedef Matrix<double>           DoubleMatrix;
#endif
 
  template <class T>
  inline std::ostream& operator<<( std::ostream& s, const Item<T>& obj ) {
    return s << T( obj );
  }
} // namespace NTuple
 
// Useful:
typedef SmartDataPtr<NTuple::Tuple>     NTuplePtr;
typedef SmartDataPtr<NTuple::Directory> NTupleDirPtr;
typedef SmartDataPtr<NTuple::File>      NTupleFilePtr;