NTupleItems.h

Go to the documentation of this file.

#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 "GaudiKernel/System.h"
#include "NTuple.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             {
      int len = 1;
      int 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) {                       }
    ~_ItemImp() override = default;
    //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)    {                }
    ~_ArrayImp() override = default;
    //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;
    }
    ~_MatrixImp() override = default;
    //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);
    }
  };
}   // end name space NTuple
#endif  // GAUDI_NTUPLESVC_NTUPLEITEMS_H