---

NTuple.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/GaudiKernel/NTuple.h,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
#ifndef GAUDIKERNEL_NTUPLE_H
#define GAUDIKERNEL_NTUPLE_H

// STL include files
#include <string>
#include <climits>
#include <cfloat>

// Framework include files
#include "GaudiKernel/DataTypeInfo.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/INTuple.h"

// Forward declarations
class IOpaqueAddress;
class NTupleFile;
class NTupleDirectory;
template <class TYPE> class SmartDataPtr;

// Definition of the CLIDs for this classes  
static const CLID CLID_NTupleFile       = 40;
static const CLID CLID_NTupleDirectory  = 41;
static const CLID CLID_RowWiseTuple     = 42;
static const CLID CLID_ColumnWiseTuple  = 43;



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(const TYP low, const TYP upper) : m_lower(low), m_upper(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()             {                               }
    const TYP lower()    const   { return m_lower;               }
    const TYP upper()    const   { return m_upper;               }
    const TYP distance() const   { return m_upper-m_lower;       }
    static const TYP min();
    static const TYP max();
  };
  template <> class Range<bool>  {
  public:
    Range(const bool /* low */ , const bool /* upper */ )    {
    }
    Range(const Range<bool>& /* copy */ )  {
    }
    virtual ~Range()              {                               }
    const bool lower()    const   { return false;                 }
    const bool upper()    const   { return true;                  }
    const bool distance() const   { return true;                  }
    static const bool min()       { return false;                 }
    static const bool max()       { return true;                  }
  };
  #define DECL_MINMAX(true_typ,minimum,maximum)                  \
  template <> inline const true_typ Range<true_typ>::min()     { \
    return minimum;                                              \
  }                                                              \
  template <> inline const true_typ Range<true_typ>::max()     { \
    return maximum;                                              \
  }
  template <> inline const float Range<float>::min()     { 
    return -FLT_MAX;                                              
  }
  template <> inline const float Range<float>::max()     { 
    return FLT_MAX;                                              
  }
  template <> inline const double Range<double>::min()     { 
    return -DBL_MAX;
  }
  template <> inline const double Range<double>::max()     { 
    return DBL_MAX;
  }
  template <> inline const unsigned char Range<unsigned char>::min()     { 
    return 0;                                              
  }
  template <> inline const unsigned char Range<unsigned char>::max()     { 
    return UCHAR_MAX;
  }
  template <> inline const char Range<char>::min()     { 
    return CHAR_MIN;
  }
  template <> inline const char Range<char>::max()     { 
    return CHAR_MAX;
  }
  template <> inline const unsigned short Range<unsigned short>::min()     { 
    return 0;                                              
  }
  template <> inline const unsigned short Range<unsigned short>::max()     { 
    return USHRT_MAX;                                              
  }
  template <> inline const short Range<short>::min()     { 
    return SHRT_MIN;                                              
  }
  template <> inline const short Range<short>::max()     { 
    return SHRT_MAX;                                              
  }
  template <> inline const unsigned int Range<unsigned int>::min()     { 
    return 0;                                              
  }
  template <> inline const unsigned int Range<unsigned int>::max()     { 
    return UINT_MAX;                                              
  }
  template <> inline const int Range<int>::min()     { 
    return INT_MIN;                                              
  }
  template <> inline const int Range<int>::max()     { 
    return USHRT_MAX;                                              
  }
  template <> inline const unsigned long Range<unsigned long>::min()     { 
    return 0;                                              
  }
  template <> inline const unsigned long Range<unsigned long>::max()     { 
    return ULONG_MAX;                                              
  }
  template <> inline const long Range<long>::min()     { 
    return LONG_MIN;            
  }
  template <> inline const long Range<long>::max()     { 
    return LONG_MAX;
  }
  template <> inline IOpaqueAddress* const Range<IOpaqueAddress* >::min()     {
    return (IOpaqueAddress*)0x0;
  }
  template <> inline IOpaqueAddress* const Range<IOpaqueAddress* >::max()     {
    return (IOpaqueAddress*)0xffffffff;
  }
  /*
  template <> inline SmartRef<DataObject> const Range<SmartRef<DataObject> >::min()     { 
    return (DataObject*)0x0;            
  }
  template <> inline SmartRef<DataObject> const Range<SmartRef<DataObject> >::max()     { 
    return (DataObject*)0xffffffff;
  }
  template <> inline SmartRef<ContainedObject> const Range<SmartRef<ContainedObject> >::min()     { 
    return (ContainedObject*)0x0;            
  }
  template <> inline SmartRef<ContainedObject> const Range<SmartRef<ContainedObject> >::max()     { 
    return (ContainedObject*)0xffffffff;
  }
  */

  template <class TYP> class _Data : virtual public INTupleItem  {
  protected:
    TYP* m_buffer;
  public:
    typedef Range<TYP>  ItemRange;
    virtual void setDefault(const TYP d)          = 0;
    virtual const ItemRange& range() const        = 0;
  };

  template <class TYP> class _Item : virtual public _Data<TYP>  {
  public:
    static _Item* create(INTuple* tup, const std::string& name, TYP min, TYP max, TYP def);
    void       set(const TYP& item) { *m_buffer = item;             }
    virtual const TYP get() const   { return *m_buffer;             }
  };

  template <class TYP> class _Array : virtual public _Data<TYP>  {
  public:
    static _Array* create(INTuple* tup, const std::string& name, const std::string& index, long len, TYP min, TYP max, TYP def);
    const TYP& data(long i)  const  { return *(m_buffer + i);        }
    TYP&       data(long i)         { return *(m_buffer + i);        }
  };

  template <class TYP> class _Matrix : virtual public _Data<TYP>    {
  protected:
    long  m_rows;
  public:
    static _Matrix* create(INTuple* tup, const std::string& name, const std::string& index, long ncol, long nrow, TYP min, TYP max, TYP def);
    TYP*       column(long i)       { return (m_buffer + i*m_rows);  }
    const TYP* column(long i) const { return (m_buffer + i*m_rows);  }
  };

  template <class TYP> class _Accessor  {
    friend class Tuple;
  protected:
    mutable TYP*  m_ptr;
  public:
    _Accessor() : m_ptr(0)           {                                }
    virtual ~_Accessor()             {                                }
    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()                          {    }
    operator const TYP () const     { return 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) { 
      m_ptr->set( data ); 
      return *this;
    }
    Item<TYP>& operator += (const TYP data)    {                       
      m_ptr->set ( m_ptr->get() + data );                     
      return *this;                                                     
    }
    Item<TYP>& operator -= (const TYP data)    {                       
      m_ptr->set ( m_ptr->get() - data );                     
      return *this;                                                     
    }
    Item<TYP>& operator *= (const TYP data)    {                       
      m_ptr->set ( m_ptr->get() * data );                     
      return *this;                                                     
    }
    Item<TYP>& operator /= (const TYP data)    {                       
      m_ptr->set ( m_ptr->get() / data );                     
      return *this;                                                     
    }
  };

  template <class TYP> class Array  : virtual public _Accessor < _Array<TYP> > {
  public:
    Array()                                  {    }
    template <class T>
    TYP&       operator[] (const T i)        { return m_ptr->data(i);  }
    template <class T>
    const TYP& operator[] (const T i) const  { return m_ptr->data(i);  }
  };

  template <class TYP> class Matrix : virtual public _Accessor< _Matrix<TYP> >  {
  public:
    Matrix()                                  {    }
    template <class T>
    TYP*       operator[] (const T i)         { return m_ptr->column(i); }
    template <class T>
    const TYP* operator[] (const T i)  const  { return m_ptr->column(i); }
  };

  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 = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
    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 = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
    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 = 0;
      }
      return (0==result) ? StatusCode::FAILURE : StatusCode::SUCCESS;
    }
    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, 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, 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, index, dim1, dim2, low, high, TYPE(0)) );
      }
      return StatusCode::FAILURE;
    }
  public:
    virtual ~Tuple()   {
    }
    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>& result)   {
      return i_addItem(name, 1, "", Range<TYPE>::min(), Range<TYPE>::max(), result.m_ptr);
    }
    template <class TYPE, class RANGE> StatusCode addItem(const std::string& name, Item<TYPE>& result, const RANGE low, const RANGE high)   {
      return i_addItem(name, 1, "", TYPE(low), TYPE(high), result.m_ptr);
    }
    template <class TYPE> StatusCode addItem(const std::string& name, long dim, Array<TYPE>& result)   {
      return i_addItem(name, dim, "", Range<TYPE>::min(), Range<TYPE>::max(), result.m_ptr);
    }
    template <class TYPE, class RANGE> StatusCode addItem(const std::string& name, long dim, Array<TYPE>& result, const RANGE low, const RANGE high)   {
      return i_addItem(name, dim, "", TYPE(low), TYPE(high), result.m_ptr);
    }
    template <class TYPE, class INDEX, class RANGE> StatusCode addItem(const std::string& name,
      Item<INDEX>& index,Array<TYPE>& result, const RANGE low, const RANGE high)   {
      return i_addItem(name, index->range().distance(), index->name(), TYPE(low), TYPE(high), result.m_ptr);
    }
    template <class TYPE, class INDEX> StatusCode addItem(const std::string& name, Item<INDEX>& index, Array<TYPE>& result)   {
      return i_addItem(name, index->range().distance(), index->name(), Range<TYPE>::min(), Range<TYPE>::max(), result.m_ptr);
    }
    template <class TYPE> StatusCode addItem(const std::string& name, long dim, long rows, Matrix<TYPE>& result)   {
      return i_addItem(name, dim, rows, "", Range<TYPE>::min(), Range<TYPE>::max(), result.m_ptr);
    }
    template <class TYPE, class RANGE> StatusCode addItem(const std::string& name, long dim, long rows, Matrix<TYPE>& result, const RANGE low, const RANGE high)   {
      return i_addItem(name, dim, rows, "", TYPE(low), TYPE(high), result.m_ptr);
    }
    template <class TYPE, class INDEX> StatusCode addItem(const std::string& name, Item<INDEX>& index, Matrix<TYPE>& result, long rows)   {
      return i_addItem(name, index->range().distance(), rows, index->name(), Range<TYPE>::min(), Range<TYPE>::max(), result.m_ptr);
    }
    template <class TYPE, class INDEX, class RANGE> StatusCode addItem(const std::string& name, Item<INDEX>& index, Matrix<TYPE>& result, long rows, const RANGE low, const RANGE high)   {
      return i_addItem(name, index->range().distance(), rows, index->name(), TYPE(low), TYPE(high), result.m_ptr);
    }
  };

  class Directory : public DataObject    {
  public:
    Directory()   {
    }
    virtual ~Directory()   {
    }
    static const CLID& classID()    {
      return CLID_NTupleDirectory;
    }
    virtual const CLID& clID()    const   {
      return Directory::classID();
    }
  };

  class File : public Directory    {
  protected:
    std::string   m_name;
    std::string   m_logName;
    unsigned char m_type;
    bool          m_isOpen;
  public:
    File() : m_type(0), m_isOpen(false)   {
    }
    File(unsigned char type, const std::string name, const std::string& logName)
    : m_name(name), m_logName(logName), m_type(type), m_isOpen(false)  {
    }
    virtual ~File()   {
    }
    static const CLID& classID()    {
      return CLID_NTupleFile;
    }
    virtual const CLID& clID()    const   {
      return File::classID();
    }
    void setType(const unsigned char typ)   {
      m_type = typ;
    }
    const unsigned char type()      const {
      return m_type;
    }
    const std::string& name()    const   {
      return m_name;
    }
    void setName(const std::string& nam)    {
      m_name = nam;
    }
    const std::string& logicalName()    const   {
      return m_logName;
    }
    void setLogicalName( const std::string& l)  {
      m_logName = l;
    }
      void setOpen(bool flag)   {
      m_isOpen = flag;
    }
    bool isOpen()   const   {
      return m_isOpen;
    }
  };

  // inhibit certians types by defining specialized templates which do not allow for 
  // construction.
  template <> class Array <IOpaqueAddress*>       {private: Array(){}  public: virtual void dummy() = 0; };
  template <> class Matrix<IOpaqueAddress*>       {private: Matrix(){} public: virtual void dummy() = 0; };
  #ifndef ALLOW_ALL_TYPES
      template <> class Item<unsigned char>       {private: Item(){}   public: virtual void dummy() = 0; };
      template <> class Array <unsigned char>     {private: Array(){}  public: virtual void dummy() = 0; };
      template <> class Matrix<unsigned char>     {private: Matrix(){} public: virtual void dummy() = 0; };
      template <> class Item<char>                {private: Item(){}   public: virtual void dummy() = 0; };
      template <> class Array <char>              {private: Array(){}  public: virtual void dummy() = 0; };
      template <> class Matrix<char>              {private: Matrix(){} public: virtual void dummy() = 0; };
      template <> class Item<unsigned short>      {private: Item(){}   public: virtual void dummy() = 0; };
      template <> class Array <unsigned short>    {private: Array(){}  public: virtual void dummy() = 0; };
      template <> class Matrix<unsigned short>    {private: Matrix(){} public: virtual void dummy() = 0; };
      template <> class Item<short>               {private: Item(){}   public: virtual void dummy() = 0; };
      template <> class Array <short>             {private: Array(){}  public: virtual void dummy() = 0; };
      template <> class Matrix<short>             {private: Matrix(){} public: virtual void dummy() = 0; };
      template <> class Item<unsigned int>        {private: Item(){}   public: virtual void dummy() = 0; };
      template <> class Array <unsigned int>      {private: Array(){}  public: virtual void dummy() = 0; };
      template <> class Matrix<unsigned int>      {private: Matrix(){} public: virtual void dummy() = 0; };
      template <> class Item<int>                 {private: Item(){}   public: virtual void dummy() = 0; };
      template <> class Array <int>               {private: Array(){}  public: virtual void dummy() = 0; };
      template <> class Matrix<int>               {private: Matrix(){} public: virtual void dummy() = 0; };
    #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<unsigned long>     ULongItem;
      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
#undef DECL_MINMAX
};

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

#include "GaudiKernel/MsgStream.h"
template <class T>
MsgStream& operator<<(MsgStream& s, const NTuple::Item<T>& obj)   {
  return s << T(obj);
}

template <class T>
std::ostream& operator<<(std::ostream& s, const NTuple::Item<T>& obj)   {
  return s << T(obj);
}

#endif // GAUDIKERNEL_NTUPLE_H

---