cs_StreamBufferAccessor.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Apr 3, 2020
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
 
#pragma once
 
#include <structs/cs_BufferAccessor.h>
 
class StreamBufferAccessor {
public:
    StreamBufferAccessor(buffer_ptr_t buffer, cs_buffer_size_t size) { assign(buffer, size); }
    StreamBufferAccessor(cs_data_t data) : StreamBufferAccessor(data.data, data.len) {}
 
    void reset() {
        internal_status = ERR_SUCCESS;
        buff_curr       = buff_begin;
    }
 
    cs_ret_code_t assign(buffer_ptr_t buffer, cs_buffer_size_t size) {
        buff_begin = buffer;
        buff_end   = buffer + size;
        reset();
 
        return ERR_SUCCESS;
    }
 
    cs_buffer_size_t getSerializedSize() const { return buff_curr - buff_begin; }
 
    cs_buffer_size_t getBufferSize() const { return buff_end - buff_begin; }
 
    cs_buffer_size_t getRemainingCapacity() const { return buff_end - buff_curr; }
 
    cs_data_t getSerializedBuffer() { return cs_data_t(buff_begin, getBufferSize()); }
 
    // ============ Get ============
 
    template <class T>
    StreamBufferAccessor& get(T*& packet_ptr) {
        if (!status_check()) {
            // failed status check
            // ignore get request when failure
            return *this;
        }
 
        if (!size_check<T>()) {
            // failed size check
            packet_ptr      = nullptr;
            internal_status = ERR_NO_SPACE;
        }
        else {
            // write to the out-parameter packet_ptr
            packet_ptr = reinterpret_cast<T*>(buff_curr);
            increment_buff<T>();
        }
 
        return *this;
    }
 
    template <class T>
    T get() {
        if (!size_check<T>() && !status_check()) {
            increment_buff<T>();
            return *reinterpret_cast<T*>(buff_curr);
        }
 
        // try to return a default when possible
        internal_status = ERR_NO_SPACE;
        return T();
    }
 
    // ============ Set ============
 
    template <class T>
    void put(T packet) {
        if (size_check<T>() && status_check()) {
            // copy into the buffer, after that, increment
            *reinterpret_cast<T*>(buff_curr) = packet;
            increment_buff<T>();
        }
        else {
            // failed size_check
            internal_status = ERR_NO_SPACE;
        }
    }
 
protected:
    // returns false on failure
    template <class T>
    inline bool size_check() {
        return buff_curr + sizeof(T) <= buff_end;
    }
 
    template <class T>
    inline void increment_buff() {
        buff_curr += sizeof(T);
    }
 
    // returns false on failure
    inline bool status_check() { return internal_status == ERR_SUCCESS; }
 
private:
    buffer_ptr_t buff_begin;
    buffer_ptr_t buff_curr;
    buffer_ptr_t buff_end;
 
    cs_ret_code_t internal_status;
};