H1BankFuns.h

Go to the documentation of this file.

#ifndef __H1BANKFUNS_H
#define __H1BANKFUNS_H

#include "jbltools/sfh/h1/H1Funs.h"
#include "H1OOBanks/H1BankPtr.h"
#include "H1OOBanks/H1Row.h"


#include <cassert>
#include <cstring>

class H1DmisBankPtr;
class H1DmisRow;

template <class H1SomeBankPtr, class H1SomeRow, class TM>
class JBLH1SomeBankFloatFun: public FloatFun {
  public:
    JBLH1SomeBankFloatFun (const H1SomeBankPtr& ptr_,           
                           const FillIterator& iter_,           
                           TM (H1SomeRow::* ptr_mem_)() const,  
                           const char *attribname = 0           
                           )
      : FloatFun(getH1PtrName(ptr_)
                 +'['+iter_.getName()+"]."+attribname),
        ptr (ptr_), 
        iter (iter_),  
        ptr_mem(ptr_mem_)
      { assert (&ptr); 
      }
    virtual Float_FF operator() () const { 
      assert (ptr[iter()]);
      H1SomeRow& row = *ptr[iter()];
      return (row.*ptr_mem)();
    }
      
    virtual const FillIterator *getIterator() const { return &iter; }
  protected:
    virtual ~JBLH1SomeBankFloatFun() {}
  private:
   // Data members
    const H1SomeBankPtr& ptr;            
    const FillIterator&  iter;           
    TM (H1SomeRow::* ptr_mem)() const;   
};

class JBLH1BankFloatFun: public FloatFun {
  public:
    JBLH1BankFloatFun (const char *name_,            
                       const FillIterator& iter_,    
                       int column_ = 0,              
                       const char *attribname = 0    
                      )
      : FloatFun(std::string(name_)+'['+iter_.getName()+"]."
                 + (attribname ? std::string(attribname) : std::string("Float(")+str(column_)+')')),
        ptr (*new H1BankPtr(name_)), 
        iter (iter_), 
        column (column_)
      {   
        assert (&ptr);  
      }
    JBLH1BankFloatFun (const H1BankPtr& ptr_,      
                       const FillIterator& iter_,  
                       int column_ = 0,            
                       const char *attribname = 0  
                      )
      : FloatFun(getH1PtrName(ptr_)
                 +'['+iter_.getName()+"]."
                 + (attribname ? std::string(attribname) : std::string("Float(")+str(column_)+')')),
        ptr (ptr_), 
        iter (iter_), 
        column (column_)               
      {   
        assert (&ptr);  
      }
    virtual Float_FF operator() () const { 
      assert (ptr[iter()]);
      return ptr[iter()]->GetFloat (column);
    }
    virtual JBLH1BankFloatFun& operator[] (int newcolumn    
                                          ) const {
      return *new JBLH1BankFloatFun (ptr, iter, newcolumn);
    }   
      
    virtual const FillIterator *getIterator() const { return &iter; }
  protected:
    virtual ~JBLH1BankFloatFun() {}
  private:
    // Data members
    const H1BankPtr&    ptr;        
    const FillIterator& iter;       
          int           column;     
};

class JBLH1BankFloatFunInt: public FloatFun {
  public:
    JBLH1BankFloatFunInt (const char *name_,           
                          const FillIterator& iter_,    
                          int column_ = 0,              
                          const char *attribname = 0    
                         )
      : FloatFun(std::string(name_)+'['+iter_.getName()+"]."
                 + (attribname ? std::string(attribname) : std::string("Int(")+str(column_)+')')),
        ptr (*new H1BankPtr(name_)), 
        iter (iter_), 
        column (column_)  
      { assert (&ptr); }
    JBLH1BankFloatFunInt (const H1BankPtr& ptr_,      
                          const FillIterator& iter_,  
                          int column_ = 0,            
                          const char *attribname = 0  
                         )
      : FloatFun(getH1PtrName(ptr_)
                 +'['+iter_.getName()+"]."
                 + (attribname ? std::string(attribname) : std::string("Int(")+str(column_)+')')),
        ptr (ptr_), iter (iter_), column (column_)                  
      { assert (&ptr); }
    virtual Float_FF operator() () const { 
      assert (ptr[iter()]);
      return ptr[iter()]->GetInt (column);
    }
    virtual JBLH1BankFloatFunInt& operator[] (int newcolumn    
                                             ) const {
      return *new JBLH1BankFloatFunInt (ptr, iter, newcolumn);
    }   
      
    virtual const FillIterator *getIterator() const { return &iter; }
  protected:
    virtual ~JBLH1BankFloatFunInt() {}
  private:
    // Data members
    const H1BankPtr&    ptr;        
    const FillIterator& iter;       
          int           column;     
};

class JBLH1BankIntFun: public IntFun {
  public:
    JBLH1BankIntFun (const char *name_,            
                     const FillIterator& iter_,    
                     int column_ = 0,              
                     const char *attribname = 0    
                    )
      : IntFun(std::string(name_)+'['+iter_.getName()+"]."
               + (attribname ? std::string(attribname) : std::string("Int(")+str(column_)+')')),
        ptr (*new H1BankPtr(name_)), iter (iter_), column (column_)  
      { assert (&ptr); }
    JBLH1BankIntFun (const H1BankPtr& ptr_,      
                     const FillIterator& iter_,  
                     int column_ = 0,            
                     const char *attribname = 0    
                    )
      : IntFun(getH1PtrName(ptr_)
               +'['+iter_.getName()+"]."
               + (attribname ? std::string(attribname) : std::string("Int(")+str(column_)+')')),
        ptr (ptr_), iter (iter_), column (column_)                  
      { assert (&ptr); }
    virtual int operator() () const { 
      assert (ptr[iter()]);
      return ptr[iter()]->GetInt (column);
    }
    
    virtual JBLH1BankIntFun& operator[] (int newcolumn    
                                        ) const {
      return *new JBLH1BankIntFun (ptr, iter, newcolumn);
    }
    virtual JBLH1BankIntFun& Int (int newcolumn    
                                 ) const {
      return *new JBLH1BankIntFun (ptr, iter, newcolumn);
    }
    virtual JBLH1BankFloatFun& Float (int newcolumn    
                                     ) const {
      return *new JBLH1BankFloatFun (ptr, iter, newcolumn);
    }
    virtual JBLH1BankFloatFunInt& FloatFromInt (int newcolumn    
                                               ) const {
      return *new JBLH1BankFloatFunInt (ptr, iter, newcolumn);
    }
      
    virtual const FillIterator *getIterator() const { return &iter; }
  protected:
    virtual ~JBLH1BankIntFun() {}
  private:
    const H1BankPtr& ptr;              
    const FillIterator& iter;          
    int column;                        
};



template <class H1SomeBankPtr = H1BankPtr, class H1SomeRow = H1Row>
class JBLH1SomeBankIterator: public FillIterator {
  public:
    JBLH1SomeBankIterator () 
      : FillIterator(),
        ptr (*new H1SomeBankPtr), 
        index (0)
      {    
        assert (&ptr); 
        setName(getH1PtrName(ptr));
      }
    explicit JBLH1SomeBankIterator (const char *name_        
                                   ) 
      : FillIterator(name_),
        ptr (*new H1SomeBankPtr(name_)), 
        index (0)
      {    
        assert (&ptr);   
      }
    explicit JBLH1SomeBankIterator (const H1SomeBankPtr& ptr_     
                                ) 
      : FillIterator(getH1PtrName(ptr_)),
        ptr (ptr_), index (0)
      {    
        assert (&ptr);   
      }
    virtual int operator() () const {
      return index;
    }   
    virtual bool next() {
      return (++index < ptr.GetEntries());
    }
    virtual bool reset() {
      return ((index=0) < ptr.GetEntries());
    }
    virtual bool isValid() const {
      return index>=0 && index < ptr.GetEntries();
      
    }          
    virtual JBLH1BankFloatFun& GetFloat(int column,                 
                                        const char *attribname = 0  
                                       ) {
      return *new JBLH1BankFloatFun (ptr, *this, column, attribname);
    }
    
    template<class TM>
    JBLH1SomeBankFloatFun<H1SomeBankPtr, H1SomeRow, TM>& 
      GetFloat(TM (H1SomeRow::* ptr_mem)() const, 
               const char *attribname = 0         
                                       ) {
      return *new JBLH1SomeBankFloatFun<H1SomeBankPtr, H1SomeRow, TM> (ptr, *this, ptr_mem, attribname);
    }
    virtual JBLH1BankFloatFunInt& GetFloatFromInt (int column    
                                       ) {
      return *new JBLH1BankFloatFunInt (ptr, *this, column);
    }
    virtual JBLH1BankIntFun& GetInt(int column    
                                    ) {
      return *new JBLH1BankIntFun (ptr, *this, column);
    }
  
  protected:
    virtual ~JBLH1SomeBankIterator() {}

  private:
    // Data members
    const H1SomeBankPtr& ptr;    
    int index;               
};

typedef JBLH1SomeBankIterator<H1BankPtr, H1Row> JBLH1BankIterator;
typedef JBLH1SomeBankIterator<H1DmisBankPtr, H1DmisRow> JBLH1DmisBankIterator;


template <class H1SomeBankPtr = H1BankPtr, class H1SomeRow = H1Row>
class JBLH1SomeBank {
  public:
    JBLH1SomeBank () 
      : ptr (*new H1SomeBankPtr)
      { 
        assert (&ptr); 
        name = getH1PtrName(ptr);
      }
    explicit JBLH1SomeBank (const char *name_         
                       ) 
      : ptr (*new H1SomeBankPtr(name_)), name (name_)
      {  
        assert (&ptr);  
      }
    explicit JBLH1SomeBank (const H1SomeBankPtr& ptr_     
                       ) 
      : ptr (ptr_)
      {  
        assert (&ptr);   
        name = getH1PtrName(ptr);
      }
    virtual JBLH1SomeBankIterator<H1SomeBankPtr, H1SomeRow>& iter() const { 
      return *new JBLH1SomeBankIterator<H1SomeBankPtr, H1SomeRow> (ptr); 
    }
    virtual const H1SomeBankPtr& getH1BankPtr() const {return ptr;}
    virtual const char *getName() const { return name.c_str(); }
  protected: 
    virtual ~JBLH1SomeBank() {}
  private:
    // Data members
    const H1SomeBankPtr& ptr;     
    std::string name;             
};

typedef JBLH1SomeBank<H1BankPtr, H1Row> JBLH1Bank;
typedef JBLH1SomeBank<H1DmisBankPtr, H1DmisRow> JBLH1DmisBank;


#endif /* #ifndef __H1BANKFUNS_H */ 

---