BaseCutHelpers.h

Go to the documentation of this file.

#ifndef __BASECUTHELPERS_H
#define __BASECUTHELPERS_H

#include "jbltools/sfh/BaseCut.h"
#include "jbltools/sfh/IntFunBase.h"
#include "jbltools/sfh/FloatFunBase.h"
#include "jbltools/sfh/ROListPoR.h"
#include "jbltools/sfh/BaseCutPoR.h"
#include "jbltools/sfh/FillIteratorPoR.h"
#include "jbltools/sfh/CachedO.h"

#include <vector>


// Class FloatBaseCut:
//  Helper class to create a FloatFun out of a BaseCut
class FloatBaseCut: public FloatFun {
  public:
    explicit FloatBaseCut (const BaseCut& theBaseCut_,  
                           const char *name_ = 0    
                          );
    virtual Float_FF operator() () const { return theBaseCut();} 
    virtual const FillIterator *getIterator() const { 
      return theBaseCut.getIterator(); 
    }
    
  protected:  
    virtual ~FloatBaseCut() {}
    const BaseCut& theBaseCut;                
};

// Class IntBaseCut:
//  Helper class to create a IntFun out of a BaseCut
class IntBaseCut: public IntFun {
  public:
    explicit IntBaseCut (const BaseCut& theBaseCut_,  
                         const char *name_ = 0    
                        );
    virtual int operator() () const { return theBaseCut();} 
    virtual const FillIterator *getIterator() const { 
      return theBaseCut.getIterator(); 
    }
  protected:  
    virtual ~IntBaseCut() {}
    const BaseCut& theBaseCut;                
};

//  Class TwoCutCompound:
//  Helper class for binary logical operations between BaseCut objects
/* 
 * This cut holds pointers to two other cuts.
 * The derived classes AndOfTwoCuts and OrOfTwoCuts implement
 * operator().
 */
class TwoCutCompound : public BaseCut {
  public:
    TwoCutCompound (const BaseCut& lhs_,          
                    const std::string opname_,    
                    const BaseCut& rhs_           
                   );    
    TwoCutCompound (const BaseCut& lhs_,          
                    const BaseCut& rhs_,          
                    const std::string name_       
                    );   
                    
    virtual const FillIterator *getIterator() const;
    
  protected:
    virtual ~TwoCutCompound() {} 
    const BaseCut& lhs;                     
    const BaseCut& rhs;                     
};

//  Class AndOfTwoCuts:
//  Helper class for the implementation of BaseCut && BaseCut
/* 
 * Returns the AND of two cuts.
 * If the value of the first cut is false, the second cut is
 * not evaluated.
 */
class AndOfTwoCuts : public TwoCutCompound {
  public:
    AndOfTwoCuts (const BaseCut& lhs_,    
                  const BaseCut& rhs_     
                  )
      : TwoCutCompound (lhs_, "&&", rhs_) 
      {}
    virtual bool operator() () const {
      return lhs() && rhs();
    };
    
  protected:
    virtual ~AndOfTwoCuts() {}
};

//  Class OrOfTwoCuts:
//  Helper class for the implementation of BaseCut || BaseCut
/* 
 * Returns the OR of two cuts.
 * If the value of the first cut is true, the second cut is
 * not evaluated.
 */
class OrOfTwoCuts : public TwoCutCompound {
  public:
    OrOfTwoCuts (const BaseCut& lhs_,    
                 const BaseCut& rhs_     
                 )
      : TwoCutCompound (lhs_, "||", rhs_) 
      {}
    virtual bool operator() () const {
      return lhs() || rhs();
    }
  protected:
    virtual ~OrOfTwoCuts() {}
};


//  Class OneCutCompound:
//  Helper class for unary logical operations on BaseCut objects
/* 
 * This cut holds a pointer to one other cut.
 * The derived class NotOfACut implements operator().
 */ 
class OneCutCompound : public BaseCut {
  public:
    OneCutCompound (const std::string& funname_,    
                    const BaseCut& arg_             
                    );
    OneCutCompound (const BaseCut& arg_,            
                    const std::string& name_        
                    );
    
    virtual const FillIterator *getIterator() const {  
      return arg.getIterator(); 
    }
    
  protected:
    virtual ~OneCutCompound() {} 

    const BaseCut& arg;                  
};

//  Class NotOfACut:
//  Helper class  for ! BaseCut
/* 
 * Returns NOT of a cut.
 */
class NotOfACut : public OneCutCompound {
  public:
    NotOfACut (const BaseCut& arg_        
              )
    : OneCutCompound ("!", arg_){}
    virtual bool operator() () const {
      return !arg();
    }
  protected:
    virtual ~NotOfACut() {}; 
};


class CachedBaseCut: public BaseCut, public CachedO {
  public:
    CachedBaseCut (const ROListPoR& rol,      
                   const BaseCut&  arg_       
                  );
    CachedBaseCut (const ROListPoR& rol,      
                   const BaseCut&  arg_,      
                   const std::string& name_   
                  );
    
    virtual bool operator() () const;
    
    virtual void invalidateCache() { cacheValid = false; }
    
  protected:
    virtual ~CachedBaseCut() {}
    
    // Data members
    const   BaseCut& arg;         
    mutable bool cacheValid;       
    mutable bool cachedValue;     
};

class CachedBaseCutIt: public BaseCut, public CachedO {
  public:
    CachedBaseCutIt (const ROListPoR&     rol,  
                     const BaseCut&      arg_  
                    );
    CachedBaseCutIt (const ROListPoR&     rol,  
                     const BaseCut&      arg_, 
                     const FillIterator&  iter_ 
                    );
    CachedBaseCutIt (const ROListPoR&     rol,  
                     const BaseCut&      arg_, 
                     const std::string& name_   
                    );
    CachedBaseCutIt (const ROListPoR&     rol,  
                     const BaseCut&      arg_, 
                     const FillIterator&  iter_, 
                     const std::string& name_   
                    );
    
    virtual bool operator() () const;
    
    virtual const FillIterator *getIterator() const { 
      return &iter; 
    }
    
    virtual void invalidateCache() {   
      cacheValid.resize(0);
      cachedValues.resize(0);
    }
    
  protected:
    void growCache (unsigned int s) const;
  
    virtual ~CachedBaseCutIt() {}
    
    // Data members
    const   BaseCut& arg;                      
    const   FillIterator&  iter;                  
    mutable std::vector<bool>  cacheValid;      
    mutable std::vector<bool> cachedValues;    
};




#endif /* #ifndef __BASECUTHELPERS_H */

---