ROList.h

Go to the documentation of this file.

#ifndef __ROLIST_H
#define __ROLIST_H

#include "jbltools/sfh/RegO.h"

#include <TH1.h> // defines Option_t

#include <map>

class HVisitor;
class ConstHVisitor;
class TPad;
class TVirtualPS;
class ROListPoR;

//  Class ROList:

class ROList: public RegO {
    
  public:
    typedef unsigned long long IndexType;
  
  private:  
    enum {LINEAR = 0, LOGY = 1, LOGX = 2, LOGXY = 3};   
    typedef std::map<IndexType, RegO *> MapType;
  public:
    typedef MapType::const_iterator         const_iterator;
    typedef MapType::iterator               iterator;
    typedef MapType::const_reverse_iterator const_reverse_iterator;
    typedef MapType::reverse_iterator       reverse_iterator;
    
  public:
    ROList ();
    ROList (const ROListPoR& mother        
           );
    
    virtual ~ROList ();
                      
    int registerObject (RegO* h          
                       );    
    int registerObject (IndexType n,  
                        RegO* h          
                       );    
    
    virtual void Write ();
    

    virtual ROList& visit (HVisitor& v      
                          );
    virtual ROList& visit (const ConstHVisitor& v);
    

    virtual int Draw (TPad *pad,              
                       TVirtualPS *ps = 0,     
                       Option_t *option = 0,   
                       bool across = true,     
                       Int_t nx = 1,           
                       Int_t ny = 1,           
                       Float_t xmargin = 0.01, 
                       Float_t ymargin = 0.01, 
                       Int_t color = 0,        
                       Int_t log = 0,          
                       bool recursive = false,  
                       int izone = 0            
                      );
    virtual int Draw (TPad *pad,              
                       TVirtualPS *ps,         
                       Option_t *option,       
                       bool across,            
                       Int_t nx,               
                       Int_t ny,               
                       Int_t log,              
                       bool recursive = false,  
                       int izone = 0            
                      );
    

    virtual int DrawFunc (TPad *pad,                    
                       TVirtualPS *ps = 0,              
                       Option_t *option = 0,            
                       const char* fname = "",          
                       bool across = true,              
                       Int_t nx = 1,                    
                       Int_t ny = 1,                    
                       Float_t xmargin = 0.01,          
                       Float_t ymargin = 0.01,          
                       Int_t color = 0,                 
                       Int_t log = 0,                   
                       bool recursive = false,          
                       int izone = 0                    
                      );
    virtual int DrawFunc (TPad *pad,                    
                       TVirtualPS *ps,                  
                       Option_t *option,                
                       const char* fname,               
                       bool across,                     
                       Int_t nx,                        
                       Int_t ny,                        
                       Int_t log,                       
                       bool recursive = false,          
                       int izone = 0                    
                      );
    

    virtual void DrawCutFlow (TPad *pad,              
                              TVirtualPS *ps = 0,     
                              Option_t *option = 0,   
                              Option_t *sameoption = 0, 
                              bool across = true,     
                              Int_t nx = 1,           
                              Int_t ny = 1,           
                              Float_t xmargin = 0.01, 
                              Float_t ymargin = 0.01, 
                              Int_t color = 0,        
                              Int_t log = 0,          
                              bool recursive = false, 
                              bool backward = false   
                             );
    virtual void DrawCutFlow (TPad *pad,              
                              TVirtualPS *ps,         
                              Option_t *option,       
                              Option_t *sameoption,   
                              bool across,            
                              Int_t nx,               
                              Int_t ny,               
                              Int_t log,              
                              bool recursive = false, 
                              bool backward = false   
                             );
    inline IndexType getEntries() const;                  
    inline IndexType getHighestEntry() const;       
    inline IndexType getFirstEntry() const;       
    inline RegO *getEntry(IndexType i       
                             ) const;                  
    inline RegO *getNextEntry(IndexType& i  
                             ) const;     

    inline RegO *getEntry(const_iterator iter       
                         ) const;                  
    inline RegO *getNextEntry(const_iterator& i  
                             ) const;     
                             
    inline iterator begin();
    inline const_iterator begin() const;
    inline iterator end();
    inline const_iterator end() const;
    
    inline reverse_iterator rbegin();
    inline const_reverse_iterator rbegin() const;
    inline reverse_iterator rend();
    inline const_reverse_iterator rend() const;
                             
    inline iterator lower_bound (IndexType i
                                );
    inline const_iterator lower_bound(IndexType i
                                ) const;
    inline iterator upper_bound(IndexType i
                                );
    inline const_iterator upper_bound(IndexType i
                                ) const;
    
    inline IndexType getIndex (iterator iter       
                               ) const;
    inline IndexType getIndex (const_iterator iter       
                               ) const;
                                        
  private:  
    MapType theMap;      
};

// Implementation of inline member functions
ROList::IndexType ROList::getEntries() const { 
  return theMap.size(); 
} 
               
ROList::IndexType ROList::getHighestEntry() const { 
  // theMap.rbegin() is the iterator pointing to the last element in the map
  return (theMap.empty()) ? 0 : rbegin()->first+1;
}                
               
ROList::IndexType ROList::getFirstEntry() const { 
  return (theMap.empty()) ? 0 : begin()->first;
}                

RegO *ROList::getEntry(IndexType i) const {
  const_iterator iter = theMap.find(i);
  return (iter != end()) ? iter->second : 0;
}                 


RegO *ROList::getNextEntry(IndexType& i) const {
  const_iterator iter = theMap.upper_bound(i);
  if (iter != theMap.end()) {
    i = iter->first;
    return iter->second;
  }
  return 0;
}

RegO *ROList::getEntry(ROList::const_iterator iter) const {
  return (iter != end()) ? iter->second : 0;
}                 

RegO *ROList::getNextEntry(ROList::const_iterator& iter) const {
  if (iter == theMap.end()) return 0;
  if (++iter == theMap.end()) return 0;
  return iter->second;
}
  
ROList::iterator ROList::begin() {
  return theMap.begin();
}
ROList::const_iterator ROList::begin() const {
  return theMap.begin();
}
  
ROList::iterator ROList::end() {
  return theMap.end();
}
ROList::const_iterator ROList::end() const {
  return theMap.end();
}
  
ROList::reverse_iterator ROList::rbegin() {
  return theMap.rbegin();
}
ROList::const_reverse_iterator ROList::rbegin() const {
  return theMap.rbegin();
}
  
ROList::reverse_iterator ROList::rend() {
  return theMap.rend();
}
ROList::const_reverse_iterator ROList::rend() const {
  return theMap.rend();
}

ROList::iterator ROList::lower_bound (IndexType i) {
  return theMap.lower_bound(i);
}
ROList::const_iterator ROList::lower_bound(IndexType i) const {
  return theMap.lower_bound(i);
}
ROList::iterator ROList::upper_bound(IndexType i) {
  return theMap.upper_bound(i);
}
ROList::const_iterator ROList::upper_bound(IndexType i) const {
  return theMap.upper_bound(i);
}

ROList::IndexType ROList::getIndex (ROList::iterator iter) const {
  if (iter == theMap.end()) return getHighestEntry();
  return iter->first;
}
ROList::IndexType ROList::getIndex (ROList::const_iterator iter) const {
  if (iter == theMap.end()) return getHighestEntry();
  return iter->first;
}
              
#endif  /* #ifndef __ROLIST_H */

---