JWeightFileScannerSet.hh

Go to the documentation of this file.

#ifndef __JSUPPORT_JWEIGHTFILESCANNERSET__
#define __JSUPPORT_JWEIGHTFILESCANNERSET__

#include <vector>
#include <functional>

#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"

#include "JLang/JException.hh"
#include "JLang/JComparator.hh"

#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JWeightFileScanner.hh"

#include "JAAnet/JHead.hh"
#include "JAAnet/JWeightEventToolkit.hh"

/**
 * \author bjung
 */

namespace JSUPPORT {

  using JAANET::JHead;
  using JLANG::JValueOutOfRange;
  

  /**
   * Auxiliary class for organising Monte Carlo file scanners.
   */
  template<class JFileScanner_t = JMultipleFileScanner<Evt>,
           class JComparator_t  = std::less<JHead> >
  struct JWeightFileScannerSet :
    std::vector< JWeightFileScanner<JFileScanner_t> >
  {
    typedef JWeightFileScanner<JFileScanner_t>                         value_type;

    typedef typename std::vector<value_type>::const_iterator           const_iterator;
    typedef typename std::vector<value_type>::iterator                 iterator;
    typedef typename std::vector<value_type>::const_reverse_iterator   const_reverse_iterator;
    typedef typename std::vector<value_type>::reverse_iterator         reverse_iterator;

    
    /**
     * Default constructor.
     */
    JWeightFileScannerSet()
    {}
    

    /**
     * Constructor.
     *
     * \param  input         file list
     * \param  limit         limit
     */
    JWeightFileScannerSet(JMultipleFileScanner_t& input,
                          JLimit&                 limit = JLimit())
    {
      put     (input);
      setLimit(limit);
    }
    
    
    /**
     * Put file
     *
     * \param  input              file list
     */
    void put(JMultipleFileScanner_t& input)
    {
      for (JMultipleFileScanner_t::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->put(*i);
      }
    }


    /**
     * Put file
     *
     * \param  input              file name
     */
    void put(const std::string& input)
    {
      using namespace std;
      using namespace JPP;
      
      const JHead head = getHeader(input);
      
      iterator p = lower_bound(this->begin(), this->end(), head,
                               make_comparator(&JHead::getHeader, compare));
      
      if (p == this->end()) {
        p = this->insert(p, value_type(getEventWeighter(head)));
      }

      p->put(input);
    }
    

    /**
     * Get file scanner for given header
     *
     * \param  head          header
     * \return               file scanner
     */
    const value_type& get(const JHead& head) const
    {
      for (const_iterator p = this->begin(); p != this->end(); ++p) {
        if (p->match(head, false)) {
          return *p;
        }
      }

      THROW(JValueOutOfRange, "JWeightFileScannerSet::get(): No corresponding scanner found for given header.");
    }


    /**
     * Set limit.
     *
     * \param  limit         limit
     */
    void setLimit(const JLimit& limit)
    {
      for (iterator p = this->begin(); p != this->end(); ++p) {
        p->setLimit(limit);
      }
    }


    /**
     * Function object for comparison of headers.
     */
    JComparator_t compare;
  };
}

#endif