SetConstIterator.hpp

Go to the documentation of this file.

// ======================================================================
// \title  SetConstIterator
// \author bocchino
// \brief  An abstract class template representing a const iterator for a set
// ======================================================================

#ifndef Fw_SetConstIterator_HPP
#define Fw_SetConstIterator_HPP

#include <new>

#include "Fw/DataStructures/ArraySetOrMapImpl.hpp"
#include "Fw/DataStructures/Nil.hpp"
#include "Fw/DataStructures/RedBlackTreeSetOrMapImpl.hpp"
#include "Fw/FPrimeBasicTypes.hpp"

namespace Fw {

template <typename T>
class SetConstIterator {
  public:
    // ----------------------------------------------------------------------
    // Public types
    // ----------------------------------------------------------------------

    using ArrayIterator = typename ArraySetOrMapImpl<T, Nil>::ConstIterator;

    using RedBlackTreeIterator = typename RedBlackTreeSetOrMapImpl<T, Nil>::ConstIterator;

  private:
    // ----------------------------------------------------------------------
    // Private types
    // ----------------------------------------------------------------------

    using ImplKind = typename SetOrMapImplConstIterator<T, Nil>::ImplKind;

    union Impl {
        Impl() {}
        Impl(const ArrayIterator& it) : array(it) {}
        Impl(const RedBlackTreeIterator& it) : redBlackTree(it) {}
        ArrayIterator array;
        RedBlackTreeIterator redBlackTree;
        // ! Destructor
        ~Impl() {}
    };

  public:
    // ----------------------------------------------------------------------
    // Constructors and destructors
    // ----------------------------------------------------------------------

    SetConstIterator(const ArrayIterator& it) : m_impl(it), m_implIterator(&m_impl.array) {}

    SetConstIterator(const RedBlackTreeIterator& it) : m_impl(it), m_implIterator(&m_impl.redBlackTree) {}

    SetConstIterator(const SetConstIterator& it) : m_impl(), m_implIterator() {
        const auto implKind = it.getImplIterator().implKind();
        switch (implKind) {
            case ImplKind::ARRAY:
                this->m_implIterator = new (&this->m_impl.array) ArrayIterator(it.m_impl.array);
                break;
            case ImplKind::RED_BLACK_TREE:
                this->m_implIterator = new (&this->m_impl.redBlackTree) RedBlackTreeIterator(it.m_impl.redBlackTree);
                break;
            default:
                FW_ASSERT(0, static_cast<FwAssertArgType>(implKind));
                break;
        }
    }

    ~SetConstIterator() {}

  public:
    // ----------------------------------------------------------------------
    // Public member functions
    // ----------------------------------------------------------------------

    SetConstIterator& operator=(const SetConstIterator&) = default;

    bool operator==(const SetConstIterator& it) {
        bool result = false;
        const auto implKind1 = this->getImplIterator().implKind();
        const auto implKind2 = it.getImplIterator().implKind();
        if (implKind1 == implKind2) {
            switch (implKind1) {
                case ImplKind::ARRAY:
                    result = this->m_impl.array.compareEqual(it.m_impl.array);
                    break;
                case ImplKind::RED_BLACK_TREE:
                    result = this->m_impl.redBlackTree.compareEqual(it.m_impl.redBlackTree);
                    break;
                default:
                    FW_ASSERT(0, static_cast<FwAssertArgType>(implKind1));
                    break;
            }
        }
        return result;
    }

    bool operator!=(const SetConstIterator& it) { return !(*this == it); };

    SetConstIterator& operator++() {
        this->getImplIterator().increment();
        return *this;
    }

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

    bool isInRange() const { return this->getImplIterator().isInRange(); }

    const T& operator*() const { return this->getImplIterator().getEntry().getKeyOrElement(); }

    const T* operator->() const { return &this->getImplIterator().getEntry().getKeyOrElement(); }

  private:
    // ----------------------------------------------------------------------
    // Private helper functions
    // ----------------------------------------------------------------------

    SetOrMapImplConstIterator<T, Nil>& getImplIterator() {
        FW_ASSERT(this->m_implIterator != nullptr);
        return *this->m_implIterator;
    }

    const SetOrMapImplConstIterator<T, Nil>& getImplIterator() const {
        FW_ASSERT(this->m_implIterator != nullptr);
        return *this->m_implIterator;
    }

  private:
    // ----------------------------------------------------------------------
    // Private member variables
    // ----------------------------------------------------------------------

    Impl m_impl;

    SetOrMapImplConstIterator<T, Nil>* m_implIterator = nullptr;
};

}  // namespace Fw

#endif