Vector2.h

#pragma once

#include <cassert>

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

            T array[2];     
        };

        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);
            return array[n];
        }

        const T& operator [] (int n) const noexcept {
            assert(n < 2);
            return array[n];
        }

        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;
}