TrIterator.hpp

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

#ifndef TRITERATOR_H
#define TRITERATOR_H

#include <cstddef>
#include "TObject.h"

namespace TrAnal
{


template<class T>
class TrIterator // functions as though it inherits from std::iterator< ::std::input_iterator_tag,T>
{
    public:
    typedef T value_type;
    typedef ptrdiff_t difference_type;
    typedef T* pointer;
    typedef T& reference;
    typedef std::input_iterator_tag iterator_category;

    private:
    const T* m_iter;
    
    public:

    TrIterator(const T* iter=0) : m_iter(iter) {}
    

    TrIterator(const TrIterator& iter) : m_iter(iter.m_iter) {}


    TrIterator& operator=(const TrIterator& iter) {
        if (this != &iter) {
            m_iter = iter.m_iter;
        }
        return *this;
    }

    // support boolean comparison
    bool operator==(const TrIterator& iter) const { return m_iter==iter.m_iter;} 
    bool operator!=(const TrIterator& iter) const { return m_iter!=iter.m_iter;} 

    bool operator<(const TrIterator& iter) const { return m_iter<iter.m_iter;}
    bool operator<=(const TrIterator& iter) const { return m_iter<=iter.m_iter;}
    bool operator>(const TrIterator& iter) const { return m_iter>iter.m_iter;}
    bool operator>=(const TrIterator& iter) const { return m_iter>=iter.m_iter;}

    // Incrementation support
    TrIterator& operator++() { ++m_iter; return *this;}
    TrIterator operator++(int) { TrIterator tmp(*this); operator++(); return tmp;}

    // Support for decrementing
    TrIterator& operator--() { --m_iter; return *this;}
    TrIterator operator--(int) { TrIterator tmp(*this); operator--(); return tmp;}

    // Support basic random access 
    TrIterator operator+(int n) const { TrIterator tmp(m_iter+n); return tmp;}
    TrIterator& operator+=(int n) { m_iter=m_iter+n; return *this;}
    TrIterator operator-(int n) const { TrIterator tmp(m_iter-n); return tmp;}
    TrIterator& operator-=(int n) { m_iter=m_iter-n; return *this;}

    // Subtraction

    difference_type operator-(const TrIterator& that) const
    {
        return (m_iter-that.m_iter);
    }    
    
    // support value access

    value_type operator*() const { return *m_iter;} 

    // ROOT dictionary generation
    ClassDef(TrIterator,0);

}; // end TrIterator class 


template<class T>
TrIterator<T> operator+(int n, const TrIterator<T>& iter)
{
    return iter.operator+(n);
}


template<class T>
TrIterator<T> operator-(int n, const TrIterator<T>& iter)
{
    return iter.operator-(n);
}

//-------------------------------------------------------------------
//
// TrRange class
//___________________________________________________________________



template<class T>
class TrRange 
{
    private:
    TrIterator<T> m_begin; 
    TrIterator<T> m_end;   

    public:

    TrRange(const TrIterator<T>& b=TrIterator<T>(), 
            const TrIterator<T>& e=TrIterator<T>()) 
        : m_begin(b), m_end(e) {}


    TrRange(const TrIterator<T>& ref, int range) : m_begin(ref), m_end(ref+range) 
    {
        if (m_begin>m_end) invert();
    } 

    TrRange(const TrRange& that) : m_begin(that.m_begin), m_end(that.m_end) {}

    TrRange& operator=(const TrRange& that) 
    {
        if (this != &that) {
            m_begin = that.m_begin; 
            m_end = that.m_end;
        }
        return *this;
    }

    // Member access operators
    TrIterator<T> begin() const { return m_begin;}
    TrIterator<T> end() const { return m_end;}


    TrRange& operator++() 
    {
        m_begin.operator++();
        m_end.operator++(); 

        return *this;
    }    


    TrRange operator++(int) 
    {
        TrIterator<T> tmpb = m_begin++;
        TrIterator<T> tmpe = m_end++; 
        TrRange tmp (tmpb,tmpe);

        return tmp;
    }    
    

    TrRange& operator--() 
    {
        m_begin.operator--();
        m_end.operator--(); 

        return *this;
    }    


    TrRange operator--(int) 
    {
        TrIterator<T> tmpb = m_begin--;
        TrIterator<T> tmpe = m_end--; 
        TrRange tmp (tmpb,tmpe);

        return tmp;
    }    

    // Basic random access

    TrRange operator+(int n) const
    {
        TrRange tmp(m_begin.operator+(n),
                m_end.operator+(n));

        return tmp;
    }    


    TrRange operator-(int n) const
    {
        TrRange tmp(m_begin.operator-(n),
                m_end.operator-(n)); 

        return tmp;
    }    


    TrRange& operator+=(int n) 
    {
        m_begin.operator+=(n);
        m_end.operator+=(n);

        return *this;
    }    


    TrRange& operator-=(int n) 
    {
        m_begin.operator-=(n);
        m_end.operator-=(n);

        return *this;
    }    


    typename TrIterator<T>::difference_type range() const { return (m_end - m_begin);}

    void invert() 
    { 
        TrIterator<T> tmp=m_begin; 
        m_begin=m_end; 
        m_end=tmp; 

    }

    // Equality operators

    bool operator==(const TrRange& that) const { return ((m_begin==that.m_begin)&&(m_end==that.m_end));}
    bool operator!=(const TrRange& that) const { return (! operator==(that));}

    // Comparison operators

    bool operator<(const TrRange& that) const { return ((m_begin<that.m_begin) && (m_end<that.m_end));}

    bool operator>(const TrRange& that) const { return ((m_begin>that.m_begin) && (m_end>that.m_end));}

    bool operator<=(const TrRange& that) const { return (operator<(that) || operator==(that)); } 
    bool operator>=(const TrRange& that) const { return (operator>(that) || operator==(that)); } 
    
    ClassDef(TrRange,0);

}; // end of TrRange class

template<class T>
TrRange<T> operator+(int n, const TrRange<T>& range)
{
    TrRange<T> tmp = range.operator+(n);
    return tmp;
}


template<class T>
TrRange<T> operator-(int n, const TrRange<T>& range)
{
    TrRange<T> tmp = range.operator-(n);
    return tmp;
}

} // end namespace


#endif