StackBase.hpp

Go to the documentation of this file.

// ======================================================================
// \title  StackBase
// \author bocchino
// \brief  An abstract base class template for a stack
// ======================================================================

#ifndef Fw_StackBase_HPP
#define Fw_StackBase_HPP

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

namespace Fw {

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

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

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

    StackBase() : SizedContainer() {}

    virtual ~StackBase() = default;

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

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

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

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

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

    virtual Success push(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 pop(T& e  
                        ) = 0;
};

}  // namespace Fw

#endif