ble_notify_queue.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/int.h"
#include "fl/stl/vector.h"
 
namespace fl {
namespace net {
namespace ble {

class BleNotifyQueue {
  public:
    static constexpr size_t kCapacity = 4;
 
  private:
    static constexpr size_t kSlots = kCapacity + 1;
 
    static size_t next(size_t index) { return (index + 1) % kSlots; }
 
  public:
    bool push(const char *data, size_t size) {
        if (data == nullptr || size == 0) {
            return false;
        }
        const size_t tail = mTail;
        const size_t advanced = next(tail);
        if (advanced == mHead) {
            return false; // full
        }
        fl::vector<u8> &slot = mSlots[tail];
        slot.clear();
        slot.reserve(size);
        for (size_t i = 0; i < size; ++i) {
            slot.push_back(static_cast<u8>(data[i]));
        }
        // Publish only after the slot is fully written.
        mTail = advanced;
        return true;
    }

    bool empty() const { return mHead == mTail; }

    size_t depth() const {
        const size_t head = mHead;
        const size_t tail = mTail;
        return (tail + kSlots - head) % kSlots;
    }

    size_t remaining() const {
        if (empty()) {
            return 0;
        }
        const size_t size = mSlots[mHead].size();
        return mOffset >= size ? 0 : size - mOffset;
    }

    const u8 *chunkData() const {
        if (remaining() == 0) {
            return nullptr;
        }
        return mSlots[mHead].data() + mOffset;
    }

    size_t chunkSize(size_t max_payload) const {
        if (max_payload == 0) {
            return 0;
        }
        const size_t left = remaining();
        return left < max_payload ? left : max_payload;
    }

    void advance(size_t sent) {
        if (empty() || sent == 0) {
            return;
        }
        const size_t head = mHead;
        const size_t size = mSlots[head].size();
        mOffset += sent;
        if (mOffset >= size) {
            mSlots[head].clear();
            mOffset = 0;
            // Release the slot last, so the producer cannot reuse it while
            // it is still being cleared.
            mHead = next(head);
        }
    }

    void dropFront() {
        if (empty()) {
            return;
        }
        const size_t head = mHead;
        mSlots[head].clear();
        mOffset = 0;
        mHead = next(head);
    }

    void clear() {
        for (size_t i = 0; i < kSlots; ++i) {
            mSlots[i].clear();
        }
        mHead = 0;
        mTail = 0;
        mOffset = 0;
    }
 
  private:
    fl::vector<u8> mSlots[kSlots];
    volatile size_t mHead = 0;
    volatile size_t mTail = 0;
    size_t mOffset = 0;
};
 
} // namespace ble
} // namespace net
} // namespace fl