NTIntFun.h

Go to the documentation of this file.

#ifndef __NTINTFUN_H
#define __NTINTFUN_H

#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/IntFunPoR.h"
 
#include <Rtypes.h>     // declares Int_t
#include <TTree.h>    
#include <TBranch.h>    
#include <cassert>   
#include <cstring>   
#include <stdio.h>  
#include <iostream>
 
 
// Class NTIntFun

class NTIntFun: public IntFun {
  public:
    NTIntFun (const std::string& name_       
             );
    
    NTIntFun (const std::string& name_,      
              const IntFun *iter_            
             );
    NTIntFun (const std::string& name_,      
              int offset_                    
             );
    
    
    virtual NTIntFun& operator[] (const IntFunPoR& iter_  
                                  ) const = 0;
    
    virtual NTIntFun& operator[] (int offset_  
                                 ) const = 0;
    

    virtual const FillIterator *getIterator() const { 
      return iter ? iter->getIterator() : 0; 
    }
    
  protected:  
    virtual ~NTIntFun() {}
    
    std::string getBaseName() const;
    
    // Data members
    const IntFun *iter;               
    int offset;                       
};
 
// Class NTIntFunT

template<class Ntuple, class T = Int_t> 
class NTIntFunT: public NTIntFun {
  public:
    NTIntFunT (const Ntuple& nt,            
               const char *branchname,      
               const IntFunPoR& iter_ = 0   
              ) 
    : NTIntFun (branchname, iter_.pif)
    {        
      TTree *t = nt.fChain;
      assert (t);
      TBranch *b = t->GetBranch (branchname);
      assert (b);
      branchAddress = reinterpret_cast<T *>(b->GetAddress());
      assert (branchAddress);
    }
    
    NTIntFunT (const Ntuple& nt,            
               T Ntuple::* p_mem,           
               const char *name_ = "?",     
               const IntFunPoR& iter_ = 0   
              ) 
    : NTIntFun (name_, iter_.pif)       
    {
      branchAddress = &(nt.*p_mem);
      assert (branchAddress);
    }
  
    NTIntFunT (const Ntuple& nt,            
               const char *branchname,      
               int offset_                  
              ) 
    : NTIntFun (branchname, offset_)
    {        
      TTree *t = nt.fChain;
      assert (t);
      TBranch *b = t->GetBranch (branchname);
      assert (b);
      branchAddress = reinterpret_cast<T *>(b->GetAddress());
      assert (branchAddress);
    }
    
    NTIntFunT (const Ntuple& nt,            
              T Ntuple::* p_mem,            
              const char *name_,            
              int offset_                   
             ) 
    : NTIntFun (name_, offset_)   
    {
      branchAddress = &(nt.*p_mem);
      assert (branchAddress);
    }
    
    NTIntFunT (const NTIntFunT<Ntuple, T>& source, 
               const IntFunPoR& iter_                  
              )
      : NTIntFun (source.getBaseName(), iter_.pif),
        branchAddress (source.branchAddress)
        {}
    NTIntFunT (const NTIntFunT<Ntuple, T>& source, 
               const int offset_                        
              )
      : NTIntFun (source.getBaseName(), offset_),
        branchAddress (source.branchAddress)
        {}
  
    virtual int operator() () const {
      int i = (iter) ? (*iter)() : offset;
      return branchAddress[i];
    } 
    
    NTIntFunT<Ntuple, T>& operator[] (const IntFunPoR& iter_  
                                    ) const {
      return *new NTIntFunT<Ntuple, T> (*this, iter_.pif);
    }
    
    NTIntFunT<Ntuple, T>& operator[] (int offset_  
                                    ) const {
      return *new NTIntFunT<Ntuple, T> (*this, offset_);
    }
    
    
  protected:  
    virtual ~NTIntFunT() {}
    
    // Data members
    const T *branchAddress;           
};


template<class Ntuple, class T> 
NTIntFunT<Ntuple, T>& ntintfun (const Ntuple& nt,            
                                T Ntuple::* p_mem,           
                                const char *name_ = "?",     
                                const IntFunPoR& iter_ = 0   
                               ) {
  return *new NTIntFunT<Ntuple, T> (nt, p_mem, name_, iter_);
}   

template<class Ntuple, class T> 
NTIntFunT<Ntuple, T>& ntintfun (const Ntuple& nt,            
                                T Ntuple::* p_mem,           
                                const char *name_ = "?",     
                                int offset_                  
                               ) {
  return *new NTIntFunT<Ntuple, T> (nt, p_mem, name_, offset_);
}   
/*
 * A very special solution to the problem
 * that a member pointer to an ARRAY of T (i.e., a T[n]) is not equivalent
 * to a pointer to T or anything. Unfortunately, we also cannot
 * use a syntax like "p_mem[0]", because that is forbidden.
 * Therefore we have to use n as template argument explicitely,
 * and use the ugly reinterpret_cast to make a pointer to T out of a 
 * pointer to a T[n].
 */                               
template<class Ntuple, class T, unsigned int n> 
NTIntFunT<Ntuple, T>& ntintfun (const Ntuple& nt,            
                                T (Ntuple::* p_mem)[n],           
                                const char *name_ = "?",
                                const IntFunPoR& iter_ = 0   
                               ) {
  // p_mem is of type "T[n] Ntuple::*", which is correctly written as "T (Ntuple::*)[n]",
  // now we convert it to type "T Ntuple::*"                                
  T (Ntuple::* p_mem0) = reinterpret_cast<T Ntuple::*>(p_mem);
  return *new NTIntFunT<Ntuple, T> (nt, p_mem0, name_, iter_);
}                                  
template<class Ntuple, class T, unsigned int n> 
NTIntFunT<Ntuple, T>& ntintfun (const Ntuple& nt,             
                                T (Ntuple::* p_mem)[n],       
                                const char *name_ = "?", 
                                int offset_                   
                               ) {
  // p_mem is of type "T[n] Ntuple::*", which is correctly written as "T (Ntuple::*)[n]",
  // now we convert it to type "T Ntuple::*"                                
  T (Ntuple::* p_mem0) = reinterpret_cast<T Ntuple::*>(p_mem);
  return *new NTIntFunT<Ntuple, T> (nt, p_mem0, name_, offset_);
}                                  


#endif /* #ifndef __NTINTFUN_H */

---