ArrayMap.hpp

Go to the documentation of this file.

// ======================================================================
// \file   ArrayMap.hpp
// \author bocchino
// \brief  An array-based map with internal storage
// ======================================================================

#ifndef Fw_ArrayMap_HPP
#define Fw_ArrayMap_HPP

#include "Fw/DataStructures/ExternalArrayMap.hpp"

namespace Fw {

template <typename K, typename V, FwSizeType C>
class ArrayMap final : public MapBase<K, V> {
    // ----------------------------------------------------------------------
    // Static assertions
    // ----------------------------------------------------------------------

    static_assert(C > 0, "capacity must be greater than zero");

    // ----------------------------------------------------------------------
    // Friend class for testing
    // ----------------------------------------------------------------------

    template <typename KK, typename VV, FwSizeType CC>
    friend class ArrayMapTester;

  public:
    // ----------------------------------------------------------------------
    // Public types
    // ----------------------------------------------------------------------

    using ConstIterator = MapConstIterator<K, V>;

    using Entry = SetOrMapImplEntry<K, V>;

    using Entries = Entry[C];

  public:
    // ----------------------------------------------------------------------
    // Public constructors and destructors
    // ----------------------------------------------------------------------

    ArrayMap() : MapBase<K, V>(), m_extMap(m_entries, C) {}

    ArrayMap(const ArrayMap<K, V, C>& map) : MapBase<K, V>(), m_extMap(m_entries, C) { *this = map; }

    ~ArrayMap() override = default;

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

    ArrayMap<K, V, C>& operator=(const ArrayMap<K, V, C>& map) {
        this->m_extMap.copyDataFrom(map);
        return *this;
    }

    ConstIterator begin() const override { return this->m_extMap.begin(); }

    void clear() override { this->m_extMap.clear(); }

    ConstIterator end() const override { return this->m_extMap.end(); }

    Success find(const K& key,  
                 V& value       
    ) const override {
        return this->m_extMap.find(key, value);
    }

    FwSizeType getCapacity() const override { return this->m_extMap.getCapacity(); }

    FwSizeType getSize() const override { return this->m_extMap.getSize(); }

    Success insert(const K& key,   
                   const V& value  
                   ) override {
        return this->m_extMap.insert(key, value);
    }

    Success remove(const K& key,  
                   V& value       
                   ) override {
        return this->m_extMap.remove(key, value);
    }

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

    ExternalArrayMap<K, V> m_extMap = {};

    Entries m_entries = {};
};

}  // namespace Fw

#endif