JTreeReaderObjectIterator.hh

Go to the documentation of this file.

#ifndef __JROOT__JTREEREADEROBJECTITERATOR__
#define __JROOT__JTREEREADEROBJECTITERATOR__
 
#include "TFile.h"
#include "TError.h"
 
#include "JLang/JObjectIterator.hh"
#include "JROOT/JTreeReader.hh"
#include "JROOT/JTreeParameters.hh"
#include "JROOT/JCounter.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JRewindableObjectIterator;
  using JLANG::JAccessibleObjectIterator;
  using JLANG::skip_type;
  
 
  /**
   * JTreeReader object iterator.
   *
   * This class implements the JLANG::JRewindableObjectIterator interface.
   */
  template<class T>
  class JTreeReaderObjectIterator :
    public virtual JRewindableObjectIterator<T>,
    public JTreeReader<T>
  {
  public:
 
    typedef typename JRewindableObjectIterator<T>::pointer_type  pointer_type;
 
    
    /**
     * Default constructor.
     */
    JTreeReaderObjectIterator() :
      JTreeReader<T>(getTreeParameters<T>()),
      counter(0)
    {
      gErrorIgnoreLevel = kError;
    }
 
 
    /**
     * Rewind.
     */
    virtual void rewind()
    {
      counter = 0;
    }
 
 
    /**
     * Check availability of next element.
     *
     * \return            true if the iteration has more elements.
     */
    virtual bool hasNext() 
    {
      if (this->is_valid()) 
        return counter < this->get()->GetEntries();
      else
        return false;
    }
 
 
    /**
     * Get next element.
     *
     * \return            pointer to element.
     */
    virtual const pointer_type& next() 
    {
      static pointer_type ps;
      
      if (hasNext()) {
 
        this->get()->GetEvent(counter++);
 
        ps.reset(this->getAddress());
 
      } else {
 
        ps.reset(NULL);
      }
 
      return ps;
    }
 
 
    /**
     * Skip items.
     *
     * \param  ns         number of items to skip
     * \return            number of items skipped
     */
    virtual skip_type skip(const skip_type ns)
    {
      if (this->is_valid()) {
        return advance(counter, ns, this->get()->GetEntries());
      }
 
      return 0;
    }
 
 
    /**
     * Get internal counter.
     *
     * \return            counter
     */
    counter_type getCounter() const
    {
      return counter;
    }
    
  protected:
    counter_type counter;
  };
 
 
  /**
   * JTemplateTreeReader object iterator.
   *
   * This class extends the JTreeReaderObjectIterator class and
   * implements the JLANG::JAccessibleObjectIterator interface.
   */
  template<class T>
  class JTreeReaderAccessibleObjectIterator :
    public JAccessibleObjectIterator<T>,
    public JTreeReaderObjectIterator<T>
  {
  public:
    /**
     * Default constructor.
     */
    JTreeReaderAccessibleObjectIterator()
    {}
 
 
    /**
     * Check is file is open.
     *
     * \return                 true if open; else false
     */
    virtual bool is_open() const
    {
      if (this->is_valid()) {
 
        const TFile* file = this->get()->GetCurrentFile();
 
        return (file != NULL && file->IsOpen());
      }
 
      return false;
    }
 
 
    /**
     * Open file.
     *
     * \param  file_name      file name
     */
    virtual void open(const char* file_name)
    {
      this->load(TFile::Open(file_name));
      this->rewind();
    }
 
 
    /**
     * Close file.
     */
    virtual void close()
    {
      if (this->is_valid()) {
 
        const TFile* file = this->get()->GetCurrentFile();
 
        if (file != NULL) {
          delete file;
        }
      }
 
      this->reset();
    }
  };
}
 
#endif