ExternalStack.hpp

Go to the documentation of this file.

// ======================================================================
// \file   ExternalStack.hpp
// \author bocchino
// \brief  A stack with external storage
// ======================================================================

#ifndef Fw_ExternalStack_HPP
#define Fw_ExternalStack_HPP

#include "Fw/DataStructures/ExternalArray.hpp"
#include "Fw/DataStructures/StackBase.hpp"
#include "Fw/Types/ByteArray.hpp"

namespace Fw {

template <typename T>
class ExternalStack final : public StackBase<T> {
    // ----------------------------------------------------------------------
    // Friend class for testing
    // ----------------------------------------------------------------------

    template <typename TT>
    friend class ExternalStackTester;

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

    ExternalStack() = default;

    ExternalStack(T* items,            
                  FwSizeType capacity  
                  )
        : StackBase<T>() {
        this->setStorage(items, capacity);
    }

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

    ExternalStack(const ExternalStack<T>& stack) : StackBase<T>() { *this = stack; }

    ~ExternalStack() override = default;

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

    ExternalStack<T>& operator=(const ExternalStack<T>& stack) {
        if (&stack != this) {
            this->m_items = stack.m_items;
            this->m_size = stack.m_size;
        }
        return *this;
    }

    void clear() override { this->m_size = 0; }

    void setStorage(T* items,            
                    FwSizeType capacity  
    ) {
        this->m_items.setStorage(items, capacity);
        this->clear();
    }

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

    Success push(const T& e  
                 ) override {
        auto status = Success::FAILURE;
        if (this->m_size < this->getCapacity()) {
            this->m_items[this->m_size] = e;
            this->m_size++;
            status = Success::SUCCESS;
        }
        return status;
    }

    const T& at(FwSizeType index  
    ) const override {
        FW_ASSERT(index < this->m_size, static_cast<FwAssertArgType>(index),
                  static_cast<FwAssertArgType>(this->m_size));
        return this->m_items[this->m_size - 1 - index];
    }

    Success pop(T& e  
                ) override {
        auto status = Success::FAILURE;
        if (this->m_size > 0) {
            e = this->at(0);
            this->m_size--;
            status = Success::SUCCESS;
        }
        return status;
    }

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

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

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

    static constexpr U8 getByteArrayAlignment() { return ExternalArray<T>::getByteArrayAlignment(); }

    static constexpr FwSizeType getByteArraySize(FwSizeType capacity  
    ) {
        return ExternalArray<T>::getByteArraySize(capacity);
    }

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

    ExternalArray<T> m_items = {};

    FwSizeType m_size = 0;
};

}  // namespace Fw

#endif