// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
// Generated from Converters.tt. Do not modify directly
 
using System;
using System.Collections.Generic;
 
namespace Microsoft.Data.Analysis
{
    internal interface IByteConverter<T>
    {
        byte GetByte(T value);
    }
    internal static class ByteConverter<T>
    {
        public static IByteConverter<T> Instance { get; } = ByteConverter.GetByteConverter<T>();
    }
    internal static class ByteConverter
    {
        public static IByteConverter<T> GetByteConverter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IByteConverter<T>)new ByteByteConverter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IByteConverter<T>)new SByteByteConverter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteByteConverter : IByteConverter<byte>
    {
        public byte GetByte(byte value)
        {
            return (byte)value;
        }
    }
    internal class SByteByteConverter : IByteConverter<sbyte>
    {
        public byte GetByte(sbyte value)
        {
            return (byte)value;
        }
    }
    internal interface ISByteConverter<T>
    {
        sbyte GetSByte(T value);
    }
    internal static class SByteConverter<T>
    {
        public static ISByteConverter<T> Instance { get; } = SByteConverter.GetSByteConverter<T>();
    }
    internal static class SByteConverter
    {
        public static ISByteConverter<T> GetSByteConverter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (ISByteConverter<T>)new ByteSByteConverter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (ISByteConverter<T>)new SByteSByteConverter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteSByteConverter : ISByteConverter<byte>
    {
        public sbyte GetSByte(byte value)
        {
            return (sbyte)value;
        }
    }
    internal class SByteSByteConverter : ISByteConverter<sbyte>
    {
        public sbyte GetSByte(sbyte value)
        {
            return (sbyte)value;
        }
    }
    internal interface IInt16Converter<T>
    {
        short GetInt16(T value);
    }
    internal static class Int16Converter<T>
    {
        public static IInt16Converter<T> Instance { get; } = Int16Converter.GetInt16Converter<T>();
    }
    internal static class Int16Converter
    {
        public static IInt16Converter<T> GetInt16Converter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IInt16Converter<T>)new ByteInt16Converter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IInt16Converter<T>)new SByteInt16Converter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IInt16Converter<T>)new Int16Int16Converter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IInt16Converter<T>)new UInt16Int16Converter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteInt16Converter : IInt16Converter<byte>
    {
        public short GetInt16(byte value)
        {
            return (short)value;
        }
    }
    internal class SByteInt16Converter : IInt16Converter<sbyte>
    {
        public short GetInt16(sbyte value)
        {
            return (short)value;
        }
    }
    internal class Int16Int16Converter : IInt16Converter<short>
    {
        public short GetInt16(short value)
        {
            return (short)value;
        }
    }
    internal class UInt16Int16Converter : IInt16Converter<ushort>
    {
        public short GetInt16(ushort value)
        {
            return (short)value;
        }
    }
    internal interface IUInt16Converter<T>
    {
        ushort GetUInt16(T value);
    }
    internal static class UInt16Converter<T>
    {
        public static IUInt16Converter<T> Instance { get; } = UInt16Converter.GetUInt16Converter<T>();
    }
    internal static class UInt16Converter
    {
        public static IUInt16Converter<T> GetUInt16Converter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IUInt16Converter<T>)new ByteUInt16Converter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IUInt16Converter<T>)new SByteUInt16Converter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IUInt16Converter<T>)new Int16UInt16Converter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IUInt16Converter<T>)new UInt16UInt16Converter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteUInt16Converter : IUInt16Converter<byte>
    {
        public ushort GetUInt16(byte value)
        {
            return (ushort)value;
        }
    }
    internal class SByteUInt16Converter : IUInt16Converter<sbyte>
    {
        public ushort GetUInt16(sbyte value)
        {
            return (ushort)value;
        }
    }
    internal class Int16UInt16Converter : IUInt16Converter<short>
    {
        public ushort GetUInt16(short value)
        {
            return (ushort)value;
        }
    }
    internal class UInt16UInt16Converter : IUInt16Converter<ushort>
    {
        public ushort GetUInt16(ushort value)
        {
            return (ushort)value;
        }
    }
    internal interface IInt32Converter<T>
    {
        int GetInt32(T value);
    }
    internal static class Int32Converter<T>
    {
        public static IInt32Converter<T> Instance { get; } = Int32Converter.GetInt32Converter<T>();
    }
    internal static class Int32Converter
    {
        public static IInt32Converter<T> GetInt32Converter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IInt32Converter<T>)new ByteInt32Converter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IInt32Converter<T>)new SByteInt32Converter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IInt32Converter<T>)new Int16Int32Converter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IInt32Converter<T>)new UInt16Int32Converter();
            }
            if (typeof(T) == typeof(int))
            {
                return (IInt32Converter<T>)new Int32Int32Converter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (IInt32Converter<T>)new UInt32Int32Converter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteInt32Converter : IInt32Converter<byte>
    {
        public int GetInt32(byte value)
        {
            return (int)value;
        }
    }
    internal class SByteInt32Converter : IInt32Converter<sbyte>
    {
        public int GetInt32(sbyte value)
        {
            return (int)value;
        }
    }
    internal class Int16Int32Converter : IInt32Converter<short>
    {
        public int GetInt32(short value)
        {
            return (int)value;
        }
    }
    internal class UInt16Int32Converter : IInt32Converter<ushort>
    {
        public int GetInt32(ushort value)
        {
            return (int)value;
        }
    }
    internal class Int32Int32Converter : IInt32Converter<int>
    {
        public int GetInt32(int value)
        {
            return (int)value;
        }
    }
    internal class UInt32Int32Converter : IInt32Converter<uint>
    {
        public int GetInt32(uint value)
        {
            return (int)value;
        }
    }
    internal interface IUInt32Converter<T>
    {
        uint GetUInt32(T value);
    }
    internal static class UInt32Converter<T>
    {
        public static IUInt32Converter<T> Instance { get; } = UInt32Converter.GetUInt32Converter<T>();
    }
    internal static class UInt32Converter
    {
        public static IUInt32Converter<T> GetUInt32Converter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IUInt32Converter<T>)new ByteUInt32Converter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IUInt32Converter<T>)new SByteUInt32Converter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IUInt32Converter<T>)new Int16UInt32Converter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IUInt32Converter<T>)new UInt16UInt32Converter();
            }
            if (typeof(T) == typeof(int))
            {
                return (IUInt32Converter<T>)new Int32UInt32Converter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (IUInt32Converter<T>)new UInt32UInt32Converter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteUInt32Converter : IUInt32Converter<byte>
    {
        public uint GetUInt32(byte value)
        {
            return (uint)value;
        }
    }
    internal class SByteUInt32Converter : IUInt32Converter<sbyte>
    {
        public uint GetUInt32(sbyte value)
        {
            return (uint)value;
        }
    }
    internal class Int16UInt32Converter : IUInt32Converter<short>
    {
        public uint GetUInt32(short value)
        {
            return (uint)value;
        }
    }
    internal class UInt16UInt32Converter : IUInt32Converter<ushort>
    {
        public uint GetUInt32(ushort value)
        {
            return (uint)value;
        }
    }
    internal class Int32UInt32Converter : IUInt32Converter<int>
    {
        public uint GetUInt32(int value)
        {
            return (uint)value;
        }
    }
    internal class UInt32UInt32Converter : IUInt32Converter<uint>
    {
        public uint GetUInt32(uint value)
        {
            return (uint)value;
        }
    }
    internal interface IInt64Converter<T>
    {
        long GetInt64(T value);
    }
    internal static class Int64Converter<T>
    {
        public static IInt64Converter<T> Instance { get; } = Int64Converter.GetInt64Converter<T>();
    }
    internal static class Int64Converter
    {
        public static IInt64Converter<T> GetInt64Converter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IInt64Converter<T>)new ByteInt64Converter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IInt64Converter<T>)new SByteInt64Converter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IInt64Converter<T>)new Int16Int64Converter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IInt64Converter<T>)new UInt16Int64Converter();
            }
            if (typeof(T) == typeof(int))
            {
                return (IInt64Converter<T>)new Int32Int64Converter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (IInt64Converter<T>)new UInt32Int64Converter();
            }
            if (typeof(T) == typeof(long))
            {
                return (IInt64Converter<T>)new Int64Int64Converter();
            }
            if (typeof(T) == typeof(ulong))
            {
                return (IInt64Converter<T>)new UInt64Int64Converter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteInt64Converter : IInt64Converter<byte>
    {
        public long GetInt64(byte value)
        {
            return (long)value;
        }
    }
    internal class SByteInt64Converter : IInt64Converter<sbyte>
    {
        public long GetInt64(sbyte value)
        {
            return (long)value;
        }
    }
    internal class Int16Int64Converter : IInt64Converter<short>
    {
        public long GetInt64(short value)
        {
            return (long)value;
        }
    }
    internal class UInt16Int64Converter : IInt64Converter<ushort>
    {
        public long GetInt64(ushort value)
        {
            return (long)value;
        }
    }
    internal class Int32Int64Converter : IInt64Converter<int>
    {
        public long GetInt64(int value)
        {
            return (long)value;
        }
    }
    internal class UInt32Int64Converter : IInt64Converter<uint>
    {
        public long GetInt64(uint value)
        {
            return (long)value;
        }
    }
    internal class Int64Int64Converter : IInt64Converter<long>
    {
        public long GetInt64(long value)
        {
            return (long)value;
        }
    }
    internal class UInt64Int64Converter : IInt64Converter<ulong>
    {
        public long GetInt64(ulong value)
        {
            return (long)value;
        }
    }
    internal interface IUInt64Converter<T>
    {
        ulong GetUInt64(T value);
    }
    internal static class UInt64Converter<T>
    {
        public static IUInt64Converter<T> Instance { get; } = UInt64Converter.GetUInt64Converter<T>();
    }
    internal static class UInt64Converter
    {
        public static IUInt64Converter<T> GetUInt64Converter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IUInt64Converter<T>)new ByteUInt64Converter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IUInt64Converter<T>)new SByteUInt64Converter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IUInt64Converter<T>)new Int16UInt64Converter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IUInt64Converter<T>)new UInt16UInt64Converter();
            }
            if (typeof(T) == typeof(int))
            {
                return (IUInt64Converter<T>)new Int32UInt64Converter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (IUInt64Converter<T>)new UInt32UInt64Converter();
            }
            if (typeof(T) == typeof(long))
            {
                return (IUInt64Converter<T>)new Int64UInt64Converter();
            }
            if (typeof(T) == typeof(ulong))
            {
                return (IUInt64Converter<T>)new UInt64UInt64Converter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteUInt64Converter : IUInt64Converter<byte>
    {
        public ulong GetUInt64(byte value)
        {
            return (ulong)value;
        }
    }
    internal class SByteUInt64Converter : IUInt64Converter<sbyte>
    {
        public ulong GetUInt64(sbyte value)
        {
            return (ulong)value;
        }
    }
    internal class Int16UInt64Converter : IUInt64Converter<short>
    {
        public ulong GetUInt64(short value)
        {
            return (ulong)value;
        }
    }
    internal class UInt16UInt64Converter : IUInt64Converter<ushort>
    {
        public ulong GetUInt64(ushort value)
        {
            return (ulong)value;
        }
    }
    internal class Int32UInt64Converter : IUInt64Converter<int>
    {
        public ulong GetUInt64(int value)
        {
            return (ulong)value;
        }
    }
    internal class UInt32UInt64Converter : IUInt64Converter<uint>
    {
        public ulong GetUInt64(uint value)
        {
            return (ulong)value;
        }
    }
    internal class Int64UInt64Converter : IUInt64Converter<long>
    {
        public ulong GetUInt64(long value)
        {
            return (ulong)value;
        }
    }
    internal class UInt64UInt64Converter : IUInt64Converter<ulong>
    {
        public ulong GetUInt64(ulong value)
        {
            return (ulong)value;
        }
    }
    internal interface ISingleConverter<T>
    {
        float GetSingle(T value);
    }
    internal static class SingleConverter<T>
    {
        public static ISingleConverter<T> Instance { get; } = SingleConverter.GetSingleConverter<T>();
    }
    internal static class SingleConverter
    {
        public static ISingleConverter<T> GetSingleConverter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (ISingleConverter<T>)new ByteSingleConverter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (ISingleConverter<T>)new SByteSingleConverter();
            }
            if (typeof(T) == typeof(short))
            {
                return (ISingleConverter<T>)new Int16SingleConverter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (ISingleConverter<T>)new UInt16SingleConverter();
            }
            if (typeof(T) == typeof(int))
            {
                return (ISingleConverter<T>)new Int32SingleConverter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (ISingleConverter<T>)new UInt32SingleConverter();
            }
            if (typeof(T) == typeof(long))
            {
                return (ISingleConverter<T>)new Int64SingleConverter();
            }
            if (typeof(T) == typeof(ulong))
            {
                return (ISingleConverter<T>)new UInt64SingleConverter();
            }
            if (typeof(T) == typeof(float))
            {
                return (ISingleConverter<T>)new SingleSingleConverter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteSingleConverter : ISingleConverter<byte>
    {
        public float GetSingle(byte value)
        {
            return (float)value;
        }
    }
    internal class SByteSingleConverter : ISingleConverter<sbyte>
    {
        public float GetSingle(sbyte value)
        {
            return (float)value;
        }
    }
    internal class Int16SingleConverter : ISingleConverter<short>
    {
        public float GetSingle(short value)
        {
            return (float)value;
        }
    }
    internal class UInt16SingleConverter : ISingleConverter<ushort>
    {
        public float GetSingle(ushort value)
        {
            return (float)value;
        }
    }
    internal class Int32SingleConverter : ISingleConverter<int>
    {
        public float GetSingle(int value)
        {
            return (float)value;
        }
    }
    internal class UInt32SingleConverter : ISingleConverter<uint>
    {
        public float GetSingle(uint value)
        {
            return (float)value;
        }
    }
    internal class Int64SingleConverter : ISingleConverter<long>
    {
        public float GetSingle(long value)
        {
            return (float)value;
        }
    }
    internal class UInt64SingleConverter : ISingleConverter<ulong>
    {
        public float GetSingle(ulong value)
        {
            return (float)value;
        }
    }
    internal class SingleSingleConverter : ISingleConverter<float>
    {
        public float GetSingle(float value)
        {
            return (float)value;
        }
    }
    internal interface IDoubleConverter<T>
    {
        double GetDouble(T value);
    }
    internal static class DoubleConverter<T>
    {
        public static IDoubleConverter<T> Instance { get; } = DoubleConverter.GetDoubleConverter<T>();
    }
    internal static class DoubleConverter
    {
        public static IDoubleConverter<T> GetDoubleConverter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IDoubleConverter<T>)new ByteDoubleConverter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IDoubleConverter<T>)new SByteDoubleConverter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IDoubleConverter<T>)new Int16DoubleConverter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IDoubleConverter<T>)new UInt16DoubleConverter();
            }
            if (typeof(T) == typeof(int))
            {
                return (IDoubleConverter<T>)new Int32DoubleConverter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (IDoubleConverter<T>)new UInt32DoubleConverter();
            }
            if (typeof(T) == typeof(long))
            {
                return (IDoubleConverter<T>)new Int64DoubleConverter();
            }
            if (typeof(T) == typeof(ulong))
            {
                return (IDoubleConverter<T>)new UInt64DoubleConverter();
            }
            if (typeof(T) == typeof(float))
            {
                return (IDoubleConverter<T>)new SingleDoubleConverter();
            }
            if (typeof(T) == typeof(double))
            {
                return (IDoubleConverter<T>)new DoubleDoubleConverter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteDoubleConverter : IDoubleConverter<byte>
    {
        public double GetDouble(byte value)
        {
            return (double)value;
        }
    }
    internal class SByteDoubleConverter : IDoubleConverter<sbyte>
    {
        public double GetDouble(sbyte value)
        {
            return (double)value;
        }
    }
    internal class Int16DoubleConverter : IDoubleConverter<short>
    {
        public double GetDouble(short value)
        {
            return (double)value;
        }
    }
    internal class UInt16DoubleConverter : IDoubleConverter<ushort>
    {
        public double GetDouble(ushort value)
        {
            return (double)value;
        }
    }
    internal class Int32DoubleConverter : IDoubleConverter<int>
    {
        public double GetDouble(int value)
        {
            return (double)value;
        }
    }
    internal class UInt32DoubleConverter : IDoubleConverter<uint>
    {
        public double GetDouble(uint value)
        {
            return (double)value;
        }
    }
    internal class Int64DoubleConverter : IDoubleConverter<long>
    {
        public double GetDouble(long value)
        {
            return (double)value;
        }
    }
    internal class UInt64DoubleConverter : IDoubleConverter<ulong>
    {
        public double GetDouble(ulong value)
        {
            return (double)value;
        }
    }
    internal class SingleDoubleConverter : IDoubleConverter<float>
    {
        public double GetDouble(float value)
        {
            return (double)value;
        }
    }
    internal class DoubleDoubleConverter : IDoubleConverter<double>
    {
        public double GetDouble(double value)
        {
            return (double)value;
        }
    }
    internal interface IDecimalConverter<T>
    {
        decimal GetDecimal(T value);
    }
    internal static class DecimalConverter<T>
    {
        public static IDecimalConverter<T> Instance { get; } = DecimalConverter.GetDecimalConverter<T>();
    }
    internal static class DecimalConverter
    {
        public static IDecimalConverter<T> GetDecimalConverter<T>()
        {
            if (typeof(T) == typeof(byte))
            {
                return (IDecimalConverter<T>)new ByteDecimalConverter();
            }
            if (typeof(T) == typeof(sbyte))
            {
                return (IDecimalConverter<T>)new SByteDecimalConverter();
            }
            if (typeof(T) == typeof(short))
            {
                return (IDecimalConverter<T>)new Int16DecimalConverter();
            }
            if (typeof(T) == typeof(ushort))
            {
                return (IDecimalConverter<T>)new UInt16DecimalConverter();
            }
            if (typeof(T) == typeof(int))
            {
                return (IDecimalConverter<T>)new Int32DecimalConverter();
            }
            if (typeof(T) == typeof(uint))
            {
                return (IDecimalConverter<T>)new UInt32DecimalConverter();
            }
            if (typeof(T) == typeof(long))
            {
                return (IDecimalConverter<T>)new Int64DecimalConverter();
            }
            if (typeof(T) == typeof(ulong))
            {
                return (IDecimalConverter<T>)new UInt64DecimalConverter();
            }
            if (typeof(T) == typeof(float))
            {
                return (IDecimalConverter<T>)new SingleDecimalConverter();
            }
            if (typeof(T) == typeof(double))
            {
                return (IDecimalConverter<T>)new DoubleDecimalConverter();
            }
            if (typeof(T) == typeof(decimal))
            {
                return (IDecimalConverter<T>)new DecimalDecimalConverter();
            }
            throw new NotSupportedException();
        }
    }
    internal class ByteDecimalConverter : IDecimalConverter<byte>
    {
        public decimal GetDecimal(byte value)
        {
            return (decimal)value;
        }
    }
    internal class SByteDecimalConverter : IDecimalConverter<sbyte>
    {
        public decimal GetDecimal(sbyte value)
        {
            return (decimal)value;
        }
    }
    internal class Int16DecimalConverter : IDecimalConverter<short>
    {
        public decimal GetDecimal(short value)
        {
            return (decimal)value;
        }
    }
    internal class UInt16DecimalConverter : IDecimalConverter<ushort>
    {
        public decimal GetDecimal(ushort value)
        {
            return (decimal)value;
        }
    }
    internal class Int32DecimalConverter : IDecimalConverter<int>
    {
        public decimal GetDecimal(int value)
        {
            return (decimal)value;
        }
    }
    internal class UInt32DecimalConverter : IDecimalConverter<uint>
    {
        public decimal GetDecimal(uint value)
        {
            return (decimal)value;
        }
    }
    internal class Int64DecimalConverter : IDecimalConverter<long>
    {
        public decimal GetDecimal(long value)
        {
            return (decimal)value;
        }
    }
    internal class UInt64DecimalConverter : IDecimalConverter<ulong>
    {
        public decimal GetDecimal(ulong value)
        {
            return (decimal)value;
        }
    }
    internal class SingleDecimalConverter : IDecimalConverter<float>
    {
        public decimal GetDecimal(float value)
        {
            return (decimal)value;
        }
    }
    internal class DoubleDecimalConverter : IDecimalConverter<double>
    {
        public decimal GetDecimal(double value)
        {
            return (decimal)value;
        }
    }
    internal class DecimalDecimalConverter : IDecimalConverter<decimal>
    {
        public decimal GetDecimal(decimal value)
        {
            return (decimal)value;
        }
    }
}