Enumerators.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__ENUMERATORS__HH__
#define __DIADES__UTILS__ENUMERATORS__HH__

#include<vector>

namespace Diades
{
   namespace Utils
   {

      template<typename T>
      class RangesEnumeration
      {
      public:
         using Value = T;
      private:
         std::vector<T> _start;
         std::vector<T> _end;
         std::vector<T> _current;
         bool _completed;
         bool _empty;
         size_t _counter;

         
         void checkEmpty()
         {
            _empty = false;
            size_t index = 0;
            while(!_empty && (index < _start.size()))
            {
               _empty = _start[index] == _end[index];
               ++index;
            }
         }
         
      public:

         RangesEnumeration() = default;


         RangesEnumeration(RangesEnumeration const& other) = default;
         RangesEnumeration& operator=(RangesEnumeration const& other) = default;
         RangesEnumeration(RangesEnumeration&& other) = default;
         RangesEnumeration& operator=(RangesEnumeration&& other) = default;

         virtual ~RangesEnumeration() = default;

         void
         setup(std::vector<T> && start, const std::vector<T> && end)
         {
            _start = start;
            _current = start;
            _end = end;
            checkEmpty();
            _completed = (_current == _end);
            _counter = 0;
         }

         RangesEnumeration(const std::vector<T> & start, const std::vector<T> & end) :
         _start(start), _end(end), _current(start), _completed(start == end), _empty(false), _counter(0)
         {
            checkEmpty();
         }

         size_t
         count() const
         {
            return _counter;
         }

         const std::vector<T> &
         current() const
         {
            return _current;
         }

         void
         start()
         {
            _current = _start;
            _completed = (_start == _end);
            _counter = 0;
         }

         bool
         hasNext()
         {
            if(!empty())
            {
               if(!_completed)
               {
                  ++_counter;
                  size_t index = 0;
                  ++_current[index];
                  auto indexMax = _current.size() - 1;
                  while((index != indexMax) && (_current[index] == _end[index]))
                  {
                     _current[index] = _start[index];
                     ++index;
                     ++_current[index];
                  }
                  _completed = _current[index] == _end[index];
               }
               return !_completed;
            }
            return false;
         }

         bool
         empty() const
         {
            return _empty;
         }

         bool
         completed() const
         {
            return _completed;
         }
      };
   }
}


#endif /* __DIADES__UTILS__ENUMERATORS_HH */