FixedQueue.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_FIXEDQUEUE_HXX_
#define _FREERTOS_DRIVERS_COMMON_FIXEDQUEUE_HXX_
 
#include <algorithm>
#include <cstdint>
 
#include "Devtab.hxx"
#include "executor/Notifiable.hxx"
 
template<class T, uint8_t SIZE> class FixedQueue {
public:
    FixedQueue()
        : rdIndex_(0)
        , wrIndex_(0)
        , count_(0)
    {
    }
 
    bool empty() { return size() == 0; }
    bool full() { return size() >= SIZE; }
    size_t size() { return __atomic_load_n(&count_, __ATOMIC_SEQ_CST); }
 
    T& front() {
        HASSERT(!empty());
        return storage_[rdIndex_];
    }
 
    void increment_front() {
        HASSERT(!empty());
        if (++rdIndex_ >= SIZE) rdIndex_ = 0;
        __atomic_fetch_add(&count_, -1, __ATOMIC_SEQ_CST);
    }
 
    T& back() {
        HASSERT(!full());
        return storage_[wrIndex_];
    }
 
    void increment_back() {
        HASSERT(!full());
        if (++wrIndex_ >= SIZE) wrIndex_ = 0;
        __atomic_fetch_add(&count_, 1, __ATOMIC_SEQ_CST);
    }
 
    void noncommit_back() {
        HASSERT(has_noncommit_space());
        if (++wrIndex_ >= SIZE) wrIndex_ = 0;
    }
 
    bool has_noncommit_space() {
        if (full()) return false;
        auto new_index = wrIndex_;
        if (++new_index >= SIZE) new_index = 0;
        return new_index != rdIndex_;
    }
 
    void commit_back() {
        HASSERT(count_ <= SIZE);
        __atomic_fetch_add(&count_, 1, __ATOMIC_SEQ_CST);
    }
 
private:
    T storage_[SIZE];
    uint8_t rdIndex_;
    uint8_t wrIndex_;
    volatile uint8_t count_;
};
 
#endif  // _FREERTOS_DRIVERS_COMMON_FIXEDQUEUE_HXX_