JTreeScannerInterface.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JTREESCANNERINTERFACE__
#define __JSUPPORT__JTREESCANNERINTERFACE__
 
#include "JLang/JObjectIterator.hh"
#include "JLang/JNullType.hh"
#include "JLang/JEquals.hh"
#include "JLang/JBidirectionalIterator.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JLimit.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JLANG::JRewindableObjectIterator;
  using JLANG::JNullType;
  using JLANG::JEquals;
  using JLANG::JBidirectionalIterator;
 
 
  /**
   * Auxiliary interface for direct access of elements in ROOT TChain.
   *
   * The optional second template argument is used to the determine the value of an element
   * which defines the apparent order the elements in the TChain.
   */
  template<class T, class JEvaluator_t = JNullType>
  struct JTreeScannerInterface;
 
  
  /**
   * Specialiation of interface JTreeScannerInterface for unordered direct access of elements in ROOT TChain.
   * 
   * This interface provives for STD compatible iterators.\n
   * Note that a pointer to the parent JTreeScannerInterface is used for the iteration.
   * The user should therefore make separate copies of the read data when multiple iterators are simultaneously used.
   *
   * This interface extends the JLANG::JRewindableObjectIterator interface and the JSUPPORT::JLimit class.
   */
  template<class JClass_t>
  struct JTreeScannerInterface<JClass_t, JNullType> :
    public JRewindableObjectIterator<JClass_t>,
    public JLimit
  {
    typedef JClass_t                                                    data_type;
    typedef typename JRewindableObjectIterator<JClass_t>::pointer_type  pointer_type;
 
    /**
     * Configure.
     *
     * \param  file_list         file list
     * \param  limit             limit
     */
    virtual void configure(const JMultipleFileScanner_t& file_list, const JLimit& limit) = 0;
 
      
    /**
     * Configure.
     *
     * \param  file_list         file list
     */
    void configure(const JMultipleFileScanner_t& file_list)
    {
      this->configure(file_list, JLimit());
    }
 
      
    /**
     * Get number of entries.
     *
     * \return                   number of entries
     */
    virtual Long64_t getEntries() const = 0;
 
 
    /**
     * Get entry at given index.
     *
     * \param  index             index
     * \return                   pointer to object (may be NULL)
     */
    virtual JClass_t* getEntry(Long64_t index) = 0;
 
 
    /**
     * Get internal counter.
     *
     * \return            counter
     */
    virtual counter_type getCounter() const = 0;
    
 
    /**
     * Get actual class name.
     *
     * \return                   class name
     */
    virtual const char* getClassName() const
    {
      return JClass_t::Class_Name();
    }
 
 
    /**
     * STD compatible iterator. 
     */
    struct iterator :
      public JLANG::JEquals               <iterator>,
      public JLANG::JBidirectionalIterator<iterator>
    {
      friend class JTreeScannerInterface;
      
      /**
       * Default constructor.
       */
      iterator() :
        pTreeScanner(NULL),
        index       (-1)
      {}
 
 
      /**
       * Smart pointer operator.
       *
       * \return                 pointer to object
       */
      data_type* operator->()
      { 
        return pTreeScanner->getEntry(index);
      }
 
 
      /**
       * Dereference operator.
       *
       * \return                 reference to object
       */
      data_type& operator*()
      {
        return *(pTreeScanner->getEntry(index));
      }
 
      
      /**
       * Equality of iterator.
       *
       * \param  cursor          iterator
       * \return                 true if equal; else false
       */
      virtual bool equals(const iterator& cursor) const
      {
        return index == cursor.index;
      }
 
 
      /**
       * Increment iterator.
       *
       * \return                 true if valid; else false
       */
      virtual bool increment()
      {
        return ++index < pTreeScanner->getEntries();
      }
 
 
      /**
       * Decrement iterator.
       *
       * \return                 true if valid; else false
       */
      virtual bool decrement()
      {
        return --index >= 0;
      }
 
      
    private:
      /**
       * Constructor.
       *
       * \param  __p             pointer to tree scanner
       * \param  __i             start index
       */
      iterator(JTreeScannerInterface* __p, const counter_type __i) :
        pTreeScanner(__p),
        index       (__i)
      {}
      
      JTreeScannerInterface* pTreeScanner;
      counter_type index;
    };
    
 
    /**
     * STD compatible reverse iterator. 
     */
    struct reverse_iterator :
      public JLANG::JEquals               <reverse_iterator>,
      public JLANG::JBidirectionalIterator<reverse_iterator>
    {
      friend class JTreeScannerInterface;
      
      /**
       * Default constructor.
       */
      reverse_iterator() :
        pTreeScanner(NULL),
        index       (-1)
      {}
 
 
      /**
       * Smart pointer operator.
       *
       * \return                 pointer to object
       */
      const data_type* operator->()
      { 
        return  (this->pTreeScanner->getEntry(this->pTreeScanner->getEntries() - this->index - 1));
      }
 
 
      /**
       * Dereference operator.
       *
       * \return                 reference to object
       */
      const data_type& operator*()
      {
        return *(this->pTreeScanner->getEntry(this->pTreeScanner->getEntries() - this->index - 1));
      }
 
      
      /**
       * Equality of iterator.
       *
       * \param  cursor          iterator
       * \return                 true if equal; else false
       */
      virtual bool equals(const reverse_iterator& cursor) const
      {
        return index == cursor.index;
      }
 
 
      /**
       * Increment iterator.
       *
       * \return                 true if valid; else false
       */
      virtual bool increment()
      {
        return ++index < pTreeScanner->getEntries();
      }
 
 
      /**
       * Decrement iterator.
       *
       * \return                 true if valid; else false
       */
      virtual bool decrement()
      {
        return --index >= 0;
      }
 
      
    private:
      /**
       * Constructor.
       *
       * \param  __p             pointer to tree scanner
       * \param  __i             start index
       */
      reverse_iterator(JTreeScannerInterface* __p, const counter_type __i) :
        pTreeScanner(__p),
        index       (__i)
      {}
      
      JTreeScannerInterface* pTreeScanner;
      counter_type index;
    };
 
 
    /**
     * Check emptyness.
     *
     * \return                 true if empty; else false
     */
    bool empty() const
    {
      return getEntries() == 0;
    }
 
    
    /**
     * Get iterator to begin of data.
     * 
     * \return                 iterator
     */
    iterator begin()
    {
      return iterator(this, this->getLowerLimit());
    }
 
   
    /**
     * Get iterator to end of data.
     *
     * \return                 iterator
     */
    iterator end()
    {
      return iterator(this, this->getUpperLimit() < this->getEntries() ? this->getUpperLimit() : this->getEntries());
    }
 
    
    /**
     * Get reverse iterator to begin of data.
     * 
     * \return                 reverse iterator
     */
    reverse_iterator rbegin()
    {
      return reverse_iterator(this, this->getLowerLimit());
    }
 
   
    /**
     * Get reverse iterator to end of data.
     *
     * \return                 reverse iterator
     */
    reverse_iterator rend()
    {
      return reverse_iterator(this, this->getUpperLimit() < this->getEntries() ? this->getUpperLimit() : this->getEntries());
    }
  };
 
  
  /**
   * Specialiation of interface JTreeScannerInterface for ordered direct access of elements in ROOT TChain.
   * 
   * This interface extends the JTreeScannerInterface<JClass_t, JNullType> interface by
   * defining the additional interface method to find a corresponding entry in the ROOT TChain.
   */
  template<class JClass_t, class JEvaluator_t>
  struct JTreeScannerInterface :
    public virtual JTreeScannerInterface<JClass_t>
  {
    /**
     * Constructor.
     *
     * \param  evaluator         evaluator
     */
    JTreeScannerInterface(const JEvaluator_t& evaluator = JEvaluator_t()) :
      getValue(evaluator)
    {}
 
 
    /**
     * Find index of element that is closest in value to given value.
     *
     * \param  value             value
     * \return                   index (-1 in case of error)
     */
    virtual Long64_t find(const double value) const = 0;
 
 
    /**
     * Find index of element that is closest in value to given object.
     *
     * \param  object            object
     * \return                   index (-1 in case of error)
     */
    template<class T>
    Long64_t find(const T& object) const
    {
      return this->find(getValue(object));
    }
 
 
    /**
     * Get evaluator.
     *
     * \return                   evaluator
     */
    const JEvaluator_t& getEvaluator() const
    {
      return getValue;
    }
 
    
  protected:
    JEvaluator_t getValue;
  };
}
 
#endif