#ifndef __JTRIGGER__JCLONE__
#define __JTRIGGER__JCLONE__

#include <algorithm>

#include "JLang/JClass.hh"
#include "JTrigger/JHitToolkit.hh"


/**
 * \author mdejong
 */

namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }

namespace JTRIGGER {
  
  /**
   * Clone of a container.
   *
   * A JClone object contains a reference to container data and can be used as any normal container.
   * It comprises in addition an internal iterator which is implemented as mutable data member.
   *
   * The methods 
   *   - JClone::is_valid, 
   *   - JClone::rewind, 
   *   - JClone::next, 
   *   - JClone::lower_bound, 
   *   - JClone::fast_forward and 
   *   - JClone::get 
   *
   * can be used to check, set and access the internal iterator.
   *
   * The data in the original container should have been terminated with an appriopriate end marker.
   */
  template<class JContainer_t>
  class JClone :
    public JHitToolkit<typename JContainer_t::value_type>
  {
  public:

    typedef typename JContainer_t::value_type                   value_type;
    typedef typename JLANG::JClass<value_type>::argument_type   argument_type;
    typedef typename JContainer_t::const_iterator               const_iterator;
    typedef typename JContainer_t::const_iterator               iterator;
    
    using JHitToolkit<value_type>::getT;
    using JHitToolkit<value_type>::getToT;
    using JHitToolkit<value_type>::getJHit;
    using JHitToolkit<value_type>::getTimeDifference;


    /**
     * Default constructor.
     */
    JClone() :
      JHitToolkit<value_type>(),
      __begin(),
      __end  (),
      __i    ()
    {}


    /**
     * Constructor.
     *
     * \param  input          input
     */
    JClone(const JContainer_t& input) :
      JHitToolkit<value_type>(),
      __begin(input.begin()),
      __end  (input.end  ()),
      __i    (input.begin())
    {}
    

    /**
     * Get begin of data.
     *
     * \return                begin of data
     */
    iterator begin() const 
    { 
      return __begin; 
    }


    /**
     * Get end of data.
     *
     * \return                end of data
     */
    iterator end() const
    {
      return __end; 
    }
    

    /**
     * Get size of data.
     *
     * \return                size of data
     */
    inline unsigned int size() const 
    { 
      return std::distance(__begin, __end); 
    }


    /**
     * Check size of data.
     *
     * \return                true if empty; else false
     */
    inline bool empty() const 
    {
      return __begin == __end; 
    }

 
    /**
     * Rewind internal iterator.
     */
    inline void rewind() const 
    {
      __i = __begin;
    }

 
    /**
     * Check internal iterator.
     *
     * \return                true if internal iterator not yet at end; else false
     */
    inline bool is_valid() const
    {
      return __i != __end;
    }

 
    /**
     * Increment internal iterator.
     */
    inline void next() const 
    {
      ++__i;
    }


    /**
     * Get internal iterator.
     *
     * \return                internal operator
     */ 
    inline iterator get() const 
    {
      return __i;
    }


    /**
     * Get time of internal iterator.
     *
     * \return                time of internal iterator [ns]
     */
    inline double getT() const 
    { 
      return getT(*__i); 
    }


    /**
     * Get time-over-threshold of internal iterator.
     *
     * \return                time-over-threshold of hit [ns]
     */
    inline double getToT() const
    {
      return getToT(*__i);
    }


    /**
     * Construct JHit from internal iterator.
     *
     * \return                hit
     */
    inline JHit getJHit() const
    {
      return getJHit(*__i);
    }


    /**
     * Get time difference with respect to given hits.
     *
     * \param  hit            hit
     * \return                time of internal iterator - time hit [ns]
     */
    inline double getTimeDifference(argument_type hit) const
    {
      return getTimeDifference(hit, *__i);
    }


    /**
     * Set the internal iterator to the lower bound corresponding to the time of the given hit.
     *
     * \param  hit            hit
     * \return                internal operator
     */
    inline iterator lower_bound(argument_type hit) const
    {
      return (__i = std::lower_bound(__begin, __end, hit, this->getToolkit()));
    }


    /**
     * Increment the internal iterator until the lower bound corresponding to the time of the given hit.
     *
     * \param  hit            hit
     * \return                internal operator
     */
    inline iterator fast_forward(argument_type hit) const
    {
      while (JHitToolkit<value_type>::getT(*__i) < 
	     JHitToolkit<value_type>::getT(hit)) {
	++__i;
      }

      return __i;
    }


  protected:
    iterator __begin;
    iterator __end;
    mutable iterator __i;
  };
}

#endif