JMultipleFileScanner.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JMULTIPLEFILESCANNER__
#define __JSUPPORT__JMULTIPLEFILESCANNER__
 
#include <string>
#include <vector>
#include <limits>
 
#include "TChain.h"
#include "TChainElement.h"
 
#include "JLang/JObjectIterator.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JNullType.hh"
#include "JLang/JMultiEquals.hh"
#include "JLang/JException.hh"
 
#include "JSupport/JLimit.hh"
#include "JSupport/JFileScanner.hh"
 
 
/**
 * \file
 * Scanning of objects from multiple files according a format that follows from the extension of each file name.
 * \author mdejong
 */
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JLANG::JRewindableObjectIterator;
  using JLANG::JPointer;
  using JLANG::JTypeList;
  using JLANG::JTYPELIST;
  using JLANG::JNullType;
  using JLANG::JMultiEquals;
  using JLANG::skip_type;
  using JLANG::JException;
 
 
  /**
   * Auxiliary base class for list of file names.
   */
  struct JMultipleFileScanner_t :
    public std::vector<std::string>     
  {
    /**
     * Default constructor.
     */
    JMultipleFileScanner_t()
    {}
 
    
    /**
     * Constructor.
     *
     * \param  file_name        file name
     */
    JMultipleFileScanner_t(const std::string& file_name) :
      std::vector<std::string>(1, file_name)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  chain            ROOT chain
     */
    JMultipleFileScanner_t(const TChain& chain) 
    {
      setFilelist(chain);
    }
 
 
    /**
     * Get file list.
     *
     * \return                  list of file names
     */
    const JMultipleFileScanner_t& getFilelist() const
    {
      return static_cast<const JMultipleFileScanner_t&>(*this);
    }
 
 
    /**
     * Get file list.
     *
     * \return                  list of file names
     */
    JMultipleFileScanner_t& getFilelist()
    {
      return static_cast<JMultipleFileScanner_t&>(*this);
    }
    
 
    /**
     * Set file list.
     *
     * \param  file_list        list of file names
     */
    void setFilelist(const JMultipleFileScanner_t& file_list)
    {
      static_cast<JMultipleFileScanner_t&>(*this) = file_list;
    }
    
 
    /**
     * Set file list.
     *
     * \param  chain            ROOT chain
     */
    void setFilelist(const TChain& chain)
    {
      this->clear();
      
      const TObjArray* array = chain.GetListOfFiles();
 
      for (Int_t i = 0; i != array->GetEntries(); ++i) {
 
        const TChainElement* p = (const TChainElement*) array->At(i);
        
        this->push_back(p->GetTitle());
      }
    }
    
 
    /**
     * Read file list from input.
     *
     * \param  in               input stream
     * \param  object           file list
     * \return                  input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JMultipleFileScanner_t& object)
    {
      for (std::string buffer; in >> buffer; ) {
        object.push_back(buffer.c_str());
      }
 
      return in;
    }
 
 
    /**
     * Write file list to output.
     *
     * \param  out              output stream
     * \param  object           file list
     * \return                  output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JMultipleFileScanner_t& object)
    {
      for (const_iterator i = object.begin(); i != object.end(); ++i) {
        out << *i << std::endl;
      }
 
      return out;
    }
  };
 
  
  /**
   * General purpose class for object reading from a list of file names.
   */
  template<class T = JNullType>
  class JMultipleFileScanner;
 
 
  /**
   * Template specialisation of JMultipleFileScanner for undefined type.\n
   * This specialisation is used as a virtual base class for all implementations of JMultipleFileScanner for defined type(s).\n
   * The method JMultipleFileScanner::configure should be used to set the internal parameters.
   *
   * This class is a simple container for a list of file names and has an additional counter limit by extending from JSUPPORT::JLimit.\n
   * This counter limit will be used to limit the number of calls to the method <tt>next</tt> of the derived class.\n
   * Note that the counter limit can only be set via the member or friend methods of class JSUPPORT::JLimit.
   */
  template<>
  class JMultipleFileScanner<JNullType> :
    public JMultipleFileScanner_t,
    public JLimit,
    public JMultiEquals<JMultipleFileScanner<JNullType>,
                        JTYPELIST<JLimit, JMultipleFileScanner_t>::typelist>
  {
  public:
 
    typedef JMultipleFileScanner_t                               input_type;
    
    /**
     * Default constructor.
     */
    JMultipleFileScanner() 
    {}
 
    
    /**
     * Virtual destructor.
     */
    virtual ~JMultipleFileScanner()
    {}
 
    
    /**
     * Configure.
     *
     * \param  input             list of file names
     * \param  limit             limit
     */
    void configure(const input_type& input, const JLimit& limit)
    {
      this->setFilelist(input);
      this->setLimit   (limit);
    }
    
 
    /**
     * Read multiple file scanner from input.
     *
     * Note that only file names are read.
     *
     * \param  in               input stream
     * \param  object           multiple file scanner
     * \return                  input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JMultipleFileScanner& object)
    {
      return in >> object.getFilelist();
    }
 
 
    /**
     * Write multiple file scanner to output.
     *
     * Note that only file names are written.
     *
     * \param  out              output stream
     * \param  object           multiple file scanner
     * \return                  output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JMultipleFileScanner& object)
    {
      return out << object.getFilelist();
    }
  }; 
 
 
  /**
   * Implementation of object reading for single data type from a list of file names.
   *
   * This class extends the JMultipleFileScanner<JNullType> class and 
   * implements the JLANG::JRewindableObjectIterator interface.\n
   * When the method hasNext() is called,
   * the next file in the list is opened when the previous file is exhausted.
   */
  template<class T>
  class JMultipleFileScanner :
    public virtual JMultipleFileScanner<>,
    public JRewindableObjectIterator<T>
  {
  public:
 
    typedef JMultipleFileScanner<>::input_type                   input_type;
    typedef typename JRewindableObjectIterator<T>::pointer_type  pointer_type;
    
    /**
     * Default constructor.
     */
    JMultipleFileScanner() :
      index  (0),
      counter(0)
    {}
 
    
    /**
     * Copy constructor.
     *
     * Note that the counter limit is not copied and the index and counter are set to zero.
     *
     * \param  input            input
     */
    template<class JTypelist_t>
    JMultipleFileScanner(const JMultipleFileScanner<JTypelist_t>& input) :
      index  (0),
      counter(0)
    {
      this->configure(input.getFilelist(), JLimit());
    }
 
 
    /**
     * Constructor.
     *
     * \param  file_list        list of file names
     * \param  limit            limit
     */
    JMultipleFileScanner(const input_type& file_list, const JLimit& limit = JLimit()) :
      index  (0),
      counter(0)
    {
      configure(file_list, limit);
    }
 
 
    /**
     * Get current file name.
     *
     * Note that this method should only be called when method hasNext() returns true.
     *
     * \return                  file name
     */
    const std::string& getFilename() const 
    {
      return this->at(index);
    }
 
 
    /**
     * Get counter.
     *
     * \return                  counter
     */
    counter_type getCounter() const
    {
      return counter;
    }
 
 
    /**
     * Rewind.
     */
    virtual void rewind() 
    {
      if (scanner.is_open()) {
        scanner.close();
      }
 
      index   = 0;
      counter = 0;
 
      scanner.reset();
    }
 
 
    /**
     * Check availability of next element.
     *
     * \return                  true if the iteration has more elements; else false
     */
    virtual bool hasNext() 
    {
      if (is_valid()) {
 
        if (counter < getUpperLimit() && index != this->size()) {
 
          // first time around
 
          if (!scanner.is_open()) {
            scanner.open(getFilename().c_str());
          }
          
          if (counter < getLowerLimit()) {
            counter += scanner.skip(getLowerLimit() - counter);
          }     
 
          if (!scanner.hasNext()) {
            
            scanner.close();
            
            ++index;
            
            return hasNext();
          }
 
          return true;
 
        } else {
 
          // last time around
 
          if (scanner.is_open()) {
            scanner.close();
          }
 
          scanner.reset();
        }
      }
 
      return false;
    }
 
 
    /**
     * Get next element.
     *
     * \return                  pointer to element
     */
    virtual const pointer_type& next() 
    {
      ++counter;
 
      return scanner.next();
    }
 
 
    /**
     * Skip items.
     *
     * \param  ns               number of items to skip
     * \return                  number of items skipped
     */
    virtual skip_type skip(const skip_type ns)
    {
      skip_type i = 0;
 
      while (this->hasNext() && i != ns) {
        i += scanner.skip(ns - i);
      }
 
      counter += i;
 
      return i;
    }
 
 
  protected:
    JFileScanner<T> scanner;
    unsigned int    index;
    counter_type    counter;
  }; 
 
 
  /**
   * Implementation of object reading for multiple data types from a list of file names.
   *
   * This class recursively implements the JLANG::JRewindableObjectIterator interface
   * for all data types by deriving from:
   *  - JMultipleFileScanner<JHead_t>; and 
   *  - JMultipleFileScanner<JTail_t>.
   *
   * The method rewind(), rewinds each object iterator.
   */
  template<class JHead_t, class JTail_t>
  class JMultipleFileScanner< JTypeList<JHead_t, JTail_t> > :
    public virtual JMultipleFileScanner<>,
    public JRewindableObjectIterator< JTypeList<JHead_t, JTail_t> >,
    public JMultipleFileScanner<JHead_t>,
    public JMultipleFileScanner<JTail_t>
  {
  public:
 
    typedef JMultipleFileScanner<>::input_type                   input_type;
 
    using JMultipleFileScanner<JHead_t>::hasNext;
    using JMultipleFileScanner<JHead_t>::next;
 
 
    /**
     * Default constructor.
     */
    JMultipleFileScanner() :
      JMultipleFileScanner<>()
    {}
 
    
    /**
     * Copy constructor.
     *
     * Note that the counter limit is not copied and the index and counter are set to zero.
     *
     * \param  input            input
     */
    template<class JTypelist_t>
    JMultipleFileScanner(const JMultipleFileScanner<JTypelist_t>& input)
    {
      this->configure(input.getFilelist(), JLimit());
    }
 
 
    /**
     * Constructor.
     *
     * \param  file_list        list of file names
     * \param  limit            limit
     */
    JMultipleFileScanner(const input_type& file_list, const JLimit& limit = JLimit()) 
    {
      this->configure(file_list, limit);
    }
 
 
    /**
     * Rewind.\n
     * This method rewinds the JMultipleFileScanner for each data type.
     */
    virtual void rewind()
    {
      JMultipleFileScanner<JHead_t>::rewind();
      JMultipleFileScanner<JTail_t>::rewind();
    }
 
    
    /**
     * Skip items.
     *
     * \param  ns               number of items to skip
     * \return                  number of items skipped
     */
    virtual skip_type skip(const skip_type ns)
    {
      if (JMultipleFileScanner<JHead_t>::skip(ns) == ns &&
          JMultipleFileScanner<JTail_t>::skip(ns) == ns) 
        return ns;
      else
        throw JException("JMultipleFileScanner::skip(): inconsistent number of items skipped.");
    }  
  };
 
 
  /**
   * Terminator class of recursive JMultipleFileScanner class.
   */
  template<class JHead_t>
  class JMultipleFileScanner< JTypeList<JHead_t, JNullType> > :
    public JMultipleFileScanner<JHead_t>
  {
  public:
 
    typedef JMultipleFileScanner<>::input_type                   input_type;
 
    /**
     * Default constructor.
     */
    JMultipleFileScanner() :
      JMultipleFileScanner<JHead_t>()
    {}
 
    
    /**
     * Copy constructor.
     *
     * Note that the counter limit is not copied and the index and counter are set to zero.
     *
     * \param  input            input
     */
    template<class JTypelist_t>
    JMultipleFileScanner(const JMultipleFileScanner<JTypelist_t>& input)
    {
      this->configure(input.getFilelist(), JLimit());
    }
 
 
    /**
     * Constructor.
     *
     * \param  file_list        list of file names
     * \param  limit            limit
     */
    JMultipleFileScanner(const input_type& file_list, const JLimit& limit = JLimit()) 
    {
      this->configure(file_list, limit);
    }
  };
}
 
#endif