fsfw/container/HybridIterator.h

#ifndef FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_
#define FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_

#include <framework/container/ArrayList.h>
#include <framework/container/SinglyLinkedList.h>

template<typename T, typename count_t = uint8_t>
class HybridIterator: public LinkedElement<T>::Iterator,
		public ArrayList<T, count_t>::Iterator {
public:
	HybridIterator() {}

	HybridIterator(typename LinkedElement<T>::Iterator *iter) :
		LinkedElement<T>::Iterator(*iter), value(iter->value),
		linked(true) {

	}

	HybridIterator(LinkedElement<T> *start) :
		LinkedElement<T>::Iterator(start), value(start->value),
		linked(true) {

	}

	HybridIterator(typename ArrayList<T, count_t>::Iterator start,
			typename ArrayList<T, count_t>::Iterator end) :
			ArrayList<T, count_t>::Iterator(start), value(start.value),
			linked(false), end(end.value) {
		if (value == this->end) {
			value = NULL;
		}
	}

	HybridIterator(T *firstElement, T *lastElement) :
			ArrayList<T, count_t>::Iterator(firstElement), value(firstElement),
			linked(false), end(++lastElement) {
		if (value == end) {
			value = NULL;
		}
	}

	HybridIterator& operator++() {
		if (linked) {
			LinkedElement<T>::Iterator::operator++();
			if (LinkedElement<T>::Iterator::value != nullptr) {
				value = LinkedElement<T>::Iterator::value->value;
			} else {
				value = nullptr;
			}
		} else {
			ArrayList<T, count_t>::Iterator::operator++();
			value = ArrayList<T, count_t>::Iterator::value;

			if (value == end) {
				value = nullptr;
			}
		}
		return *this;
	}

	HybridIterator operator++(int) {
		HybridIterator tmp(*this);
		operator++();
		return tmp;
	}

	bool operator==(const HybridIterator& other) const {
		return value == other.value;
	}

	bool operator!=(const HybridIterator& other) const {
		return !(*this == other);
	}

	T operator*() {
		return *value;
	}

	T *operator->() {
		return value;
	}

	T* value = nullptr;

private:
	bool linked = false;
	T *end = nullptr;
};

#endif /* FRAMEWORK_CONTAINER_HYBRIDITERATOR_H_ */