FifoQueueBase.hpp

Go to the documentation of this file.

// ======================================================================
// \title  FifoQueueBase
// \author bocchino
// \brief  An abstract base class template for a FIFO queue
// ======================================================================

#ifndef Fw_FifoQueueBase_HPP
#define Fw_FifoQueueBase_HPP

#include "Fw/DataStructures/SizedContainer.hpp"
#include "Fw/Types/Assert.hpp"
#include "Fw/Types/SuccessEnumAc.hpp"

namespace Fw {

template <typename T>
class FifoQueueBase : public SizedContainer {
  private:
    // ----------------------------------------------------------------------
    // Private constructors
    // ----------------------------------------------------------------------

    FifoQueueBase(const FifoQueueBase<T>&) = delete;

  protected:
    // ----------------------------------------------------------------------
    // Protected constructors and destructors
    // ----------------------------------------------------------------------

    FifoQueueBase() : SizedContainer() {}

    virtual ~FifoQueueBase() = default;

  private:
    // ----------------------------------------------------------------------
    // Private member functions
    // ----------------------------------------------------------------------

    FifoQueueBase<T>& operator=(const FifoQueueBase<T>&) = delete;

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

    virtual const T& at(FwSizeType index  
    ) const = 0;

    void copyDataFrom(const FifoQueueBase<T>& queue  
    ) {
        if (&queue != this) {
            this->clear();
            const FwSizeType size = FW_MIN(queue.getSize(), this->getCapacity());
            for (FwSizeType i = 0; i < size; i++) {
                const auto& e = queue.at(i);
                const auto status = this->enqueue(e);
                FW_ASSERT(status == Fw::Success::SUCCESS, static_cast<FwAssertArgType>(status));
            }
        }
    }

    virtual Success enqueue(const T& e  
                            ) = 0;

    Success peek(T& e,                 
                 FwSizeType index = 0  
    ) const {
        auto status = Success::FAILURE;
        if (index < this->getSize()) {
            e = this->at(index);
            status = Success::SUCCESS;
        }
        return status;
    }

    virtual Success dequeue(T& e  
                            ) = 0;
};

}  // namespace Fw

#endif