buffer_view.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include "ravennakit/core/assert.hpp"
#include "ravennakit/core/byte_order.hpp"
 
#include <cstddef>
#include <array>
#include <vector>
 
namespace rav {

template<class Type>
class BufferView {
  public:
    BufferView() = default;
 
    BufferView(const BufferView& other) = default;
    BufferView& operator=(const BufferView& other) = default;
 
    BufferView(BufferView&& other) noexcept = default;
    BufferView& operator=(BufferView&& other) noexcept = default;

    BufferView(Type* data, const size_t size) : data_(data), size_(size) {
        if (data_ == nullptr) {
            size_ = 0;
        }
    }

    template<size_t S>
    explicit BufferView(const std::array<Type, S>& array) : BufferView(array.data(), array.size()) {}

    template<typename T = Type, std::enable_if_t<!std::is_const_v<T>, int> = 0>  // Type must be non-const for vector.
    explicit BufferView(const std::vector<Type>& vector) : BufferView(vector.data(), vector.size()) {}

    template<typename T = Type, std::enable_if_t<!std::is_const_v<T>, int> = 0>  // Type must be non-const for vector.
    explicit BufferView(std::vector<Type>& vector) : BufferView(vector.data(), vector.size()) {}

    Type& operator[](size_t index) const {
        return data_[index];
    }

    [[nodiscard]] const Type* data() const {
        return data_;
    }

    [[nodiscard]] Type* data() {
        return data_;
    }

    [[nodiscard]] size_t size() const {
        return size_;
    }

    [[nodiscard]] size_t size_bytes() const {
        return size_ * sizeof(Type);
    }

    [[nodiscard]] bool empty() const {
        return size_ == 0;
    }

    template<typename ValueType, std::enable_if_t<std::is_trivially_copyable_v<ValueType>, bool> = true>
    ValueType read_ne(const size_t offset) const {
        RAV_ASSERT(offset + sizeof(ValueType) <= size_bytes(), "Buffer view out of bounds");
        return rav::read_ne<ValueType>(data_ + offset);
    }

    template<typename ValueType, std::enable_if_t<std::is_trivially_copyable_v<ValueType>, bool> = true>
    ValueType read_be(const size_t offset) const {
        return swap_if_le(read_ne<ValueType>(offset));
    }

    template<typename ValueType, std::enable_if_t<std::is_trivially_copyable_v<ValueType>, bool> = true>
    ValueType read_le(const size_t offset) const {
        return swap_if_be(read_ne<ValueType>(offset));
    }

    [[nodiscard]] BufferView subview(size_t offset) const {
        offset = std::min(offset, size_);
        return BufferView(data_ + offset, size_ - offset);
    }

    [[nodiscard]] BufferView subview(size_t offset, const size_t size) const {
        offset = std::min(offset, size_);
        return BufferView(data_ + offset, std::min(size_ - offset, size));
    }

    BufferView<std::add_const_t<Type>> const_view() const {
        return BufferView<std::add_const_t<Type>>(data_, size_);
    }

    template<class NewType>
    BufferView<NewType> reinterpret() const {
        return BufferView<NewType>(reinterpret_cast<NewType*>(data_), size_ * sizeof(Type) / sizeof(NewType));
    }
 
  private:
    Type* data_ {nullptr};
    size_t size_ {0};
};
 
}  // namespace rav