BaseCut.h

Go to the documentation of this file.

#ifndef __BASECUT_H
#define __BASECUT_H

#include "jbltools/sfh/BaseCutBase.h"
#include "jbltools/sfh/FillIteratorPoR.h"    // needed for default argument 
#include "jbltools/sfh/BaseCutPoR.h"         // needed for automagic conversion 
#include "jbltools/sfh/ROListPoR.h"         // needed for automagic conversion 

class IntFun;
class FloatFun;

// Class ConstBaseCut
class ConstBaseCut : public BaseCut {
  public: 
    explicit ConstBaseCut (bool c_,                 
                           const char *name_ = 0    
                          )
      : BaseCut (name_ ? name_ : str(c_).c_str(), str(c_)), 
        c(c_) 
      {}
    explicit ConstBaseCut (bool c_,                 
                           const std::string& name_         
                      )
      : BaseCut (name_, str(c_)), 
        c(c_) 
      {}      
    virtual bool operator() () const { return c; };
  protected:
    const bool c;                   

    virtual ~ConstBaseCut() {}; 
};

<<<<<<< BaseCut.h
// Class FloatBaseCut:
//  Helper class to create a FloatFun out of a BaseCut
class FloatBaseCut: public FloatFun {
  public:
    FloatBaseCut (const BaseCut& theBaseCut_   
                );
    virtual float operator() () const { return theBaseCut();} 
    virtual const FillIterator *getIterator() const { 
      return theBaseCut.getIterator(); 
    }
    virtual const char *getName() const { return name; }
    
  protected:  
    virtual ~FloatBaseCut() {
      delete[] name;
      name = 0;
    }
    const BaseCut& theBaseCut;                
    char *name;
    
  private:
    FloatBaseCut (const FloatBaseCut& rhs);
    FloatBaseCut& operator= (const FloatBaseCut& rhs);
};

// Class IntBaseCut:
//  Helper class to create a IntFun out of a BaseCut
class IntBaseCut: public IntFun {
  public:
    IntBaseCut (const BaseCut& theBaseCut_   
                );
    virtual int operator() () const { return theBaseCut();} 
    virtual const FillIterator *getIterator() const { 
      return theBaseCut.getIterator(); 
    }
    virtual const char *getName() const { return name; }
    
  protected:  
    virtual ~IntBaseCut() {
      delete[] name;
      name = 0;
    }
    const BaseCut& theBaseCut;                
    char *name;
    
  private:
    IntBaseCut (const IntBaseCut& rhs);
    IntBaseCut& operator= (const IntBaseCut& rhs);
};

//  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 BaseCut& rhs_,    
                    const char *format="TwoCutCompound(%s,%s)"
                    );
    
    virtual const FillIterator *getIterator() const;
    
    virtual const char *getName() const { return name; }
    
  protected:
    virtual ~TwoCutCompound() {
      delete[] name;
      name = 0;
    } 
    const BaseCut& lhs;                     
    const BaseCut& rhs;                     
    char *name;
    
  private:
    TwoCutCompound (const TwoCutCompound& rhs);
    TwoCutCompound& operator= (const TwoCutCompound& 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_, "(%s)&&(%s)") {};
    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_, "(%s)||(%s)") {};
    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 BaseCut& arg_, 
                    const char *format="OneCutCompound(%s)"
                   );
    
    virtual const FillIterator *getIterator() const {  
      return arg.getIterator(); 
    }
    
    virtual const char *getName() const { return name; }
    
  protected:
    virtual ~OneCutCompound() {
      delete[] name;
      name = 0;
    } 

    const BaseCut& arg;                  
    char *name;
    
  private:
    OneCutCompound (const OneCutCompound& rhs);
    OneCutCompound& operator= (const OneCutCompound& rhs);
};

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


class CachedBaseCut: public BaseCut, public CachedO {
  public:
    CachedBaseCut (const ROListPoR& rol,  
                    const BaseCut&  arg_  
                   );
    
    virtual bool operator() () const;
    
    virtual void invalidateCache() { cacheValid = false; }
    
    virtual const char *getName() const { return name; }
    
  protected:
    virtual ~CachedBaseCut() {
      delete[] name;
      name = 0;
    }
    
    // Data members
    const   BaseCut& arg;         
    mutable bool cacheValid;       
    mutable bool cachedValue;     
    char *name;                              
    
  private:
    CachedBaseCut (const CachedBaseCut& rhs);
    CachedBaseCut& operator= (const CachedBaseCut& rhs);
};

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


=======
>>>>>>> 1.16
// External functions that implement logical operators between
// BaseCut objects, so that we can write e.g. "cuta && (cutb || !cutc)"

BaseCut& operator&& (const BaseCut& lhs_, const BaseCut& rhs_);

BaseCut& operator|| (const BaseCut& lhs_, const BaseCut& rhs_);

BaseCut& operator! (const BaseCut& rhs_);

FloatFun& Float (const BaseCut& arg);

IntFun& Int (const BaseCut& arg);

BaseCut& cached (const ROListPoR&   rol,        
                  const BaseCutPoR& cut,        
                  const FillIteratorPoR& iter=0  
                 );


#endif /* #ifndef __BASECUT_H */

---