cs_CircularBuffer.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Feb 27, 2015
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
#pragma once
 
#include <cfg/cs_Strings.h>
#include <logging/cs_Logger.h>
 
#include <cstdlib>
 
#include "common/cs_Types.h"
 
#define LOGCircularBufferDebug LOGvv
 
#define CS_CIRCULAR_BUFFER_INDEX_NOT_FOUND 0xFFFF
 
template <class T>
class CircularBuffer {
public:
    CircularBuffer(uint16_t capacity)
            : _array(nullptr), _capacity(capacity), _head(0), _tail(-1), _contentsSize(0), _allocatedSelf(false) {}
 
    virtual ~CircularBuffer() { deinit(); }
 
    uint16_t getMaxByteSize(uint16_t capacity) { return capacity * sizeof(T); }
    uint16_t getMaxByteSize() { return getMaxByteSize(_capacity); }
    uint16_t getMaxSize(uint16_t byteSize) { return byteSize / sizeof(T); }
 
    bool init() {
        if (_array != nullptr) {
            return false;
        }
        // Allocate memory
        LOGCircularBufferDebug(FMT_ALLOCATE_MEMORY, _array);
        _array = (T*)calloc(_capacity, sizeof(T));
        if (_array == nullptr) {
            LOGw(STR_ERR_ALLOCATE_MEMORY);
            return false;
        }
 
        _allocatedSelf = true;
        // Also call clear to make sure we start with a clean buffer
        clear();
        return true;
    }
 
    bool deinit() {
        if (_array != nullptr && _allocatedSelf) {
            free(_array);
        }
        _allocatedSelf = false;
        _array         = nullptr;
        return true;
    }
 
    bool assign(buffer_ptr_t buffer, uint16_t bufferSize) {
        if (getMaxSize(bufferSize) < _capacity || _allocatedSelf) {
            LOGd(FMT_ERR_ASSIGN_BUFFER, buffer, bufferSize);
            return false;
        }
        LOGCircularBufferDebug(FMT_ASSIGN_BUFFER_LEN, buffer, bufferSize);
        _array = (T*)buffer;
 
        // Also call clear to make sure we start with a clean buffer
        clear();
        return true;
    }
 
    bool release() {
        if (_allocatedSelf) {
            return false;
        }
        _array = nullptr;
        return true;
    }
 
    bool isInitialized() { return _array != nullptr; }
 
    T* getBuffer() { return _array; }
 
    void clear() {
        _head         = 0;
        _tail         = -1;
        _contentsSize = 0;
    }
 
    uint16_t size() const { return _contentsSize; }
 
    uint16_t capacity() const { return _capacity; }
 
    bool empty() const { return size() == 0; }
 
    bool full() const { return size() == capacity(); }
 
    void push(const T& value) {
        incTail();
        if (_contentsSize > _capacity) {
            incHead();
        }
        _array[_tail] = value;
    }
 
    bool pushUnique(const T& value) {
        if (find(value) == CS_CIRCULAR_BUFFER_INDEX_NOT_FOUND) {
            push(value);
            return true;
        }
        return false;
    }
 
    const T& pop() {
        T* res = &(_array[_head]);
        incHead();
        return *res;
    }
 
    T& peek() const { return _array[_head]; }
 
    T& operator[](uint16_t idx) const { return _array[(_head + idx) % _capacity]; }
 
    uint16_t find(const T& value) const {
        for (uint16_t index = 0; index < size(); ++index) {
            if (operator[](index) == value) {
                return index;
            }
        }
        return CS_CIRCULAR_BUFFER_INDEX_NOT_FOUND;
    }
 
private:
    T* _array;
 
    uint16_t _capacity;
 
    uint16_t _head;
 
    uint16_t _tail;
 
    uint16_t _contentsSize;
 
    bool _allocatedSelf;
 
    void incTail() {
        ++_tail;
        _tail %= _capacity;
        ++_contentsSize;
    }
 
    void incHead() {
        ++_head;
        _head %= _capacity;
        --_contentsSize;
    }
};