range.h

Go to the documentation of this file.

// include guard
#ifndef TFXX_RANGE_H_VERSION

#define TFXX_RANGE_H_VERSION \
  "TFXX_RANGE_H   V1.2"

namespace tfxx {

template<class T=int>
  class Range {
    public:
      typedef T Tvalue;
      Range(): Mfirst(0), Mlast(0) { }
      Range(const Tvalue& index): Mfirst(index), Mlast(index) { }
      Range(const Tvalue& first, const Tvalue& last):
        Mfirst(first<last ? first:last), 
        Mlast(last>first ? last:first) { }
      Tvalue& first() { return Mfirst; }
      Tvalue& last() { return Mlast; }
      const Tvalue& first() const { return Mfirst; }
      const Tvalue& last() const { return Mlast; }
      bool isinside(const Range& other) const
      { return ((Mfirst >= other.first()) && (Mlast <= other.last())); }
      bool contains(const Range& other) const
      { return ((Mfirst <= other.first()) && (Mlast >= other.last())); }
      bool contains(const Tvalue& v) const
      { return ((Mfirst <= v) && (Mlast >= v)); }
      Range& shrink(const Range& other) 
      { 
        Mfirst=Mfirst>other.first() ? Mfirst:other.first();
        Mlast=Mlast<other.last() ? Mlast:other.last();
        return *this;
      }
      Range& expand(const Range& other) 
      { 
        Mfirst=Mfirst<other.first() ? Mfirst:other.first();
        Mlast=Mlast>other.last() ? Mlast:other.last();
        return *this;
      }
      Range& shift(const Tvalue& n)
      { Mfirst+=n; Mlast+=n; return *this; }
      Range& operator+=(const Tvalue& n)
      { return this->shift(n); }
      Range& operator-=(const Tvalue& n)
      { return this->shift(-n); }
    private:
      Tvalue Mfirst; 
      Tvalue Mlast;  
  }; // class Range

/*----------------------------------------------------------------------*/

  template<class T=int>
    class RangeStepper {
      public:
        typedef Range<T> Trange;
        typedef typename Trange::Tvalue Tvalue;
        RangeStepper(const Trange& range,
                     const Tvalue& stepsize=1):
          Mrange(range), Mstepsize(stepsize), Mcurrent(Mrange.first()) { }
        operator Tvalue() const { return(this->current()); }
        Tvalue current() const { return(Mcurrent); }
        bool valid() const { return(Mcurrent<=Mrange.last()); }
        bool more() const { return(Mcurrent<=(Mrange.last()-Mstepsize)); }
        Tvalue next() 
          { 
            if (this->valid()) { Mcurrent += Mstepsize; }
            return(this->current()); 
          }
        Tvalue operator++() { return(this->next()); }
      private:
        Trange Mrange;
        Tvalue Mstepsize;
        Tvalue Mcurrent;
    };// class RangeStepper

} // namespace tfxx

#endif // TFXX_RANGE_H_VERSION (includeguard)

/* ----- END OF range.h ----- */