MapConstIterator.hpp

Go to the documentation of this file.

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

#ifndef Fw_MapConstIterator_HPP
#define Fw_MapConstIterator_HPP

#include <new>

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

namespace Fw {

template <typename K, typename V>
class MapConstIterator {
  public:
    // ----------------------------------------------------------------------
    // Public types
    // ----------------------------------------------------------------------

    using ArrayIterator = typename ArraySetOrMapImpl<K, V>::ConstIterator;
    using EntryBase = MapEntryBase<K, V>;
    using RedBlackTreeIterator = typename RedBlackTreeSetOrMapImpl<K, V>::ConstIterator;

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

    using ImplKind = typename SetOrMapImplConstIterator<K, V>::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
    // ----------------------------------------------------------------------

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

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

    MapConstIterator(const MapConstIterator& 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;
        }
    }

    ~MapConstIterator() {}

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

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

    bool operator==(const MapConstIterator& 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 MapConstIterator& it) { return !(*this == it); };

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

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

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

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

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

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

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

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

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

    Impl m_impl;

    SetOrMapImplConstIterator<K, V>* m_implIterator = nullptr;
};

}  // namespace Fw

#endif