In This Package:

NTupleItems.h

Go to the documentation of this file.

// $Id: NTupleItems.h,v 1.7 2008/10/27 19:22:20 marcocle Exp $
#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>  {
  private:
    _DataImp(const _DataImp& copy)    {}
  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;
    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,const std::string& name,const std::type_info& info,const std::string& index,long len,TYP low,TYP high,TYP def)
    : m_length(len), m_tuple(tup), m_name(name), m_index(index),
      m_def(def), m_range(low, high), m_info(info)
    {
      m_indexItem = 0;
      m_type = typeid(TYP) == typeid(void*) ? DataTypeInfo::POINTER : DataTypeInfo::ID(info);
      this->m_buffer = new TYP[m_length];
      reset();
    }
    virtual ~_DataImp()                      {
      if ( 0 != this->m_buffer ) delete [] this->m_buffer;
    }
    virtual std::string typeName()   const   {
      return System::typeinfoName( this->typeID() );
    }
    virtual void reset()                      {
      TYP* buff = this->m_buffer;
      for ( size_t i = 0; i < static_cast<size_t>(m_length); i++ )    {
        *buff++ = m_def;
      }
    }
    virtual long filled()  const              {
      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 > 1 )   {
          len *= dim(nd);
        }
      }
      return len;
    }
    virtual INTupleItem* indexItem()                  {
      if ( 0 == m_indexItem )   {
        m_indexItem = m_tuple->find(m_index);
      }
      return m_indexItem;
    }
    virtual const INTupleItem* indexItem() const      {
      if ( 0 == m_indexItem )   {
        m_indexItem = m_tuple->find(m_index);
      }
      return m_indexItem;
    }
    virtual const std::type_info& typeID() const             { return m_info;}
    virtual long size() const { return m_length*sizeof(TYP); }
    virtual void release() { delete this; }
    virtual bool hasIndex() const { return m_index.length()>0; }
    virtual const std::string& index() const { return m_index; }
    virtual const std::string&  name() const { return m_name; }
    virtual long type() const { return m_type; }
    virtual void setType (long t) { m_type=DataTypeInfo::Type(t); }
    virtual void setDefault(const TYP val) { m_def = val; }
    virtual const ItemRange& range() const { return m_range; }
    virtual long length() const { return m_length; }
    virtual const void* buffer() const { return this->m_buffer; }
    virtual void* buffer() { return this->m_buffer; }
    virtual long ndim() const { return 0; }
    virtual long dim(long i) const { return (i==0) ? 1 : 0; }
    virtual INTuple* tuple() { 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 ~_ItemImp()                      {                                     }
    //virtual const std::type_info& typeID() const             { return typeid(NTuple::_Item<TYP>);  }
    virtual void setDefault(const TYP val)   { this->m_def = val;                  }
    virtual const ItemRange& range() const   { return this->m_range;               }
    virtual long size()   const              { 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 ~_ArrayImp()                     {                                     }
    //virtual const std::type_info& typeID() const             { return typeid(NTuple::_Array<TYP>); }
    virtual void setDefault(const TYP val)   { this->m_def = val;                  }
    virtual const ItemRange& range() const   { return this->m_range;               }
    virtual long size()   const              { return this->m_length*sizeof(TYP);  }
    virtual long ndim()   const              { return 1;                     }
    virtual long dim(long i) const {
      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 ~_MatrixImp()                    {                                     }
    //virtual const std::type_info& typeID() const             { return typeid(NTuple::_Matrix<TYP>);}
    virtual void setDefault(const TYP val)   { this->m_def = val;                  }
    virtual const ItemRange& range() const   { return this->m_range;               }
    virtual long size()   const              { return this->m_length*sizeof(TYP);  }
    virtual long ndim() const                { return 2;                           }
    virtual long dim(long i) const           {
      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

---