NTupleItems.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2024 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.                                             *
\***********************************************************************************/
 
// cppcheck-suppress-file passedByValue; TYP is a small type
 
#ifndef GAUDI_NTUPLESVC_NTUPLEITEMS_H
#define GAUDI_NTUPLESVC_NTUPLEITEMS_H 1
 
// The converter understands all items
#define ALLOW_ALL_TYPES
 
// STL include files
#include <vector>
 
// Framework include files
#include "NTuple.h"
#include <GaudiKernel/System.h>
// Forward declarations
class IDataProviderSvc;
class IConversionSvc;
 
namespace NTuple {
  // Local forward declarations
  template <class TYP>
  class DataItem;
  template <class TYP>
  class _DataImp;
  template <class TYP>
  class _ItemImp;
  template <class TYP>
  class _ArrayImp;
  template <class TYP>
  class _MatrixImp;
 
  template <class TYP>
  class _DataImp : virtual public _Data<TYP> {
    _DataImp( const _DataImp& ) = delete;
 
  protected:
    typedef const std::string&    CSTR;
    typedef const std::type_info& CTYPE;
    long m_length;
    INTuple* m_tuple;
    std::string m_name;
    std::string m_index;
    mutable INTupleItem* m_indexItem = nullptr;
    DataTypeInfo::Type m_type;
    TYP m_def;
    Range<TYP> m_range;
    const std::type_info& m_info;
 
  public:
    typedef Range<TYP> ItemRange;
    _DataImp( INTuple* tup, std::string name, const std::type_info& info, std::string index, long len, TYP low,
              TYP high, TYP def )
        : m_length( len )
        , m_tuple( tup )
        , m_name( std::move( name ) )
        , m_index( std::move( index ) )
        , m_def( std::move( def ) )
        , m_range( std::move( low ), std::move( high ) )
        , m_info( info ) {
      m_type         = typeid( TYP ) == typeid( void* ) ? DataTypeInfo::POINTER : DataTypeInfo::ID( info );
      this->m_buffer = new TYP[m_length];
      reset();
    }
    ~_DataImp() override { delete[] this->m_buffer; }
    std::string typeName() const override { return System::typeinfoName( this->typeID() ); }
    void reset() override { std::fill_n( this->m_buffer, m_length, m_def ); }
    long filled() const override {
      long len = 1;
      long nd  = ndim();
      if ( m_length > 1 ) {
        for ( int l = 0; l < nd - 1; l++ ) { len *= dim( l ); }
        if ( indexItem() ) {
          long* ll = (long*)m_indexItem->buffer();
          len *= *ll;
        } else if ( nd > 0 ) {
          len *= dim( nd - 1 );
        }
      }
      return len;
    }
    INTupleItem* indexItem() override {
      if ( !m_indexItem ) m_indexItem = m_tuple->find( m_index );
      return m_indexItem;
    }
    const INTupleItem* indexItem() const override {
      if ( !m_indexItem ) m_indexItem = m_tuple->find( m_index );
      return m_indexItem;
    }
    const std::type_info& typeID() const override { return m_info; }
    long size() const override { return m_length * sizeof( TYP ); }
    void release() override { delete this; }
    bool hasIndex() const override { return m_index.length() > 0; }
    const std::string& index() const override { return m_index; }
    const std::string& name() const override { return m_name; }
    long type() const override { return m_type; }
    void setType( long t ) override { m_type = DataTypeInfo::Type( t ); }
    void setDefault( const TYP val ) override { m_def = val; }
    const ItemRange& range() const override { return m_range; }
    long length() const override { return m_length; }
    const void* buffer() const override { return this->m_buffer; }
    virtual void* buffer() { return this->m_buffer; }
    long ndim() const override { return 0; }
    long dim( long i ) const override { return ( i == 0 ) ? 1 : 0; }
    INTuple* tuple() override { return m_tuple; }
  };
 
  template <class TYP>
  class _ItemImp : virtual public _DataImp<TYP>, virtual public _Item<TYP> {
 
  public:
    typedef Range<TYP> ItemRange;
    _ItemImp( INTuple* tup, const std::string& name, const std::type_info& info, TYP min, TYP max, TYP def )
        : _DataImp<TYP>( tup, name, info, "", 1, min, max, def ) {}
    // virtual const std::type_info& typeID() const             { return typeid(NTuple::_Item<TYP>);  }
    void setDefault( const TYP val ) override { this->m_def = val; }
    const ItemRange& range() const override { return this->m_range; }
    long size() const override { return this->m_length * sizeof( TYP ); }
  };
 
  template <class TYP>
  class _ArrayImp : virtual public _DataImp<TYP>, virtual public _Array<TYP> {
  public:
    typedef Range<TYP> ItemRange;
    _ArrayImp( INTuple* tup, const std::string& name, const std::type_info& typ, const std::string& index, long len,
               TYP min, TYP max, TYP def )
        : _DataImp<TYP>( tup, name, typ, index, len, min, max, def ) {}
    // virtual const std::type_info& typeID() const             { return typeid(NTuple::_Array<TYP>); }
    void setDefault( const TYP val ) override { this->m_def = val; }
    const ItemRange& range() const override { return this->m_range; }
    long size() const override { return this->m_length * sizeof( TYP ); }
    long ndim() const override { return 1; }
    long dim( long i ) const override { return ( i != 0 || this->hasIndex() ) ? 0 : this->m_length; }
  };
 
  template <class TYP>
  class _MatrixImp : virtual public _DataImp<TYP>, virtual public _Matrix<TYP> {
  public:
    typedef Range<TYP> ItemRange;
    _MatrixImp( INTuple* tup, const std::string& name, const std::type_info& typ, const std::string& index, long ncol,
                long nrow, TYP min, TYP max, TYP def )
        : _DataImp<TYP>( tup, name, typ, index, nrow * ncol, min, max, def ) {
      this->m_rows = nrow;
    }
    // virtual const std::type_info& typeID() const             { return typeid(NTuple::_Matrix<TYP>);}
    void setDefault( const TYP val ) override { this->m_def = val; }
    const ItemRange& range() const override { return this->m_range; }
    long size() const override { return this->m_length * sizeof( TYP ); }
    long ndim() const override { return 2; }
    long dim( long i ) const override {
      return ( this->hasIndex() ) ? ( ( i == 0 ) ? this->m_rows : this->m_length / this->m_rows )
                                  : ( ( i == 1 ) ? this->m_length / this->m_rows : this->m_rows );
    }
  };
} // namespace NTuple
#endif // GAUDI_NTUPLESVC_NTUPLEITEMS_H