############################################ IntervalIntSet.h ########################################
#pragma once
#include <vector>
#include "IntSet.h"
#include "Interval.h"

class IntervalIntSet: public IntSet
{
public:
    IntervalIntSet() { count = 0; lastValue = 0; }
    bool Contains(int elem);
    void Add(int elem);
    IntSet* Union(IntSet& other);
    void Rewind() { iterator = 0; iteratorInterval = 0; iteratorIntervalStart = 0; }
    bool IsEnd() { return (iterator == count); }
    int Current();
    void MoveNext();
private:
    std::vector<Interval> interval;
    int lastValue, iterator, iteratorInterval, iteratorIntervalStart;
};

############################################ IntervalIntSet.cpp ########################################
#include "IntervalIntSet.h"

bool IntervalIntSet::Contains(int elem) {
    for (unsigned int i = 0; i < interval.size(); i++) {
        if (elem >= interval[i].startValue && elem <= interval[i].endValue) return true;
    }
    return false;
}

void IntervalIntSet::Add(int elem) {
    if (interval.size() == 0 || elem != lastValue + 1) { // Start new interval
        Interval newInterval;
        newInterval.startValue = elem;
        interval.push_back(newInterval);
    }
    interval[interval.size() - 1].endValue = elem;
    lastValue = elem;
    count++;
}

IntSet* IntervalIntSet::Union(IntSet& other) {
    return 0;//new IntSet();
}

int IntervalIntSet::Current() {
    return interval[iteratorInterval].startValue + (iterator - iteratorIntervalStart);
}

void IntervalIntSet::MoveNext() {
    int currentIntervalLength = interval[iteratorInterval].endValue - interval[iteratorInterval].startValue;
    iterator++;
    if (iterator - iteratorIntervalStart > currentIntervalLength) { // Stepped beyond current interval
        iteratorInterval++;
        iteratorIntervalStart += currentIntervalLength + 1;
    }
}