IntFun.h

Go to the documentation of this file.

#ifndef __INTFUN_H
#define __INTFUN_H
 
#ifndef __INTFUNBASE_H
#include "jbltools/sfh/IntFunBase.h"
#endif /* #ifndef __INTFUNBASE_H */

#include "jbltools/sfh/BaseCutBase.h"       // needed as base class of IntFunComp
#include "jbltools/sfh/BaseCutPoR.h"        // needed for default argument 
#include "jbltools/sfh/FillIteratorPoR.h"   // needed for default argument 
#include "jbltools/sfh/FloatFunPoR.h"       // needed for default argument 
#include "jbltools/sfh/IntFunPoR.h"          // needed for automagic conversion 
#include "jbltools/sfh/ROListPoR.h"         // needed for automagic conversion 

class FloatFun;

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

    virtual ~ConstIntFun() {} 
};


//  Class IntFunComp:

class  IntFunComp: public BaseCut {
  public:
    IntFunComp (const std::string& name_) : BaseCut (name_) {}
    virtual int lhsValue() const = 0; 
    virtual int rhsValue() const = 0; 
};

// External functions that implement arithmetic operators between
// cut, so that we can write e.g. "funa + (funb * func)"


IntFun& operator+ (const IntFun& lhs_, const IntFun& rhs_);


IntFun& operator+ (int lhs_, const IntFun& rhs_);


IntFun& operator+ (const IntFun& lhs_, int rhs_);


IntFun& operator- (const IntFun& lhs_, const IntFun& rhs_);


IntFun& operator- (int lhs_, const IntFun& rhs_);


IntFun& operator- (const IntFun& lhs_, int rhs_);


IntFun& operator- (const IntFun& arg_);


IntFun& operator+ (IntFun& arg_);
const IntFun& operator+ (const IntFun& arg_);


IntFun& operator* (const IntFun& lhs_, const IntFun& rhs_);


IntFun& operator/ (const IntFun& lhs_, const IntFun& rhs_);


IntFun& operator* (int lhs_, const IntFun& rhs_);


IntFun& operator* (const IntFun& lhs_, int rhs_);


IntFun& operator/ (int lhs_, const IntFun& rhs_);


IntFun& operator/ (const IntFun& lhs_, int rhs_);


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


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


IntFun& operator^ (const IntFun& lhs_, const IntFun& rhs_);


IntFun& operator& (const IntFun& lhs_, int rhs_);


IntFun& operator& (int lhs_, const IntFun& rhs_);


IntFun& operator| (const IntFun& lhs_, int rhs_);


IntFun& operator| (int lhs_, const IntFun& rhs_);


IntFun& operator^ (const IntFun& lhs_, int rhs_);


IntFun& operator^ (int lhs_, const IntFun& rhs_);


IntFun& operator~ (const IntFun&  arg_);


IntFun& square (const IntFun& arg_);


IntFun& abs (const IntFun& arg_);

// External functions that implement comparison operators between
// IntFun objects


IntFunComp& operator< (const IntFun& lhs_, const IntFun& rhs_);

IntFunComp& operator> (const IntFun& lhs_, const IntFun& rhs_);

IntFunComp& operator<= (const IntFun& lhs_, const IntFun& rhs_);

IntFunComp& operator>= (const IntFun& lhs_, const IntFun& rhs_);

IntFunComp& operator== (const IntFun& lhs_, const IntFun& rhs_);

IntFunComp& operator!= (const IntFun& lhs_, const IntFun& rhs_);

// External functions that implement comparison operators between
// a int and a IntFun object

IntFunComp& operator< (int lhs_, const IntFun& rhs_);

IntFunComp& operator<= (int lhs_, const IntFun& rhs_);

IntFunComp& operator> (int lhs_, const IntFun& rhs_);

IntFunComp& operator>= (int lhs_, const IntFun& rhs_);

IntFunComp& operator== (int lhs_, const IntFun& rhs_);

IntFunComp& operator!= (int lhs_, const IntFun& rhs_);

// External functions that implement comparison operators between
// a IntFun object and a int
IntFunComp& operator< (const IntFun& lhs_, int rhs_);

IntFunComp& operator<= (const IntFun& lhs_, int rhs_);

IntFunComp& operator> (const IntFun& lhs_, int rhs_);

IntFunComp& operator>= (const IntFun& lhs_, int rhs_);

IntFunComp& operator== (const IntFun& lhs_, int rhs_);

IntFunComp& operator!= (const IntFun& lhs_, int rhs_);


// External functions that allow chain comparisons like 1 < x < y <= 15
// Such a chain comparison is defined as
// (1 < x) && (x < y) && (y <= 15)

IntFunComp& operator< (const IntFunComp& lhs_, const IntFun& rhs_);

IntFunComp& operator<= (const IntFunComp& lhs_, const IntFun& rhs_);

IntFunComp& operator> (const IntFunComp& lhs_, const IntFun& rhs_);

IntFunComp& operator>= (const IntFunComp& lhs_, const IntFun& rhs_);

IntFunComp& operator== (const IntFunComp& lhs_, const IntFun& rhs_);

IntFunComp& operator!= (const IntFunComp& lhs_, const IntFun& rhs_);

IntFunComp& operator< (const IntFunComp& lhs_, int rhs_);
IntFunComp& operator<= (const IntFunComp& lhs_, int rhs_);
IntFunComp& operator> (const IntFunComp& lhs_, int rhs_);
IntFunComp& operator>= (const IntFunComp& lhs_, int rhs_);
IntFunComp& operator== (const IntFunComp& lhs_, int rhs_);
IntFunComp& operator!= (const IntFunComp& lhs_, int rhs_);

IntFun& max (const IntFunPoRConst&        fun,        
             const BaseCutPoRConst&       cut=0,      
             const FillIteratorPoR&       intiter=0,  
             const FillIteratorPoRConst&  extiter=0   
            );

IntFun& min (const IntFunPoRConst&        fun,        
                    const BaseCutPoRConst&       cut=0,      
                    const FillIteratorPoR&       intiter=0,  
                    const FillIteratorPoRConst&  extiter=0   
                   );

IntFun& sum (const IntFunPoRConst&        fun,        
                    const BaseCutPoRConst&       cut=0,      
                    const FillIteratorPoR&       intiter=0,  
                    const FillIteratorPoRConst&  extiter=0   
                   );

IntFun& count (const BaseCutPoRConst&       cut=0,      
                      const FillIteratorPoR&       intiter=0,  
                      const FillIteratorPoRConst&  extiter=0   
                     );
FloatFun& Float (const IntFun& arg);

IntFun& cached (const ROListPoR&   rol,        
                const IntFunPoR& fun,          
                const FillIteratorPoR& iter=0  
               );

#endif /* #ifndef __INTFUN_H */

---