VectorIterator.h

Go to the documentation of this file.

#ifndef __VECTORITERATOR_H
#define __VECTORITERATOR_H

#include "jbltools/sfh/FloatFun.h"
#include "jbltools/sfh/FillIterator.h"

#include <vector>

#if (DEBUG>0) 
#include <iostream>
#endif /* #if (DEBUG>0)  */


template <class Row, class Member=float>
class VectorFloatFun: public FloatFun {
  public:
    VectorFloatFun (const std::vector<Row>& theVector_, 
                    Member Row::* p_mem_,          
                    const FillIterator& iter_,     
                    const char* name_ = "?"        
                    )
      : FloatFun (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorFloatFun: created '" << getName() << "'\n";
#endif
      }
    
    Float_FF operator() () const
      { return theVector[iter()].*p_mem; }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorFloatFun() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member Row::*       p_mem;        

   const FillIterator& iter;         
};


template <class Row, class Member=float>
class VectorFloatFunFun: public FloatFun {
  public:
    VectorFloatFunFun (const std::vector<Row>& theVector_,    
                       Member (Row::* p_mem_)() const,          
                       const FillIterator& iter_,         
                       const char* name_ = "?"        
                    )
      : FloatFun (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorFloatFunFun: created '" << getName() << "'\n";
#endif
      }
    
    Float_FF operator() () const
      { return (theVector[iter()].*p_mem)(); }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorFloatFunFun() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member (Row::* p_mem)() const;    

    const FillIterator& iter;         
};


template <class Row, class Member=float, class Arg=float>
class VectorFloatFunFunArg: public FloatFun {
  public:
    VectorFloatFunFunArg (const std::vector<Row>& theVector_,    
                    Member (Row::* p_mem_)(Arg) const,      
                    Arg arg_,                               
                    const FillIterator& iter_,              
                    const char* name_ = "?"                 
                    )
      : FloatFun (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        arg(arg_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorFloatFunFunArg: created '" << getName() << "'\n";
#endif
      }
    
    Float_FF operator() () const
      { return (theVector[iter()].*p_mem)(arg); }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorFloatFunFunArg() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member (Row::* p_mem)(Arg) const;   
          Arg arg;                      

    const FillIterator& iter;         
};


template <class Row, class Member=int>
class VectorIntFun: public IntFun {
  public:
    VectorIntFun (const std::vector<Row>& theVector_,    
                    Member Row::* p_mem_,               
                    const FillIterator& iter_,    
                    const char* name_ = "?"       
                    )
      : IntFun (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorIntFun: created '" << getName() << "'\n";
#endif
      }
    
    int operator() () const
      { return theVector[iter()].*p_mem; }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorIntFun() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member Row::*       p_mem;        

    const FillIterator& iter;         
};


template <class Row, class Member=int>
class VectorIntFunFun: public IntFun {
  public:
    VectorIntFunFun (const std::vector<Row>& theVector_,    
                    Member (Row::* p_mem_)() const,        
                    const FillIterator& iter_,       
                    const char* name_ = "?"        
                    )
      : IntFun (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorFloatFunFun: created '" << getName() << "'\n";
#endif
      }
    
    int operator() () const
      { return (theVector[iter()].*p_mem)(); }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorIntFunFun() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member (Row::* p_mem)() const;    

    const FillIterator& iter;         
};


template <class Row, class Member=int, class Arg=int>
class VectorIntFunFunArg: public IntFun {
  public:
    VectorIntFunFunArg (const std::vector<Row>& theVector_,    
                    Member (Row::* p_mem_)(Arg) const,        
                    Arg arg_,                             
                    const FillIterator& iter_,       
                    const char* name_ = "?"        
                    )
      : IntFun (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        arg(arg_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorIntFunFunArg: created '" << getName() << "'\n";
#endif
      }
    
    int operator() () const
      { return (theVector[iter()].*p_mem)(arg); }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorIntFunFunArg() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member (Row::* p_mem)(Arg) const;   
          Arg arg;                      

    const FillIterator& iter;         
};


template <class Row, class Member=bool>
class VectorBaseCut: public BaseCut {
  public:
    VectorBaseCut (const std::vector<Row>& theVector_,    
                    Member Row::* p_mem_,                
                    const FillIterator& iter_,     
                    const char* name_ = "?"        
                    )
      : BaseCut (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorBaseCut: created '" << getName() << "'\n";
#endif
      }
    
    bool operator() () const
      { return theVector[iter()].*p_mem; }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorBaseCut() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member Row::*       p_mem;        

   const FillIterator& iter;         
};


template <class Row, class Member=float>
class VectorBaseCutFun: public BaseCut {
  public:
    VectorBaseCutFun (const std::vector<Row>& theVector_,    
                      Member (Row::* p_mem_)() const,       
                      const FillIterator& iter_,      
                      const char* name_ = "?"         
                     )
      : BaseCut (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorBaseCutFun: created '" << getName() << "'\n";
#endif
      }
    
    bool operator() () const
      { return (theVector[iter()].*p_mem)(); }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorBaseCutFun() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member (Row::* p_mem)() const;    

    const FillIterator& iter;        
};


template <class Row, class Member=float, class Arg=bool>
class VectorBaseCutFunArg: public BaseCut {
  public:
    VectorBaseCutFunArg (const std::vector<Row>& theVector_,    
                         Member (Row::* p_mem_)(Arg) const,      
                         Arg arg_,                         
                         const FillIterator& iter_,      
                         const char* name_ = "?"         
                        )
      : BaseCut (std::string(name_ ? name_ : "?")+'['+iter_.getName()+']'),
        theVector (theVector_), 
        p_mem (p_mem_), 
        arg(arg_), 
        iter (iter_)
      {
        assert (&theVector); 
        assert (&iter); 
#if (DEBUG>0) 
        std::cout << "VectorBaseCutFunArg: created '" << getName() << "'\n";
#endif
      }
    
    bool operator() () const
      { return (theVector[iter()].*p_mem)(arg); }

    virtual const FillIterator *getIterator() const { return &iter; }
                    
  protected:
    virtual ~VectorBaseCutFunArg() {}
    
    // Data members
    const std::vector<Row>&    theVector;    
          Member (Row::* p_mem)(Arg) const;   
          Arg arg;                      

    const FillIterator& iter;        
};



template <class Row>
class VectorIterator: public FillIterator {
  public:
    explicit VectorIterator (const std::vector<Row>& theVector_,  
                             const char* name_ = "?"        
                            )
      : FillIterator (std::string(name_ ? name_ : "?")),
        theVector(theVector_), 
        index (0)
      { 
        assert (&theVector); 
#if (DEBUG>0) 
        std::cout << "VectorIterator: created '" << getName() << "'\n";
#endif
      }

    virtual int operator() () const {
      return index;
    }

    virtual bool next() {
      return (++index < theVector.size());
    }

    virtual bool reset() {
      return ((index = 0) < theVector.size());
    }
    
    virtual bool isValid() const {
      return (index >= 0) && (index < theVector.size());
    }              
    

    template <class Member>
    VectorFloatFun<Row, Member>& Float(Member Row::* p_mem,
                                 const char *name_ = "?"
                                ) const {
      return *new VectorFloatFun<Row, Member> (theVector, p_mem, *this, name_);
    }
    

    template <class Member>
    VectorFloatFunFun<Row, Member>& Float(Member (Row::* p_mem)() const,
                                    const char *name_ = "?"
                                   ) const {
      return *new VectorFloatFunFun<Row, Member> (theVector, p_mem, *this, name_);
    }
    

    template <class Member, class Arg>
    VectorFloatFunFunArg<Row, Member, Arg>& Float(Member (Row::* p_mem)(Arg) const,
                                          Arg arg_,
                                          const char *name_ = "?"
                                         ) const {
      return *new VectorFloatFunFunArg<Row, Member, Arg> (theVector, p_mem, arg_, *this, name_);
    }
  

    template <class Member>
    VectorIntFun<Row, Member>& Int(Member Row::* p_mem,
                             const char *name_ = "?"
                            ) const {
      return *new VectorIntFun<Row, Member> (theVector, p_mem, *this, name_);
    }
    

    template <class Member>
    VectorIntFunFun<Row, Member>& Int(Member (Row::* p_mem)() const,
                                const char *name_ = "?"
                               ) const {
      return *new VectorIntFunFun<Row, Member> (theVector, p_mem, *this, name_);
    }
    

    template <class Member, class Arg>
    VectorIntFunFunArg<Row, Member, Arg>& Int(Member (Row::* p_mem)(Arg) const,
                                          Arg arg_,
                                const char *name_ = "?"
                               ) const {
      return *new VectorIntFunFunArg<Row, Member, Arg> (theVector, p_mem, arg_, *this, name_);
    }
  

    template <class Member>
    VectorBaseCut<Row, Member>& Bool(Member Row::* p_mem,
                               const char *name_ = "?"
                              ) const {
      return *new VectorBaseCut<Row, Member> (theVector, p_mem, *this, name_);
    }


    template <class Member>
    VectorBaseCutFun<Row, Member>& Bool(Member (Row::* p_mem)() const,
                                  const char *name_ = "?"
                                 ) const {
      return *new VectorBaseCutFun<Row, Member> (theVector, p_mem, *this, name_);
    }

    template <class Member, class Arg>
    VectorBaseCutFunArg<Row, Member, Arg>& Bool(Member (Row::* p_mem)(Arg) const,
                                              Arg arg_,
                              const char *name_ = "?"
                                 ) const {
      return *new VectorBaseCutFunArg<Row, Member, Arg> (theVector, p_mem, arg_, *this, name_);
    }
    
  protected:  
    virtual ~VectorIterator() {}
    
    // Data members
    const std::vector<Row>& theVector;    
    unsigned int     index;        
};

#endif /* #ifndef __VECTORITERATOR_H */

---