CircularBuffer.hpp

Go to the documentation of this file.

/******************************************************************************
* Copyright (c) ATTX INC 2025. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the
* proprietary and confidential information of ATTX, INC. The Software is
* furnished under a license agreement between ATTX and the user organization
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or
* transmitted in any form or by any means, for any purpose, without the express
* written permission of ATTX, INC.
******************************************************************************/
/*
 
Author: Will Burken
*/
#ifndef DATA_MANAGEMENT_CIRC_BUFF_HPP
#define DATA_MANAGEMENT_CIRC_BUFF_HPP
 
#include <stdint.h>
 
#include "types.h"
#include "architecture/Queue.hpp"
 
namespace clockwerk {

template <typename T, uint32 L>
class CircularBuffer : public Queue<T, L> {
public:
    // Can't actually do anything in the constructor 
    CircularBuffer() {}

    int16 write(const T& instance);
    int16 writeBuffer(const T* buffer, uint32 size);
 
};
 
template <typename T, uint32 L>
int16 CircularBuffer<T, L>::write(const T& instance) {
    int16 err = NO_ERROR;
    // Check if buffer is full. is so, read one value to make space
    if(!Queue<T, L>::_vals_available) {
        Queue<T, L>::pop();
        err = WARNING_BUFFER_FULL;
    }
 
    Queue<T,L>::write(instance);
    return err;
}
 
template <typename T, uint32 L>
int16 CircularBuffer<T, L>::writeBuffer(const T* buffer, uint32 size) {
    if(buffer == nullptr) {
        return ERROR_NULLPTR;
    }
    if(size > L) {
        return ERROR_QUEUE_FULL;
    }
 
    int16 err = NO_ERROR;
 
    // Check and return if buffer doesn't have enough space
    while(size > Queue<T, L>::_vals_available) {
        Queue<T, L>::pop();
        err = WARNING_BUFFER_FULL;
    }
    Queue<T, L>::writeBuffer(buffer, size);
    return err;
}
 
}
 
#endif