FrontArray.hpp

Go to the documentation of this file.

// <FrontArray.hpp> -*- C++ -*-
 
#pragma once
 
#include "sparta/resources/Array.hpp"
 
namespace sparta{
 
    template <class DataT, ArrayType ArrayT = ArrayType::AGED>
    class FrontArray : public Array<DataT, ArrayT>
    {
        //Typedef for the base type we inherit from
        typedef Array<DataT, ArrayT> BaseArray;
 
    public:
        FrontArray(const std::string& name, uint32_t num_entries, const Clock* clk,
                   StatisticSet* statset = nullptr) :
            BaseArray(name, num_entries, clk, statset)
        {
        }
 
        const DataT& readValid(const uint32_t nth=0) const
        {
            sparta_assert(nth < BaseArray::capacity(), "Cannot read at index larger than the size of the array");
            sparta_assert(nth < BaseArray::numValid(), "Asked for an idx that is not valid");
            // We need to iterate over the underlaying vector, array_.
            // Then count how many valid entries we have passed until
            // we are at the nth'th valid entree.
            uint32_t n = 0;
            uint32_t i = 0;
            while(n <= nth)
            {
                if(BaseArray::isValid(n))
                {
                    ++n;
                }
                ++i;
            }
            // if i is not > 0, then we are going to fail that return
            // line with i-1
            sparta_assert(i > 0);
            return BaseArray::read(i - 1);
        }
 
        uint32_t writeFront(const DataT& dat)
        {
            return writeFrontImpl_(dat);
        }
 
        uint32_t writeFront(DataT&& dat)
        {
            return writeFrontImpl_(std::move(dat));
        }
 
        uint32_t writeBack(const DataT& dat)
        {
            return writeBackImpl_(dat);
        }
 
        uint32_t writeBack(DataT&& dat)
        {
            return writeBackImpl_(std::move(dat));
        }
 
        // STL compatibility -- kinda
 
        uint32_t push_front(const DataT & dat) { return writeFront(dat); }
 
        uint32_t push_front(DataT&& dat) { return writeFront(std::forward(dat)); }
 
        uint32_t push_back(const DataT & dat) { return writeBack(dat); }
 
        uint32_t push_back(DataT && dat) { return writeBack(std::forward(dat)); }
 
    private:
        template<typename U>
        uint32_t writeFrontImpl_(U&& dat)
        {
            uint32_t i;
            for(i = 0; i < BaseArray::capacity(); ++i)
            {
                if(!BaseArray::isValid(i))
                {
                    break; //we found an entry that is invalid. This is the front!
                }
            }
            sparta_assert(i < BaseArray::capacity(),
                          "Cannot write to the front of the Array. There are no free entries.");
            BaseArray::write(i, std::forward<U>(dat));
            return i;
        }
 
        template<typename U>
        uint32_t writeBackImpl_(U&& dat)
        {
            int32_t i;
            for(i = BaseArray::capacity()-1; i>=0;--i)
            {
                if(!BaseArray::isValid(i))
                {
                    break; //we found an entry that is invalid. This is the back!
                }
            }
            sparta_assert(i >= 0, "Cannot write to the back of the array. There are no free entries.");
            BaseArray::write(i, std::forward<U>(dat));
            return i;
        }
    };
}