ExternalRedBlackTreeSet.hpp

Go to the documentation of this file.

// ======================================================================
// \file   ExternalRedBlackTreeSet.hpp
// \author bocchino
// \brief  An set based on a red-black tree with external storage
// ======================================================================

#ifndef Fw_ExternalRedBlackTreeSet_HPP
#define Fw_ExternalRedBlackTreeSet_HPP

#include "Fw/DataStructures/Nil.hpp"
#include "Fw/DataStructures/RedBlackTreeSetOrMapImpl.hpp"
#include "Fw/DataStructures/SetBase.hpp"
#include "Fw/Types/Assert.hpp"

namespace Fw {

template <typename T>
class ExternalRedBlackTreeSet final : public SetBase<T> {
    // ----------------------------------------------------------------------
    // Friend class for testing
    // ----------------------------------------------------------------------

    template <typename TT>
    friend class ExternalRedBlackTreeSetTester;

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

    using ConstIterator = SetConstIterator<T>;

    using Node = typename RedBlackTreeSetOrMapImpl<T, Nil>::Node;

    using Index = typename RedBlackTreeSetOrMapImpl<T, Nil>::Index;

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

    ExternalRedBlackTreeSet() = default;

    ExternalRedBlackTreeSet(Node* nodes,         
                            Index* freeNodes,    
                            FwSizeType capacity  
                            )
        : SetBase<T>() {
        this->setStorage(nodes, freeNodes, capacity);
    }

    ExternalRedBlackTreeSet(ByteArray data,      
                            FwSizeType capacity  
                            )
        : SetBase<T>() {
        this->setStorage(data, capacity);
    }

    ExternalRedBlackTreeSet(const ExternalRedBlackTreeSet<T>& set) : SetBase<T>() { *this = set; }

    ~ExternalRedBlackTreeSet() override = default;

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

    ExternalRedBlackTreeSet<T>& operator=(const ExternalRedBlackTreeSet<T>& set) {
        if (&set != this) {
            this->m_impl = set.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 T& element  
    ) const override {
        Nil nil = {};
        return this->m_impl.find(element, nil);
    }

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

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

    Success insert(const T& element  
                   ) override {
        return this->m_impl.insert(element, Nil());
    }

    Success remove(const T& element  
                   ) override {
        Nil nil = {};
        return this->m_impl.remove(element, nil);
    }

    void setStorage(Node* nodes,         
                    Index* freeNodes,    
                    FwSizeType capacity  
    ) {
        this->m_impl.setStorage(nodes, freeNodes, capacity);
    }

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

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

    static constexpr U8 getByteArrayAlignment() { return RedBlackTreeSetOrMapImpl<T, Nil>::getByteArrayAlignment(); }

    static constexpr FwSizeType getByteArraySize(FwSizeType capacity  
    ) {
        return RedBlackTreeSetOrMapImpl<T, Nil>::getByteArraySize(capacity);
    }

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

    RedBlackTreeSetOrMapImpl<T, Nil> m_impl = {};
};

}  // namespace Fw

#endif