Vector2.h

#pragma once

#include <cassert>

namespace fsdk {
    template <typename T>
    struct Vector2 {
        T x; 
        T y; 

        Vector2() noexcept
            : x((T)0)
            , y(T(0)) {
        }

        explicit Vector2(T x_) noexcept
            : x(x_)
            , y(x_) {
        }

        Vector2(T x_, T y_) noexcept
            : x(x_)
            , y(y_) {
        }

        template <typename Other>
        Vector2<T>(const Vector2<Other>& other) noexcept {
            *this = other;
        }

        template <typename Other>
        Vector2<T>& operator=(const Vector2<Other>& other) noexcept {
            x = static_cast<T>(other.x);
            y = static_cast<T>(other.y);
            return *this;
        }

        // Vector2<T>

        bool operator==(const Vector2& other) const noexcept {
            return x == other.x && y == other.y;
        }

        bool operator!=(const Vector2& other) const noexcept {
            return !(*this == other);
        }

        bool operator>(const Vector2& other) const noexcept {
            return x > other.x && y > other.y;
        }

        bool operator>=(const Vector2& other) const noexcept {
            return x >= other.x && y >= other.y;
        }

        bool operator<(const Vector2& other) const noexcept {
            return x < other.x && y < other.y;
        }

        bool operator<=(const Vector2& other) const noexcept {
            return x <= other.x && y <= other.y;
        }

        T& operator[](int n) noexcept {
            assert(n < 2);
            if(n == 0)
                return x;
            else
                return y;
        }

        const T& operator[](int n) const noexcept {
            assert(n < 2);
            if(n == 0)
                return x;
            else
                return y;
        }

        Vector2 operator-(void) const noexcept {
            return Vector2(-x, -y);
        }

        Vector2 operator+(const Vector2& rhs) const noexcept {
            return Vector2(x + rhs.x, y + rhs.y);
        }

        Vector2 operator-(const Vector2& rhs) const noexcept {
            return Vector2(x - rhs.x, y - rhs.y);
        }

        Vector2 operator*(const Vector2& rhs) const noexcept {
            return Vector2(x * rhs.x, y * rhs.y);
        }

        Vector2 operator/(const Vector2& rhs) const noexcept {
            return Vector2(x / rhs.x, y / rhs.y);
        }

        Vector2& operator+=(const Vector2& rhs) noexcept {
            *this = *this + rhs;
            return *this;
        }

        Vector2& operator-=(const Vector2& rhs) noexcept {
            *this = *this - rhs;
            return *this;
        }

        Vector2& operator*=(const Vector2& rhs) noexcept {
            *this = *this * rhs;
            return *this;
        }

        Vector2& operator/=(const Vector2& rhs) noexcept {
            *this = *this / rhs;
            return *this;
        }

        Vector2 operator+(T rhs) const noexcept {
            return Vector2(x + rhs, y + rhs);
        }

        Vector2 operator-(T rhs) const noexcept {
            return Vector2(x - rhs, y - rhs);
        }

        Vector2 operator*(T rhs) const noexcept {
            return Vector2(x * rhs, y * rhs);
        }

        Vector2 operator/(T rhs) const noexcept {
            return Vector2(x / rhs, y / rhs);
        }

        Vector2& operator+=(T rhs) noexcept {
            *this = *this + rhs;
            return *this;
        }

        Vector2& operator-=(T rhs) noexcept {
            *this = *this - rhs;
            return *this;
        }

        Vector2& operator*=(T rhs) noexcept {
            *this = *this * rhs;
            return *this;
        }

        Vector2& operator/=(T rhs) noexcept {
            *this = *this / rhs;
            return *this;
        }
    };

    typedef Vector2<float> Point2f;

    typedef Vector2<double> Point2d;

    typedef Vector2<int> Point2i;

    typedef Vector2<unsigned int> Point2u;

    typedef Vector2<unsigned short> Point2us;

    typedef Vector2<int> Size;
} // namespace fsdk