ExternalFifoQueue.hpp

Go to the documentation of this file.

// ======================================================================
// \file   ExternalFifoQueue.hpp
// \author bocchino
// \brief  A FIFO queue with external storage
// ======================================================================

#ifndef Fw_ExternalFifoQueue_HPP
#define Fw_ExternalFifoQueue_HPP

#include "Fw/DataStructures/CircularIndex.hpp"
#include "Fw/DataStructures/ExternalArray.hpp"
#include "Fw/DataStructures/FifoQueueBase.hpp"
#include "Fw/Types/ByteArray.hpp"

namespace Fw {

template <typename T>
class ExternalFifoQueue final : public FifoQueueBase<T> {
    // ----------------------------------------------------------------------
    // Friend class for testing
    // ----------------------------------------------------------------------

    template <typename TT>
    friend class ExternalFifoQueueTester;

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

    ExternalFifoQueue() = default;

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

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

    ExternalFifoQueue(const ExternalFifoQueue<T>& queue) : FifoQueueBase<T>() { *this = queue; }

    ~ExternalFifoQueue() override = default;

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

    ExternalFifoQueue<T>& operator=(const ExternalFifoQueue<T>& queue) {
        if (&queue != this) {
            this->m_items = queue.m_items;
            this->m_enqueueIndex = queue.m_enqueueIndex;
            this->m_dequeueIndex = queue.m_dequeueIndex;
            this->m_size = queue.m_size;
        }
        return *this;
    }

    void clear() override {
        this->m_enqueueIndex.setValue(0);
        this->m_dequeueIndex.setValue(0);
        this->m_size = 0;
    }

    void setStorage(T* items,            
                    FwSizeType capacity  
    ) {
        this->m_items.setStorage(items, capacity);
        if (capacity > 0) {
            this->m_enqueueIndex.setModulus(capacity);
            this->m_dequeueIndex.setModulus(capacity);
        }
        this->clear();
    }

    void setStorage(ByteArray data,      
                    FwSizeType capacity  
    ) {
        this->m_items.setStorage(data, capacity);
        if (capacity > 0) {
            this->m_enqueueIndex.setModulus(capacity);
            this->m_dequeueIndex.setModulus(capacity);
        }
        this->clear();
    }

    Success enqueue(const T& e  
                    ) override {
        auto status = Success::FAILURE;
        if (this->m_size < this->getCapacity()) {
            const auto i = this->m_enqueueIndex.getValue();
            this->m_items[i] = e;
            (void)this->m_enqueueIndex.increment();
            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));
        auto ci = this->m_dequeueIndex;
        const auto i = ci.increment(index);
        return this->m_items[i];
    }

    Success dequeue(T& e  
                    ) override {
        auto status = Success::FAILURE;
        if (this->m_size > 0) {
            e = this->at(0);
            (void)this->m_dequeueIndex.increment();
            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 = {};

    CircularIndex m_enqueueIndex = {};

    CircularIndex m_dequeueIndex = {};

    FwSizeType m_size = 0;
};

}  // namespace Fw

#endif