NTFloatFun.h

Go to the documentation of this file.

#ifndef __NTFLOATFUN_H
#define __NTFLOATFUN_H

#include "jbltools/sfh/FloatFun.h"
#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/IntFunPoR.h"
 
#include <Rtypes.h>     // declares Float_t
#include <TTree.h>    
#include <TBranch.h>    
#include <cstring>   
 
 
// Class NTFloatFun

class NTFloatFun: public FloatFun {
  public:
    NTFloatFun (const std::string& name_       
               );
    
    NTFloatFun (const std::string& name_,      
                const IntFun *iter_     
               );
    NTFloatFun (const std::string& name_,      
                int offset_             
               );
    
    virtual NTFloatFun& operator[] (const IntFunPoR& iter_  
                                  ) const = 0;
    
    virtual NTFloatFun& operator[] (int offset_  
                                 ) const = 0;
    
    virtual const FillIterator *getIterator() const { 
      return iter ? iter->getIterator() : 0; 
    }
    
  protected:  
    virtual ~NTFloatFun() {}
    
    std::string getBaseName() const;

    // Data members
    const IntFun *iter;               
    int offset;                       
};
 
// Class NTFloatFunT

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

template<class Ntuple, class T = Float_t> 
class NTFloatFunG: public NTFloatFun {
  public:
    typedef T (Ntuple::*Getter)(); // a getter function, returning T
    typedef T (Ntuple::*ConstGetter)() const; // a getter function, returning T
    
    NTFloatFunG (const Ntuple& nt_,            
                 Getter p_mem,                 
                 const char *name_ = "?"       
                ) 
    : NTFloatFun (name_), nt (const_cast<Ntuple&>(nt_)), getMethod (p_mem)           
    {
    }
    NTFloatFunG (const Ntuple& nt_,            
                 ConstGetter p_mem,            
                 const char *name_ = "?"       
                ) 
    : NTFloatFun (name_), nt (const_cast<Ntuple&>(nt_)), getMethod (reinterpret_cast<Getter>(p_mem))           
    {
    }
  
  
    virtual Float_FF operator() () const {
      return (nt.*getMethod)();
    } 
    
    virtual NTFloatFun& operator[] (const IntFunPoR& iter_  
                                  ) const 
    {assert (0); return (*(NTFloatFun*)(0)); }
    
    virtual NTFloatFun& operator[] (int offset_  
                                 ) const
    {assert (0); return (*(NTFloatFun*)(0)); }
    
 
  protected:  
    virtual ~NTFloatFunG() {}
    
    // Data members
    Ntuple& nt;
    Getter getMethod;
};
 
// Class NTFloatFunGA

template<class Ntuple, class T = Float_t, class A = Float_t> 
class NTFloatFunGA: public NTFloatFun {
  public:
    typedef T (Ntuple::*Getter)(A); // a getter function, returning T
    typedef T (Ntuple::*ConstGetter)(A) const; // a getter function, returning T
    
    NTFloatFunGA (const Ntuple& nt_,            
                 Getter p_mem,                 
                 A arg_,                       
                 const char *name_ = "?"       
                ) 
    : NTFloatFun (name_), nt (const_cast<Ntuple&>(nt_)), getMethod (p_mem), arg (arg_)
    {
    }
    NTFloatFunGA (const Ntuple& nt_,            
                 ConstGetter p_mem,            
                 A arg_,                       
                 const char *name_ = "?"       
                ) 
    : NTFloatFun (name_), nt (const_cast<Ntuple&>(nt_)), 
      getMethod (reinterpret_cast<Getter>(p_mem)), arg (arg_)           
    {
    }
  
  
    virtual Float_FF operator() () const {
      return (nt.*getMethod)(arg);
    } 
    
    virtual NTFloatFun& operator[] (const IntFunPoR& iter_  
                                  ) const 
    {assert (0); return (*(NTFloatFun*)(0)); }
    
    virtual NTFloatFun& operator[] (int offset_  
                                 ) const
    {assert (0); return (*(NTFloatFun*)(0)); }
    
 
  protected:  
    virtual ~NTFloatFunGA() {}
    
    // Data members
    Ntuple& nt;
    Getter getMethod;
    A arg;
};
 
// Class NTFloatFunGF

template<class T = Float_t> 
class NTFloatFunGF: public NTFloatFun {
  public:
    typedef T (*Getter)(); // a getter function, returning T
    
    NTFloatFunGF (Getter p_mem,                 
                  const char *name_ = "?"       
                 ) 
    : NTFloatFun (name_), getMethod (p_mem)           
    {
    }
  
  
    virtual Float_FF operator() () const {
      return (*getMethod)();
    } 
    
    virtual NTFloatFun& operator[] (const IntFunPoR& iter_  
                                  ) const 
    {assert (0); return (*(NTFloatFun*)(0)); }
    
    virtual NTFloatFun& operator[] (int offset_  
                                 ) const
    {assert (0); return (*(NTFloatFun*)(0)); }
    
 
  protected:  
    virtual ~NTFloatFunGF() {}
    
    // Data members
    Getter getMethod;
};

template<class Ntuple, class T> 
NTFloatFunT<Ntuple, T>& ntfloatfun (const Ntuple& nt,           
                                    T Ntuple::* p_mem,           
                                    const char *name_ = "?",     
                                    const IntFunPoR& iter_ = 0   
                                   ) {
  return *new NTFloatFunT<Ntuple, T> (nt, p_mem, name_, iter_);
}  
 
template<class Ntuple, class T> 
NTFloatFunT<Ntuple, T>& ntfloatfun (const Ntuple& nt,           
                                    T Ntuple::* p_mem,          
                                    const char *name_ = "?",    
                                    int offset_                 
                                   ) {
  return *new NTFloatFunT<Ntuple, T> (nt, p_mem, name_, offset_);
} 
 
template<class Ntuple, class T> 
NTFloatFunG<Ntuple, T>& ntfloatfun (const Ntuple& nt,           
                                    T (Ntuple::* p_mem)(),      
                                    const char *name_ = "?"     
                                   ) {
  return *new NTFloatFunG<Ntuple, T> (nt, p_mem, name_);
} 
template<class Ntuple, class T> 
NTFloatFunG<Ntuple, T>& ntfloatfun (const Ntuple& nt,            
                                    T (Ntuple::* p_mem)() const, 
                                    const char *name_ = "?"      
                                   ) {
  return *new NTFloatFunG<Ntuple, T> (nt, p_mem, name_);
} 
 
template<class Ntuple, class T, class A> 
NTFloatFunGA<Ntuple, T, A>& ntfloatfun (const Ntuple& nt,           
                                        T (Ntuple::* p_mem)(A),     
                                        A arg_,                     
                                        const char *name_ = "?"     
                                       ) {
  return *new NTFloatFunGA<Ntuple, T, A> (nt, p_mem, arg_, name_);
} 
template<class Ntuple, class T, class A> 
NTFloatFunGA<Ntuple, T, A>& ntfloatfun (const Ntuple& nt,             
                                        T (Ntuple::* p_mem)(A) const, 
                                        A arg_,                       
                                        const char *name_ = "?"       
                                       ) {
  return *new NTFloatFunGA<Ntuple, T, A> (nt, p_mem, arg_, name_);
} 
 
template<class T> 
NTFloatFunGF<T>& ntfloatfun (T (* p_mem)(),     
                             const char *name_ = "?"     
                             ) {
  return *new NTFloatFunGF<T> (p_mem, name_);
} 
  
/*
 * 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> 
NTFloatFunT<Ntuple, T>& ntfloatfun (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 NTFloatFunT<Ntuple, T> (nt, p_mem0, name_, iter_);
}                                  

template<class Ntuple, class T, unsigned int n> 
NTFloatFunT<Ntuple, T>& ntfloatfun (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 NTFloatFunT<Ntuple, T> (nt, p_mem0, name_, offset_);
}                                  


#endif /* #ifndef __NTFLOATFUN_H */

---