vector.hpp

#pragma once
 
#include <cassert>
#include <algorithm>
#include <array>
#include <vector>
#include <ranges>
 
namespace LiteFX::Math {

    template <typename T, unsigned DIM> requires 
        (DIM > 0) && std::is_standard_layout_v<T> && std::is_trivially_copyable_v<T>
    struct Vector {
    public:
        static constexpr size_t vec_size = DIM;

        using scalar_type = T;

        using vec_type = Vector<scalar_type, vec_size>;
 
    protected:
        using array_type = std::array<scalar_type, vec_size>;
        array_type m_elements = { }; // NOLINT
 
    public:
        constexpr Vector() noexcept = default;

        constexpr Vector(Vector&& _other) noexcept = default;

        constexpr Vector(const Vector& _other) = default;

        constexpr Vector& operator=(Vector&& _other) noexcept = default;

        constexpr Vector& operator=(const Vector& _other) = default;

        constexpr ~Vector() noexcept = default;

        constexpr Vector(T val) noexcept {
            std::fill(std::begin(m_elements), std::end(m_elements), val);
        }

        constexpr Vector(T x, T y) noexcept requires(DIM == 2)
        {
            // NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
            m_elements[0] = x;
            m_elements[1] = y;
            // NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr Vector(T x, T y, T z) noexcept requires(DIM == 3)
        {
            // NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
            m_elements[0] = x;
            m_elements[1] = y;
            m_elements[2] = z;
            // NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr Vector(T x, T y, T z, T w) noexcept requires(DIM == 4)
        {
            // NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
            m_elements[0] = x;
            m_elements[1] = y;
            m_elements[2] = z;
            m_elements[3] = w;
            // NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr explicit Vector(std::ranges::input_range auto&& input) noexcept requires
            std::is_nothrow_convertible_v<std::ranges::range_value_t<decltype(input)>, T>
        {
            std::ranges::copy(input, std::begin(m_elements));
        }

        constexpr auto& operator=(std::ranges::input_range auto&& input) noexcept requires
            std::is_nothrow_convertible_v<std::ranges::range_value_t<decltype(input)>, T>
        {
            std::ranges::copy(input, std::begin(m_elements));
            return *this;
        }
 
    public:
        constexpr T operator[](unsigned int i) const noexcept {
            assert(i < DIM);
 
            return m_elements[i % DIM]; // NOLINT
        }

        constexpr T& operator[](unsigned int i) noexcept {
            assert(i < DIM);
 
            return m_elements[i % DIM]; // NOLINT
        }

        constexpr auto begin() noexcept {
            return m_elements.begin();
        }

        constexpr auto end() noexcept {
            return m_elements.end();
        }

        constexpr auto cbegin() const noexcept {
            return m_elements.cbegin();
        }

        constexpr auto cend() const noexcept {
            return m_elements.cend();
        }
 
    public:
        constexpr const scalar_type* elements() const noexcept {
            return m_elements.data();
        }

        constexpr operator std::array<T, DIM>() const noexcept {
            return m_elements;
        }

        constexpr operator std::vector<T>() const {
            return std::vector<T>(std::begin(m_elements), std::end(m_elements));
        }

        constexpr int size() const noexcept {
            return vec_size;
        }

        constexpr scalar_type x() const noexcept requires (DIM > 0) {
            return m_elements[0]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type& x() noexcept requires (DIM > 0) {
            return m_elements[0]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type y() const noexcept requires (DIM > 1) {
            return m_elements[1]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type& y() noexcept requires (DIM > 1) {
            return m_elements[1]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type z() const noexcept requires (DIM > 2) {
            return m_elements[2]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type& z() noexcept requires (DIM > 2) {
            return m_elements[2]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type w() const noexcept requires (DIM > 3) {
            return m_elements[3]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr scalar_type& w() noexcept requires (DIM > 3) {
            return m_elements[3]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }
    };

    template<typename T> using TVector1 = Vector<T, 1>;

    template<typename T> using TVector2 = Vector<T, 2>;

    template<typename T> using TVector3 = Vector<T, 3>;

    template<typename T> using TVector4 = Vector<T, 4>;
 
}