NTuple.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_NTUPLE_H
#define GAUDIKERNEL_NTUPLE_H
// ============================================================================
// STL include files
// ============================================================================
#include <string>
#include <limits>
#include <cfloat>
#include <stdexcept>
#include <algorithm>
// ============================================================================
// Framework include files
// ============================================================================
#include "GaudiKernel/DataTypeInfo.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/INTuple.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/IOpaqueAddress.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