TrapFilter.hpp

//  TrapFilter.hpp
//
//  Author : Jeromy Tompkins
//  Date   : 8/14/2013

#ifndef TRAPFILTER_H
#define TRAPFILTER_H

#include <iostream>
#include "AlgoIterator.hpp"
#include "SumIterator.hpp"
#include <TObject.h>

namespace TrAnal 
{


template<class T>
class TrapFilter : public AlgoIterator<T>
{
    private:
    SumIterator<T> m_trailsum; 
    SumIterator<T> m_leadsum; 

    private:

    TrapFilter();

    public:
    // Defines the trailing type of sums

    TrapFilter(const TrIterator<T>& begin, int rise_range, int gap_range)
        : AlgoIterator<T>(), 
        m_trailsum(TrRange<T>(begin,rise_range)), 
        m_leadsum(TrRange<T>(begin+rise_range+gap_range,rise_range))
    {}
    

    TrapFilter(const TrRange<T>& trail_range, const TrRange<T>& lead_range)
        : AlgoIterator<T>(), 
        m_trailsum(trail_range), 
        m_leadsum(lead_range)
    {}


    TrapFilter& operator=(const TrapFilter& that) 
    {
        if (this != &that) {
            m_trailsum = that.m_trailsum;
            m_leadsum = that.m_leadsum;
        }

        return *this;
    }


    virtual ~TrapFilter() {}


    virtual TrapFilter& operator++() 
    {
        ++m_trailsum;
        ++m_leadsum;

        return *this;
    }


    TrapFilter operator++(int) 
    {
        SumIterator<T> it = m_trailsum++;
        SumIterator<T> it2= m_leadsum++;
        TrapFilter tmp (TrRange<T>(it.min_extent(),it.max_extent()),
                        TrRange<T>(it2.min_extent(),it2.max_extent()));
        return tmp;
    }
    

    virtual bool operator<(const TrIterator<T>& it) const
    {
        TrIterator<T> max = max_extent();

        return (max<it);
    }


    bool operator>(const TrIterator<T>& it) const
    {
        TrIterator<T> min = min_extent();

        return (min>it);
    }


    virtual TrIterator<T> max_extent() const 
    {
        TrIterator<T> it;
        if (m_trailsum<m_leadsum) {
            it = m_leadsum.max_extent();
        } else {
            it = m_trailsum.max_extent();
        }

        return it;
    }


    virtual TrIterator<T> min_extent() const 
    {
        TrIterator<T> it;
        if (m_trailsum>m_leadsum) {
            it = m_leadsum.min_extent();
        } else {
            it = m_trailsum.min_extent();
        }

        return it;
    }


    virtual double operator*() const { return *m_leadsum - *m_trailsum;}    


    public:
    // ROOT dictionary generation
    ClassDef(TrapFilter,0);

}; // end class

} // end namespace
#endif