Rest.Net/Rest.Net/Route.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;

namespace MontoyaTech.Rest.Net
{
    /// <summary>
    /// The outline of a Http Route.
    /// </summary>
    public class Route
    {
        /// <summary>
        /// The http method for this route.
        /// </summary>
        public string Method;

        /// <summary>
        /// The syntax of this route.
        /// </summary>
        public string Syntax;

        /// <summary>
        /// The target function to invoke if this route is invoked.
        /// </summary>
        private Func<RouteListenerContext, HttpListenerResponse> Target;

        /// <summary>
        /// Whether or not to close the response after the route is invoked.
        /// </summary>
        public bool CloseResponse = true;

        internal Route() { }

        /// <summary>
        /// Creates a new route with a given method, syntax, target and optional close response flag.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="method"></param>
        /// <param name="syntax"></param>
        /// <param name="target"></param>
        /// <param name="closeResponse"></param>
        public Route(string method, string syntax, Func<RouteListenerContext, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        /// <summary>
        /// Creates a new route with a given method, syntax, target and optional close response flag.
        /// </summary>
        /// <param name="name"></param>
        /// <param name="method"></param>
        /// <param name="syntax"></param>
        /// <param name="target"></param>
        /// <param name="closeResponse"></param>
        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        /// <summary>
        /// Returns a list of the argument names for this route.
        /// </summary>
        /// <returns></returns>
        public List<string> GetArguments()
        {
            var segments = this.Syntax.Split('/').Where(segment => segment.Length > 0).Select(segment => segment.Trim()).ToList();

            var results = new List<string>();

            foreach (var segment in segments)
                if (segment.StartsWith("{"))
                    results.Add(segment.Substring(1, segment.Length - 2));

            return results;
        }

        /// <summary>
        /// Returns the url for this route including arguments.
        /// </summary>
        /// <returns></returns>
        public string GetUrl()
        {
            var segments = this.Syntax.Split('/').Where(segment => segment.Length > 0).Select(segment => segment.Trim()).ToList();

            var builder = new StringBuilder();

            foreach (var segment in segments)
            {
                builder.Append('/');

                if (segment.StartsWith("{"))
                    builder.Append(segment);
                else if (segment == "*")
                    builder.Append("*");
                else if (segment == "**")
                    break;
                else
                    builder.Append(segment);
            }

            return builder.ToString();
        }

        /// <summary>
        /// Invokes this route with a context and a given set of string arguments.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="arguments"></param>
        public virtual void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.Invoke(context);
        }
    }

    public class Route<T1> : Route
    {
        private Func<RouteListenerContext, T1, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(context, RouteArgumentConverter.Convert<T1>(arguments[0]));
        }
    }

    public class Route<T1, T2> : Route
    {
        private Func<RouteListenerContext, T1, T2, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1])
            );
        }
    }

    public class Route<T1, T2, T3> : Route
    {
        private Func<RouteListenerContext, T1, T2, T3, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, T3, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, T3, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1]),
                RouteArgumentConverter.Convert<T3>(arguments[2])
            );
        }
    }

    public class Route<T1, T2, T3, T4> : Route
    {
        private Func<RouteListenerContext, T1, T2, T3, T4, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1]),
                RouteArgumentConverter.Convert<T3>(arguments[2]),
                RouteArgumentConverter.Convert<T4>(arguments[3])
            );
        }
    }

    public class Route<T1, T2, T3, T4, T5> : Route
    {
        private Func<RouteListenerContext, T1, T2, T3, T4, T5, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1]),
                RouteArgumentConverter.Convert<T3>(arguments[2]),
                RouteArgumentConverter.Convert<T4>(arguments[3]),
                RouteArgumentConverter.Convert<T5>(arguments[4])
            );
        }
    }

    public class Route<T1, T2, T3, T4, T5, T6> : Route
    {
        private Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1]),
                RouteArgumentConverter.Convert<T3>(arguments[2]),
                RouteArgumentConverter.Convert<T4>(arguments[3]),
                RouteArgumentConverter.Convert<T5>(arguments[4]),
                RouteArgumentConverter.Convert<T6>(arguments[5])
            );
        }
    }

    public class Route<T1, T2, T3, T4, T5, T6, T7> : Route
    {
        private Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, T7, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, T7, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, T7, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1]),
                RouteArgumentConverter.Convert<T3>(arguments[2]),
                RouteArgumentConverter.Convert<T4>(arguments[3]),
                RouteArgumentConverter.Convert<T5>(arguments[4]),
                RouteArgumentConverter.Convert<T6>(arguments[5]),
                RouteArgumentConverter.Convert<T7>(arguments[6])
            );
        }
    }

    public class Route<T1, T2, T3, T4, T5, T6, T7, T8> : Route
    {
        private Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, T7, T8, HttpListenerResponse> Target;

        public Route(string method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, T7, T8, HttpListenerResponse> target, bool closeResponse = true)
        {
            this.Method = method;
            this.Syntax = syntax;
            this.Target = target;
            this.CloseResponse = closeResponse;
        }

        public Route(HttpRequestMethod method, string syntax, Func<RouteListenerContext, T1, T2, T3, T4, T5, T6, T7, T8, HttpListenerResponse> target, bool closeResponse = true)
            : this(method.ToString(), syntax, target, closeResponse) { }

        public override void Invoke(RouteListenerContext context, params string[] arguments)
        {
            this.Target.DynamicInvoke(
                context,
                RouteArgumentConverter.Convert<T1>(arguments[0]),
                RouteArgumentConverter.Convert<T2>(arguments[1]),
                RouteArgumentConverter.Convert<T3>(arguments[2]),
                RouteArgumentConverter.Convert<T4>(arguments[3]),
                RouteArgumentConverter.Convert<T5>(arguments[4]),
                RouteArgumentConverter.Convert<T6>(arguments[5]),
                RouteArgumentConverter.Convert<T7>(arguments[6]),
                RouteArgumentConverter.Convert<T8>(arguments[7])
            );
        }
    }
}