rangelist.h

Go to the documentation of this file.

// include guard
#ifndef TF_RANGELIST_H_VERSION

#define TF_RANGELIST_H_VERSION \
  "TF_RANGELIST_H   V1.1"

#include<tfxx/range.h>
#include<list>

namespace tfxx {

  template<class T>
    class RangeList {
      public:
        typedef T Tvalue;
        typedef tfxx::Range<Tvalue> Trange;
        typedef std::list<Trange> Tlist;
        RangeList() { }
        RangeList& append(const Trange& r)
        { Mlist.push_back(r); return *this; }
        void clear() 
        { Mlist.erase(Mlist.begin(), Mlist.end()); }
        typename Tlist::size_type size() const { return Mlist.size(); }
        bool contains(const Tvalue& v) const
        {
          bool retval=false;
          typename Tlist::const_iterator i=Mlist.begin();
          while ((i!=Mlist.end()) && (!retval))
          { retval = i->contains(v); ++i; }
          return retval;
        }
        Tlist list() const { return Mlist; }
      private:
        Tlist Mlist;
    }; // template class RangeList

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

  template<class T>
    class RangeListStepper {
      public:
        typedef RangeList<T> Trangelist;
        typedef typename Trangelist::Tvalue Tvalue;
        typedef typename Trangelist::Tlist Tlist;
        typedef RangeStepper<Tvalue> Trangestepper;
        RangeListStepper(const Trangelist& rangelist,
                         const Tvalue& stepsize=1):
          Mlist(rangelist.list()), Mstepsize(stepsize),
            Miterator(Mlist.begin()),
            Mrangestepper(Trangestepper(*Miterator, Mstepsize))
          { }
        Tvalue current() const { return(Mrangestepper.current()); }
        operator Tvalue() const { return(this->current()); }
        bool valid() const 
          { 
            return(Mrangestepper.valid() && (Miterator!=Mlist.end()));
          }
        bool more() const 
          { 
            bool retval=this->valid();
            if (retval && (!Mrangestepper.more()))
            {
              typename Tlist::const_iterator I=Miterator;
              ++I;
              if (!(I!=Mlist.end())) { retval=false; }
            }
            return(retval);
          }
        Tvalue next() 
          {
            if (this->valid())
            {
              if (Mrangestepper.more()) { Mrangestepper.next(); }
              else {
                ++Miterator;
                if (Miterator != Mlist.end()) 
                {
                  Mrangestepper=Trangestepper(*Miterator, Mstepsize);
                }
              }
            }
            return(this->current()); 
          }
        Tvalue operator++() { return(this->next()); }
      private:
        Tlist Mlist;
        Tvalue Mstepsize;
        typename Tlist::const_iterator Miterator;
        Trangestepper Mrangestepper;
    }; // template class RangeListStepper

  
}

#endif // TF_RANGELIST_H_VERSION (includeguard)

/* ----- END OF rangelist.h ----- */