cs_CircularDifferentialBuffer.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Mar 16, 2015
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
#pragma once
 
//#include <common/cs_Types.h>
 
#include <cstddef>
//#include <cstdint>
 
//#include <stdlib.h> // malloc, free
//#include <stdint.h> // uint32_t
//
//#include <logging/cs_Logger.h>
 
template <typename T>
class CircularDifferentialBuffer {
public:
    CircularDifferentialBuffer(uint16_t capacity = 32, bool initialize = false)
            : _array(NULL), _capacity(capacity), _head(0), _tail(-1), _contentSize(0) {
        if (initialize) {
            init();
        }
    }
 
    virtual ~CircularDifferentialBuffer() { free(_array); }
 
    bool init() {
        if (!_array) {
            _array = (int8_t*)calloc(_capacity - 1, sizeof(int8_t));
        }
        // also call clear to make sure the head and tail are reset and we
        // start with a clean buffer
        clear();
        return _array != NULL;
    }
 
    void clear() {
        _head        = 0;
        _tail        = -1;
        _contentSize = 0;
    }
 
    uint16_t size() const { return _contentSize; }
 
    uint16_t capacity() const { return _capacity; }
 
    bool empty() const { return size() == 0; }
 
    bool full() const { return size() == capacity(); }
 
    T peek() const { return _firstVal; }
 
    bool getFirstElement(T& val) {
        if (!_contentSize) {
            return false;
        }
        //      _readIdx = _head;
        _readIdx = 0;
        val      = _firstVal;
        return true;
    }
 
    bool getNextElement(T& val) {
        if (_readIdx >= (_contentSize - 1)) {
            //      if (_readIdx == _tail) {
            return false;
        }
        //      ++_readIdx;
        //      _readIdx %= (_capacity-1);
        //      val += _array[_readIdx];
        val += _array[(_head + _readIdx++) % (_capacity - 1)];
        return true;
    }
 
    bool getLastElement(T& val) {
        if (!_contentSize) {
            return false;
        }
        val = _lastVal;
        return true;
    }
 
    uint16_t getSerializedLength() const {
        if (empty()) {
            return 0;
        }
        return sizeof(T) + size() - 1;
    }
 
    void serialize(uint8_t* buffer);
 
    T pop() {
        T res = peek();
        _firstVal += _array[_head];
        incHead();
        return res;
    }
 
    bool push(T value) {
        if (!_contentSize) {
            _firstVal    = value;
            _lastVal     = value;
            _contentSize = 1;
            return true;
        }
 
        int32_t diff = (int32_t)value - _lastVal;
        if (diff > 127 || diff < -127) {
            //          LOGd("difference too large! %i", diff);
            clear();
            return false;
        }
 
        incTail();
        if (_contentSize > _capacity) {
            _firstVal += _array[_head];
            incHead();
        }
        _array[_tail] = diff;
        _lastVal      = value;
        return true;
    }
 
private:
    int8_t* _array;
 
    uint16_t _capacity;
 
    uint16_t _head;
 
    uint16_t _tail;
 
    uint16_t _contentSize;
 
    T _firstVal;
 
    T _lastVal;
 
    uint16_t _readIdx;
 
    void incTail() {
        ++_tail;
        _tail %= (_capacity - 1);
        ++_contentSize;
    }
 
    void incHead() {
        ++_head;
        _head %= (_capacity - 1);
        --_contentSize;
    }
};