circular_buffer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _CIRCULAR_BUFFER_H_
#define _CIRCULAR_BUFFER_H_
 
#include <stdint.h>
#include <stdbool.h>
 
typedef struct _circular_buffer {
    uint32_t buffer_size;
    uint32_t output;
    uint32_t input;
    uint32_t overflows;
    uint32_t buffer[];
} _circular_buffer;
 
typedef _circular_buffer *circular_buffer;
 
static inline uint32_t _circular_buffer_next(
        circular_buffer buffer, uint32_t current) {
    return (current + 1) & buffer->buffer_size;
}
 
static inline bool _circular_buffer_not_empty(circular_buffer buffer) {
    return buffer->input != buffer->output;
}
 
static inline bool _circular_buffer_not_full(
        circular_buffer buffer, uint32_t next) {
    return next != buffer->output;
}
 
circular_buffer circular_buffer_initialize(uint32_t size);
 
static inline bool circular_buffer_add(circular_buffer buffer, uint32_t item) {
    uint32_t next = _circular_buffer_next(buffer, buffer->input);
    bool success = _circular_buffer_not_full(buffer, next);
 
    if (success) {
        buffer->buffer[buffer->input] = item;
        buffer->input = next;
    } else {
        buffer->overflows++;
    }
 
    return success;
}
 
static inline bool circular_buffer_get_next(
        circular_buffer buffer, uint32_t *item) {
    bool success = _circular_buffer_not_empty(buffer);
 
    if (success) {
        *item = buffer->buffer[buffer->output];
        buffer->output = _circular_buffer_next(buffer, buffer->output);
    }
 
    return success;
}
 
static inline bool circular_buffer_advance_if_next_equals(
        circular_buffer buffer, uint32_t item) {
    bool success = _circular_buffer_not_empty(buffer);
    if (success) {
        success = (buffer->buffer[buffer->output] == item);
        if (success) {
            buffer->output = _circular_buffer_next(buffer, buffer->output);
        }
    }
    return success;
}
 
static inline uint32_t circular_buffer_size(circular_buffer buffer) {
    return buffer->input >= buffer->output
        ? buffer->input - buffer->output
        : (buffer->input + buffer->buffer_size + 1) - buffer->output;
}
 
static inline uint32_t circular_buffer_get_n_buffer_overflows(
        circular_buffer buffer) {
    return buffer->overflows;
}
 
static inline void circular_buffer_clear(circular_buffer buffer) {
    buffer->input = 0;
    buffer->output = 0;
}
 
void circular_buffer_print_buffer(circular_buffer buffer);
 
//---------------------------------------
// Synaptic rewiring support functions
//---------------------------------------
static inline uint32_t circular_buffer_input(circular_buffer buffer) {
    return buffer->input;
}
 
static inline uint32_t circular_buffer_output(circular_buffer buffer) {
    return buffer->output;
}
 
static inline uint32_t circular_buffer_real_size(circular_buffer buffer) {
    return buffer->buffer_size;
}
 
static inline uint32_t circular_buffer_value_at_index(
        circular_buffer buffer, uint32_t index) {
    return buffer->buffer[index & buffer->buffer_size];
}
 
#endif // _CIRCULAR_BUFFER_H_