marvin_SwapBuffer.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_SWAPBUFFER_H
#define MARVIN_SWAPBUFFER_H
#include <marvin/library/marvin_Concepts.h>
#include <type_traits>
#include <vector>
#include <span>
#include <cassert>
 
namespace marvin::containers {
    template <typename T>
    requires std::is_default_constructible_v<T> &&
             std::is_copy_constructible_v<T> &&
             std::is_move_constructible_v<T>
    class SwapBuffer final {
    public:
        SwapBuffer() = default;
        SwapBuffer(const SwapBuffer<T>& other) = default;
        SwapBuffer(SwapBuffer<T>&& other) noexcept = default;

        explicit SwapBuffer(size_t len) {
            m_a.resize(len);
            m_b.resize(len);
        }

        SwapBuffer(size_t len, T fillV) {
            m_a.resize(len);
            m_b.resize(len);
            std::fill(m_a.begin(), m_a.end(), fillV);
            std::fill(m_b.begin(), m_b.end(), fillV);
        }
 
        ~SwapBuffer() noexcept = default;
 
        SwapBuffer& operator=(const SwapBuffer<T>& other) = default;
        SwapBuffer& operator=(SwapBuffer<T>&& other) noexcept = default;

        [[nodiscard]] size_t size() const noexcept {
            assert(m_a.size() == m_b.size());
            return m_a.size();
        }

        void reserve(size_t toReserve) {
            m_a.reserve(toReserve);
            m_b.reserve(toReserve);
        }

        void resize(size_t newSize) {
            m_a.resize(newSize);
            m_b.resize(newSize);
        }

        [[nodiscard]] std::span<T> getFrontBuffer() {
            auto& buffToUse = m_aIsFrontBuffer ? m_a : m_b;
            return buffToUse;
        }

        [[nodiscard]] std::span<T> getBackBuffer() {
            auto& buffToUse = m_aIsFrontBuffer ? m_b : m_a;
            return buffToUse;
        }

        void swap() noexcept {
            m_aIsFrontBuffer = !m_aIsFrontBuffer;
        }
 
 
    private:
        std::vector<T> m_a;
        std::vector<T> m_b;
        bool m_aIsFrontBuffer{ true };
    };
} // namespace marvin::containers
#endif