CircularBuffer.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef CIRCULARBUFFER_HPP_INCLUDE
#define CIRCULARBUFFER_HPP_INCLUDE
 
#include <stdlib.h>
 
#include <vector>
 
#include "geopm_public.h"
 
#include "Exception.hpp"
 
namespace geopm
{
    template <class type>
    class CircularBuffer
    {
        public:
            CircularBuffer();
            CircularBuffer(unsigned int size);
            virtual ~CircularBuffer();
            void set_capacity(const unsigned int size);
            void clear(void);
            //
            int size(void) const;
            int capacity(void) const;
            void insert(const type value);
            const type& value(const int index) const;
            std::vector<type> make_vector(void) const;
            std::vector<type> make_vector(const unsigned int start, const unsigned int end) const;
        private:
            std::vector<type> m_buffer;
            unsigned long m_head;
            unsigned long m_count;
            size_t m_max_size;
    };
 
    template <class type>
    CircularBuffer<type>::CircularBuffer()
        : CircularBuffer(0)
    {
 
    }
 
    template <class type>
    CircularBuffer<type>::CircularBuffer(unsigned int size)
        : m_buffer(size)
        , m_head(0)
        , m_count(0)
        , m_max_size(size)
    {
 
    }
 
    template <class type>
    CircularBuffer<type>::~CircularBuffer()
    {
 
    }
 
    template <class type>
    int CircularBuffer<type>::size() const
    {
        return m_count;
    }
 
    template <class type>
    int CircularBuffer<type>::capacity() const
    {
        return m_max_size;
    }
 
    template <class type>
    void CircularBuffer<type>::clear()
    {
        m_head = 0;
        m_count = 0;
    }
 
    template <class type>
    void CircularBuffer<type>::set_capacity(const unsigned int size)
    {
        // If the requested new capacity is less than the size.
        if (size < m_count && m_max_size > 0) {
            int size_diff = m_count - size;
            std::vector<type> temp;
            for (size_t idx = size_diff; idx < m_count; ++idx) {
                temp.push_back(value(idx));
            }
            //now re-size and swap out with tmp vector data
            m_buffer.resize(size);
            m_buffer.swap(temp);
            m_count = size;
        }
        else {
            m_buffer.resize(size);
        }
        m_head = 0;
        m_max_size = size;
    }
 
    template <class type>
    void CircularBuffer<type>::insert(const type value)
    {
        if (m_max_size < 1) {
            throw Exception("CircularBuffer::insert(): Cannot insert into a buffer of 0 size", GEOPM_ERROR_RUNTIME, __FILE__, __LINE__);
        }
        if (m_count < m_max_size) {
            m_buffer.at(m_count) = value;
            m_count++;
        }
        else {
            m_buffer.at(m_head) = value;
            m_head = ((m_head + 1) % m_max_size);
        }
    }
 
    template <class type>
    const type& CircularBuffer<type>::value(const int index) const
    {
        if (index >= static_cast<int>(m_count) || index < -static_cast<int>(m_count)) {
            throw Exception(std::string("CircularBuffer::value(): index [") + std::to_string(index) + "] is out of bounds",
                GEOPM_ERROR_INVALID, __FILE__, __LINE__);
        }
        if (index < 0) {
            const int new_index = m_count + index;
            return m_buffer.at((m_head + new_index) % m_max_size);
        } else {
            return m_buffer.at((m_head + index) % m_max_size);
        }
    }
 
    template <class type>
    std::vector<type> CircularBuffer<type>::make_vector(void) const
    {
        std::vector<type> result(size());
        if (m_head == 0) {
            std::copy(m_buffer.begin(), m_buffer.begin() + m_count, result.begin());
        }
        else {
            std::copy(m_buffer.begin() + m_head, m_buffer.end(), result.begin());
            std::copy(m_buffer.begin(), m_buffer.begin() + m_head, result.end() - m_head);
        }
        return result;
    }
 
    template <class type>
    std::vector<type> CircularBuffer<type>::make_vector(const unsigned int idx_start, const unsigned int idx_end) const
    {
        if (idx_start >= (unsigned int)size()) {
            throw Exception("CircularBuffer::make_vector(): start is out of bounds", GEOPM_ERROR_INVALID, __FILE__, __LINE__);
        }
        if (idx_end > (unsigned int)size()) {
            throw Exception("CircularBuffer::make_vector(): end is out of bounds", GEOPM_ERROR_INVALID, __FILE__, __LINE__);
        }
        if (idx_end <= idx_start) {
            throw Exception("CircularBuffer::make_vector(): end index is smaller than start index", GEOPM_ERROR_INVALID, __FILE__, __LINE__);
        }
 
        int slice_length = idx_end - idx_start;
        std::vector<type> result(slice_length);
 
        unsigned int start=(m_head + idx_start) % capacity();
        unsigned int end=(((m_head + idx_end) - 1) % capacity()) + 1;
 
        if(end > start) {
            std::copy(m_buffer.begin() + start, m_buffer.begin() + end, result.begin());
        }
        else {
            std::copy(m_buffer.begin() + start, m_buffer.end(), result.begin());
            std::copy(m_buffer.begin(), m_buffer.begin() + end, result.begin() + capacity() - start);
        }
        return result;
    }
 
}
 
#endif