#pragma once

#ifndef TCG_SIZE_H

#define TCG_SIZE_H

namespace tcg

{

//**********************************************************************************

//    Bidimensional size  class

//**********************************************************************************

template <typename t=""></typename>

struct SizeT {

	typedef T value_type;

public:

	T w, h;

public:

	SizeT() : w(), h() {}

	SizeT(T w_, T h_) : w(w_), h(h_) {}

	bool empty() const { return (w <= 0) || (h <= 0); }

	SizeT &operator+=(const SizeT &other)

	{

		w += other.w, h += other.h;

		return *this;

	}

	SizeT &operator-=(const SizeT &other)

	{

		w -= other.w, h -= other.h;

		return *this;

	}

	friend SizeT<t> operator+(const SizeT<t> &a, const SizeT<t> &b)</t></t></t>

	{

		return SizeT<t>(a.w + b.w, a.h + b.h);</t>

	}

	friend SizeT<t> operator-(const SizeT<t> &a, const SizeT<t> &b)</t></t></t>

	{

		return SizeT<t>(a.w - b.w, a.h - b.h);</t>

	}

	template <typename k=""></typename>

	SizeT &operator*=(K k)

	{

		w *= k, h *= k;

		return *this;

	}

	template <typename k=""></typename>

	SizeT &operator/=(K k)

	{

		w /= k, h /= k;

		return *this;

	}

	template <typename k=""></typename>

	friend SizeT<t> operator*(K k, const SizeT<t> &a)</t></t>

	{

		return SizeT<t>(k * a.w, k * a.h);</t>

	}

	template <typename k=""></typename>

	friend SizeT<t> operator*(const SizeT<t> &a, K k)</t></t>

	{

		return SizeT<t>(a.w * k, a.h * k);</t>

	}

	template <typename k=""></typename>

	friend SizeT<t> operator/(const SizeT<t> &a, K k)</t></t>

	{

		return SizeT<t>(a.w / k, a.h / k);</t>

	}

	SizeT &operator&=(const SizeT &other)

	{

		if (other.w < w)

			w = other.w;

		if (other.h < h)

			h = other.h;

		return *this;

	}

	SizeT &operator|=(const SizeT &other)

	{

		if (other.w > w)

			w = other.w;

		if (other.h > h)

			h = other.h;

		return *this;

	}

	friend SizeT<t> operator&(const SizeT<t> &a, const SizeT<t> &b)</t></t></t>

	{

		SizeT<t> tmp(a);</t>

		return tmp &= b;

	}

	friend SizeT<t> operator|(const SizeT<t> &a, const SizeT<t> &b)</t></t></t>

	{

		SizeT<t> tmp(a);</t>

		return tmp |= b;

	}

};

//------------------------------------------------------------------------

typedef SizeT<int> SizeI;</int>

typedef SizeI Size;

typedef SizeT<double> SizeD;</double>

//**********************************************************************************

//    Tridimensional size  class

//**********************************************************************************

template <typename t=""></typename>

struct Size3T {

	typedef T value_type;

public:

	T w, h, d;

public:

	Size3T() : w(), h(), d() {}

	Size3T(T w_, T h_, T d_) : w(w_), h(h_), d(d_) {}

	bool empty() const { return (w <= 0) || (h <= 0) || (d <= 0); }

	Size3T &operator+=(const Size3T &other)

	{

		w += other.w, h += other.h, d += other.d;

		return *this;

	}

	Size3T &operator-=(const Size3T &other)

	{

		w -= other.w, h -= other.h, d -= other.d;

		return *this;

	}

	friend Size3T<t> operator+(const Size3T<t> &a, const Size3T<t> &b)</t></t></t>

	{

		return SizeT<t>(a.w + b.w, a.h + b.h, a.d + b.d);</t>

	}

	friend Size3T<t> operator-(const Size3T<t> &a, const Size3T<t> &b)</t></t></t>

	{

		return SizeT<t>(a.w - b.w, a.h - b.h, a.d + b.d);</t>

	}

	template <typename k=""></typename>

	Size3T &operator*=(K k)

	{

		w *= k, h *= k, d *= k;

		return *this;

	}

	template <typename k=""></typename>

	Size3T &operator/=(K k)

	{

		w /= k, h /= k, d /= k;

		return *this;

	}

	template <typename k=""></typename>

	friend Size3T<t> operator*(K k, const Size3T<t> &a)</t></t>

	{

		return Size3T<t>(k * a.w, k * a.h, k * a.d);</t>

	}

	template <typename k=""></typename>

	friend Size3T<t> operator*(const Size3T<t> &a, K k)</t></t>

	{

		return Size3T<t>(a.w * k, a.h * k, a.d * k);</t>

	}

	template <typename k=""></typename>

	friend Size3T<t> operator/(const Size3T<t> &a, K k)</t></t>

	{

		return Size3T<t>(a.w / k, a.h / k, a.d / k);</t>

	}

	Size3T &operator&=(const Size3T &other)

	{

		if (other.w < w)

			w = other.w;

		if (other.h < h)

			h = other.h;

		if (other.d < d)

			d = other.d;

		return *this;

	}

	Size3T &operator|=(const Size3T &other)

	{

		if (other.w > w)

			w = other.w;

		if (other.h > h)

			h = other.h;

		if (other.d > d)

			d = other.d;

		return *this;

	}

	friend Size3T<t> operator&(const Size3T<t> &a, const Size3T<t> &b)</t></t></t>

	{

		Size3T<t> tmp(a);</t>

		return tmp &= b;

	}

	friend Size3T<t> operator|(const Size3T<t> &a, const Size3T<t> &b)</t></t></t>

	{

		Size3T<t> tmp(a);</t>

		return tmp |= b;

	}

};

//------------------------------------------------------------------------

typedef Size3T<int> Size3I;</int>

typedef Size3I Size3;

typedef Size3T<double> Size3D;</double>

//**********************************************************************************

//    N-dimensional size  class

//**********************************************************************************

template <int n,="" t="" typename=""></int>

struct SizeN {

	static const int size = N;

	typedef T value_type;

public:

	T span[N];

public:

	SizeN() {}

	SizeN(const T &t) { std::fill(span, span + N, t); }

	template <typename it=""></typename>

	SizeN(It begin, It end)

	{

		std::copy(begin, end, span);

	}

	// To be completed...

};

} // namespace tcg

#endif // TCG_SIZE_H