JSuperFrameClone2D.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JSUPERFRAMECLONE2D__
#define __JTRIGGER__JSUPERFRAMECLONE2D__
 
#include <vector>
 
#include "JTrigger/JModuleHeader.hh"
#include "JTrigger/JFrameClone.hh"
#include "JTrigger/JSuperFrame2D.hh"
#include "JTrigger/JHitToolkit.hh"
#include "JLang/JClass.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
namespace JTRIGGER {
 
  /**
   * Clone of JSuperFrame2D.
   */
  template<class JElement_t>
  class JSuperFrameClone2D :
    public JModuleHeader,
    public std::vector< JFrameClone<JElement_t> >,
    public JHitToolkit<JElement_t>
  {
  public:
 
    typedef typename JLANG::JClass<JElement_t>::argument_type            argument_type;
    typedef JFrameClone<JElement_t>                                      value_type;
    typedef typename std::vector<value_type>::iterator                   iterator;
    typedef typename std::vector<value_type>::const_iterator             const_iterator;
    typedef typename std::vector<value_type>::reverse_iterator           reverse_iterator;
    typedef typename std::vector<value_type>::const_reverse_iterator     const_reverse_iterator;
 
 
    /**
     * Default constructor.
     */
    JSuperFrameClone2D() :
      JModuleHeader(),
      std::vector< JFrameClone<JElement_t> >()
    {}
    
 
    /**
     * Constructor.
     *
     * \param  input    2-dimensional super frame
     */
    JSuperFrameClone2D(const JSuperFrame2D<JElement_t>& input) :
      JModuleHeader(input.getModuleHeader()),
      std::vector< JFrameClone<JElement_t> >()
    {
      for (typename JSuperFrame2D<JElement_t>::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->push_back(JFrameClone<JElement_t>(*i));
      }
    }
 
 
    /**
     * Rewind internal iterators.
     */
    inline void rewind() const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        i->rewind();
      }
    }
 
 
    /**
     * Set the internal iterators to the lower bounds corresponding to the time of the given hit.
     *
     * \param  hit            hit
     */
    void lower_bound(argument_type hit) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        i->lower_bound(hit);
      }
    }
 
 
    /**
     * Increment the internal iterators until the lower bounds corresponding to the time of the given hit.
     *
     * \param  hit            hit
     */
    void fast_forward(argument_type hit) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        i->fast_forward(hit);
      }
    }
  };
}
 
#endif