ExternalArrayMap.hpp

Go to the documentation of this file.

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

#ifndef Fw_ExternalArrayMap_HPP
#define Fw_ExternalArrayMap_HPP

#include "Fw/DataStructures/ArraySetOrMapImpl.hpp"
#include "Fw/DataStructures/MapBase.hpp"
#include "Fw/Types/Assert.hpp"

namespace Fw {

template <typename K, typename V>
class ExternalArrayMap final : public MapBase<K, V> {
    // ----------------------------------------------------------------------
    // Friend class for testing
    // ----------------------------------------------------------------------

    template <typename KK, typename VV>
    friend class ExternalArrayMapTester;

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

    using ConstIterator = MapConstIterator<K, V>;

    using Entry = SetOrMapImplEntry<K, V>;

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

    ExternalArrayMap() = default;

    ExternalArrayMap(Entry* entries,      
                     FwSizeType capacity  
                     )
        : MapBase<K, V>() {
        this->setStorage(entries, capacity);
    }

    ExternalArrayMap(ByteArray data,      
                     FwSizeType capacity  
                     )
        : MapBase<K, V>() {
        this->setStorage(data, capacity);
    }

    ExternalArrayMap(const ExternalArrayMap<K, V>& map) : MapBase<K, V>() { *this = map; }

    ~ExternalArrayMap() override = default;

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

    ExternalArrayMap<K, V>& operator=(const ExternalArrayMap<K, V>& map) {
        if (&map != this) {
            this->m_impl = map.m_impl;
        }
        return *this;
    }

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

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

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

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

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

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

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

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

    void setStorage(Entry* entries,      
                    FwSizeType capacity  
    ) {
        this->m_impl.setStorage(entries, capacity);
    }

    void setStorage(ByteArray data,      
                    FwSizeType capacity  
    ) {
        this->m_impl.setStorage(data, capacity);
    }

  public:
    // ----------------------------------------------------------------------
    // Public static functions
    // ----------------------------------------------------------------------

    static constexpr U8 getByteArrayAlignment() { return ArraySetOrMapImpl<K, V>::getByteArrayAlignment(); }

    static constexpr FwSizeType getByteArraySize(FwSizeType capacity  
    ) {
        return ArraySetOrMapImpl<K, V>::getByteArraySize(capacity);
    }

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

    ArraySetOrMapImpl<K, V> m_impl = {};
};

}  // namespace Fw

#endif