Config.ttinclude

<#
/*
 * Copyright (C) 2017-2018  Kazuya Ujihara <ujihara.kazuya@gmail.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT Any WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 #>

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".tt.cs" #>
<#@ Assembly Name="System.Core.dll" #>
<#@ Assembly Name="System.Xml.dll" #>
<#@ Assembly Name="System.Xml.Linq.dll" #>
<#@ import namespace="System" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Diagnostics" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Xml.Linq" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Text.RegularExpressions" #>

<#+
    static Regex OSplitter = new Regex(@"(?<name>\w+)(\((?<tostring>.*)\))?(\{\*\*(?<parameters>.*)\*\*\})?(\:(?<summary>.*))?", RegexOptions.Compiled);

    public string OName(string s)
    {
        return OSplitter.Match(s).Groups["name"].Value;
    }

    public string OString(string s)
    {
        var m = OSplitter.Match(s);
        var t = m.Groups["tostring"].Value;
        if (string.IsNullOrEmpty(t))
            return m.Groups["name"].Value;
        return t;
    }

	public string ParametersString(string s)
    {
        var m = OSplitter.Match(s);
        var t = m.Groups["parameters"].Value;
        if (string.IsNullOrEmpty(t))
            return null;
        return t;
    }

	public string SummaryString(string s)
    {
        var m = OSplitter.Match(s);
        var t = m.Groups["summary"].Value;
        if (string.IsNullOrEmpty(t))
            return null;
        return t;
    }

	public string StructOrClass(bool isStruct)
	{
		return isStruct ? "struct" : "class";
	}

	public void EndGenerateEnumBody()
	{
#>
	}
<#+
	}

	public void GenerateEnumBody(string name, string[] entities, bool isStruct)
	{
		GenerateEnumBody(name, entities, isStruct, null);
	}

    public void GenerateEnumBody(string name, string[] entities, string implements)
    {
		GenerateEnumBody(name, entities, false, implements);
	}

	public void GenerateEnumBody(string name, string[] entities, bool isStruct, string implements)
    {
#>
    partial <#= StructOrClass(isStruct)  #> <#= name #> : System.IComparable<<#= name #>>, System.IComparable
<#+
		if (implements != null)
		{
#>
			 , <#= implements #> 
<#+
		}
#>
    {
		/// <summary>
		/// The <see cref="Ordinal"/> values of <see cref="<#= name #>"/>.
		/// </summary>
		/// <seealso cref="<#= name #>"/>
        <#= isStruct ? "public" : "internal" #> static partial class O
        {
<#+ 
        for (var i = 0; i < entities.Length; i++) 
        {
            var s = entities[i];
			string value_string = " " + i.ToString();
#>
            public const int <#= OName(s) #> =<#= value_string #>;
<#+ 
        }
#>          
        }

        private readonly int ordinal;
		/// <summary>
		/// The ordinal of this enumeration constant. The list is in <see cref="O"/>.
		/// </summary>
		/// <seealso cref="O"/>
        public int Ordinal => ordinal;

		/// <inheritdoc/>
        public override string ToString()
        {
            return names[Ordinal];
        }

        private static readonly string[] names = new string[] 
        {
<#+ 
foreach (var s in entities) 
{
#>
            "<#= OString(s) #>", 
<#+ 
} 
#>         
        };

        private <#= name #>(int ordinal)
        {
            this.ordinal = ordinal;
        }

        public static explicit operator <#= name #>(int ordinal)
        {
            return To<#= name #>(ordinal);
        }

        public static <#= name #> To<#= name #>(int ordinal)
        {
            if (!(0 <= ordinal && ordinal < values.Length))
                throw new System.ArgumentOutOfRangeException(nameof(ordinal));
            return values[ordinal];
        }

		public static explicit operator int(<#= name #> o)
        {
            return ToInt32(o);
        }

        public static int ToInt32(<#= name #> o)
        {
            return o.Ordinal;
        }

<#+
    for (var i = 0; i < entities.Length; i++)
    {
        var s = entities[i];
        var ss = SummaryString(s);
        if (ss != null)
        {
#>
        /// <summary>
        /// <#= ss #>
        /// </summary>
<#+
        }
		string init_param = ParametersString(s);
		if (init_param == null)
			init_param = i.ToString();
		else
			init_param = i.ToString() + "," + init_param;
#>
        public static readonly <#= name #> <#= OName(s) #> = new <#= name #>(<#= init_param #>);
<#+
    }
#>
        private static readonly <#= name #>[] values = new <#= name #>[]
        {
<#+ foreach (var s in entities) { #>
            <#= OName(s) #>, 
<#+ } #>    
        };
        public static System.Collections.Generic.IReadOnlyList<<#= name #>> Values => values;

<#+
        if (isStruct) 
        {    
#>
        /* Avoid to cause compiling error */

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
		public static bool operator==(<#= name #> a, object b)
        {
            throw new System.Exception();
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
        public static bool operator!=(<#= name #> a, object b)
        {
            throw new System.Exception();
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
        public static bool operator==(object a, <#= name #> b)
        {
            throw new System.Exception();
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1065:DoNotRaiseExceptionsInUnexpectedLocations")]
        public static bool operator!=(object a, <#= name #> b)
        {
            throw new System.Exception();
        }

<#+
        }
#>

        public static bool operator==(<#= name #> a, <#= name #> b)
        {
<#+
         if (!isStruct) 
        {    
#>
            if (ReferenceEquals(a, b))
                return true;
            if (a is null || b is null)
                return false;
<#+
        }
#>            
            return a.Ordinal == b.Ordinal;
        }

        public static bool operator !=(<#= name #> a, <#= name #> b)
        {
            return !(a == b);
        }

		/// <inheritdoc/>
        public override bool Equals(object obj)
        {
<#+ if (isStruct) { #>    
            if (!(obj is <#= name #>))
                return false;
            return this.Ordinal == ((<#= name #>)obj).Ordinal;
<#+ } else { #>
            var o = obj as <#= name #>;
            return this.Ordinal == o.Ordinal;
<#+ } #>
        }

		/// <inheritdoc/>
        public override int GetHashCode()
        {
            return Ordinal;
        }

		/// <inheritdoc/>
        public int CompareTo(object obj)
        {
            var o = (<#= name #>)obj;
            return ((int)Ordinal).CompareTo((int)o.Ordinal);
        }   

		/// <inheritdoc/>
        public int CompareTo(<#= name #> o)
        {
            return (Ordinal).CompareTo(o.Ordinal);
        }   	
<#+
    }
#>