//This is how the IArithmetic<T> interface might be used
//to implement generic structs similar to the 
//System.Drawing.Point, System.Drawing.PointF,System.Drawing.Size,System.Drawing.SizeF
//structures.

namespace Lambda.Drawing
{
    using System;
    using System.Generic;

    /// <summary>
    /// A generic 2D size type. Since this is a struct, we require the element type
    /// <typeparamref name="T"/> to be a struct as well. We also require that T implements
    /// IArithmetic<typeparamref name="T"/> (for + and - operations) and 
    /// IComparable<typeparamref name="T"/> (for == and IsEmpty)/>
    /// </summary>
    /// <typeparam name="T">The element type</typeparam>
    public struct Size<T>
        where T : struct, IArithmetic<T>, IComparable<T>
    {
        private T width, height;
        public static Size<T> Empty
        {
            get { return new Size<T>(default(T), default(T)); }
        }
        public bool IsEmpty
        {
            get { return (width.Equals(default(T))) && (height.Equals(default(T))); }
        }
        public T Width
        {
            get { return width; }
            set { width = value; }
        }
        public T Height
        {
            get { return height; }
            set { height = value; }
        }
        public Size(T width, T height)
        {
            this.width = width;
            this.height = height;
        }
        public static Size<T> operator +(Size<T> a, Size<T> b)
        {
            return new Size<T>(a.Width.Add(b.Width), a.Height.Add(b.Height));
        }
        public static Size<T> operator -(Size<T> a, Size<T> b)
        {
            return new Size<T>(a.Width.Subtract(b.Width), a.Height.Subtract(b.Height));
        }
    }
    /// <summary>
    /// A generic 2D point type. Since this is a struct, we require the element type
    /// <typeparamref name="T"/> to be a struct as well. We also require that T implements
    /// IArithmetic<typeparamref name="T"/> (for + and - operations) and 
    /// IComparable<typeparamref name="T"/> (for == and IsEmpty)/>
    /// </summary>
    /// <typeparam name="T">The element type</typeparam>
    public struct Point<T>
        where T : struct, IArithmetic<T>, IComparable<T>
    {
        private T x, y;
        public static Point<T> Empty
        {
            get { return new Point<T>(default(T), default(T)); }
        }
        public bool IsEmpty
        {
            get { return x.Equals(default(T)) && y.Equals(default(T)); }
        }
        public T X
        {
            get { return x; }
            set { x = value; }
        }
        public T Y
        {
            get { return y; }
            set { y = value; }
        }
        public Point(T x, T y)
        {
            this.x = x;
            this.y = y;
        }
        public static Point<T> operator +(Point<T> p, Size<T> s)
        {
            return new Point<T>(p.X.Add(s.Width), p.Y.Add(s.Height));
        }
        public static Point<T> operator -(Point<T> p, Size<T> s)
        {
            return new Point<T>(p.X.Subtract(s.Width), p.Y.Subtract(s.Height));
        }
    }
}