NTuple.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_NTUPLE_H
#define GAUDIKERNEL_NTUPLE_H
// ============================================================================
// STL include files
// ============================================================================
#include <algorithm>
#include <cfloat>
#include <limits>
#include <stdexcept>
#include <string>
// ============================================================================
// Framework include files
// ============================================================================
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/DataTypeInfo.h"
#include "GaudiKernel/INTuple.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/SmartDataPtr.h"
// ============================================================================
// Forward declarations
// ============================================================================
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; }
    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;
    virtual const ItemRange& range() const = 0;
  };
  // ==========================================================================
  template <class TYP>
  class GAUDI_API _Item : virtual public _Data<TYP>
  {
  public:
    ~_Item() override = default;
    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>& ) { return *this; }

  protected:
    mutable TYP* m_ptr = nullptr;

  public:
    _Accessor() = default;
    virtual ~_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(); }

    ~Array() override = default;
  };
  // =========================================================================
  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 );
    }
    ~Matrix() override = default;
  };
  // =========================================================================
  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:
    ~Tuple() override = default;

    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 );
    }
  };

  class Directory : public DataObject
  {
  public:
    Directory() {}
    ~Directory() override = default;

    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 )
    {
    }
    ~File() override = default;

    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 );
  }
} // end of namespace NTuple

// Useful:
typedef SmartDataPtr<NTuple::Tuple> NTuplePtr;
typedef SmartDataPtr<NTuple::Directory> NTupleDirPtr;
typedef SmartDataPtr<NTuple::File> NTupleFilePtr;

#endif // GAUDIKERNEL_NTUPLE_H