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));
      }
    }
    

    /**
     * Constructor.
     *
     * \param  __begin  begin of 1D data
     * \param  __end    end   of 1D data
     */
    template<class T>
    JSuperFrameClone2D(T __begin,
                       T __end) :
      JModuleHeader(),
      std::vector< JFrameClone<JElement_t> >()
    {
      if (__begin != __end) {

        this->setModuleHeader(JModuleHeader(__begin->getDAQChronometer(),
                                            __begin->getModuleIdentifier(),
                                            __begin->getPosition()));

        for (T i = __begin; i != __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