// Attention : ce fichier a été automatiquement généré par un
// template T4. Toute modification manuelle sera écrasée !!!
using System;
using System.Collections.Generic;
using System.Globalization;

namespace Developpez.Dotnet
{
    public static partial class Numbers
    {

        private static readonly Dictionary<Type, Delegate> _parsers;
        private static readonly Dictionary<Type, Delegate> _parsersWithStyleAndProvider;

        static Numbers()
        {
            _parsers = new Dictionary<Type, Delegate>
            {
                { typeof(byte), new Func<string, byte?>(TryParseByte) },
                { typeof(sbyte), new Func<string, sbyte?>(TryParseSByte) },
                { typeof(short), new Func<string, short?>(TryParseInt16) },
                { typeof(ushort), new Func<string, ushort?>(TryParseUInt16) },
                { typeof(int), new Func<string, int?>(TryParseInt32) },
                { typeof(uint), new Func<string, uint?>(TryParseUInt32) },
                { typeof(long), new Func<string, long?>(TryParseInt64) },
                { typeof(ulong), new Func<string, ulong?>(TryParseUInt64) },
                { typeof(float), new Func<string, float?>(TryParseSingle) },
                { typeof(double), new Func<string, double?>(TryParseDouble) },
                { typeof(decimal), new Func<string, decimal?>(TryParseDecimal) },
            };
            _parsersWithStyleAndProvider = new Dictionary<Type, Delegate>
            {
                { typeof(byte), new Func<string, NumberStyles, IFormatProvider, byte?>(TryParseByte) },
                { typeof(sbyte), new Func<string, NumberStyles, IFormatProvider, sbyte?>(TryParseSByte) },
                { typeof(short), new Func<string, NumberStyles, IFormatProvider, short?>(TryParseInt16) },
                { typeof(ushort), new Func<string, NumberStyles, IFormatProvider, ushort?>(TryParseUInt16) },
                { typeof(int), new Func<string, NumberStyles, IFormatProvider, int?>(TryParseInt32) },
                { typeof(uint), new Func<string, NumberStyles, IFormatProvider, uint?>(TryParseUInt32) },
                { typeof(long), new Func<string, NumberStyles, IFormatProvider, long?>(TryParseInt64) },
                { typeof(ulong), new Func<string, NumberStyles, IFormatProvider, ulong?>(TryParseUInt64) },
                { typeof(float), new Func<string, NumberStyles, IFormatProvider, float?>(TryParseSingle) },
                { typeof(double), new Func<string, NumberStyles, IFormatProvider, double?>(TryParseDouble) },
                { typeof(decimal), new Func<string, NumberStyles, IFormatProvider, decimal?>(TryParseDecimal) },
            };
        }


        /// <summary>
        /// Tente de convertir une chaine de caractères en Byte.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Byte si la conversion réussit; sinon, null.</returns>
        public static byte? TryParseByte(string s)
        {
            byte value;
            if (byte.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Byte.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Byte si la conversion réussit; sinon, null.</returns>
        public static byte? TryParseByte(string s, NumberStyles style, IFormatProvider provider)
        {
            byte value;
            if (byte.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en SByte.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur SByte si la conversion réussit; sinon, null.</returns>
        public static sbyte? TryParseSByte(string s)
        {
            sbyte value;
            if (sbyte.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en SByte.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur SByte si la conversion réussit; sinon, null.</returns>
        public static sbyte? TryParseSByte(string s, NumberStyles style, IFormatProvider provider)
        {
            sbyte value;
            if (sbyte.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Int16.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Int16 si la conversion réussit; sinon, null.</returns>
        public static short? TryParseInt16(string s)
        {
            short value;
            if (short.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Int16.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Int16 si la conversion réussit; sinon, null.</returns>
        public static short? TryParseInt16(string s, NumberStyles style, IFormatProvider provider)
        {
            short value;
            if (short.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en UInt16.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur UInt16 si la conversion réussit; sinon, null.</returns>
        public static ushort? TryParseUInt16(string s)
        {
            ushort value;
            if (ushort.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en UInt16.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur UInt16 si la conversion réussit; sinon, null.</returns>
        public static ushort? TryParseUInt16(string s, NumberStyles style, IFormatProvider provider)
        {
            ushort value;
            if (ushort.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Int32.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Int32 si la conversion réussit; sinon, null.</returns>
        public static int? TryParseInt32(string s)
        {
            int value;
            if (int.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Int32.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Int32 si la conversion réussit; sinon, null.</returns>
        public static int? TryParseInt32(string s, NumberStyles style, IFormatProvider provider)
        {
            int value;
            if (int.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en UInt32.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur UInt32 si la conversion réussit; sinon, null.</returns>
        public static uint? TryParseUInt32(string s)
        {
            uint value;
            if (uint.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en UInt32.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur UInt32 si la conversion réussit; sinon, null.</returns>
        public static uint? TryParseUInt32(string s, NumberStyles style, IFormatProvider provider)
        {
            uint value;
            if (uint.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Int64.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Int64 si la conversion réussit; sinon, null.</returns>
        public static long? TryParseInt64(string s)
        {
            long value;
            if (long.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Int64.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Int64 si la conversion réussit; sinon, null.</returns>
        public static long? TryParseInt64(string s, NumberStyles style, IFormatProvider provider)
        {
            long value;
            if (long.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en UInt64.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur UInt64 si la conversion réussit; sinon, null.</returns>
        public static ulong? TryParseUInt64(string s)
        {
            ulong value;
            if (ulong.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en UInt64.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Integer</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur UInt64 si la conversion réussit; sinon, null.</returns>
        public static ulong? TryParseUInt64(string s, NumberStyles style, IFormatProvider provider)
        {
            ulong value;
            if (ulong.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Single.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Single si la conversion réussit; sinon, null.</returns>
        public static float? TryParseSingle(string s)
        {
            float value;
            if (float.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Single.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Float</c> combiné à <c>NumberStyles.AllowThousands</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Single si la conversion réussit; sinon, null.</returns>
        public static float? TryParseSingle(string s, NumberStyles style, IFormatProvider provider)
        {
            float value;
            if (float.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Double.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Double si la conversion réussit; sinon, null.</returns>
        public static double? TryParseDouble(string s)
        {
            double value;
            if (double.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Double.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Float</c> combiné à <c>NumberStyles.AllowThousands</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Double si la conversion réussit; sinon, null.</returns>
        public static double? TryParseDouble(string s, NumberStyles style, IFormatProvider provider)
        {
            double value;
            if (double.TryParse(s, style, provider, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Decimal.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <returns>La valeur Decimal si la conversion réussit; sinon, null.</returns>
        public static decimal? TryParseDecimal(string s)
        {
            decimal value;
            if (decimal.TryParse(s, out value))
                return value;
            return null;
        }

        /// <summary>
        /// Tente de convertir une chaine de caractères en Decimal.
        /// </summary>
        /// <param name="s">Chaine à convertir</param>
        /// <param name="style">Une combinaison de valeurs NumberStyles indiquant le format autorisé de <c>s</c>. Une valeur typique à spécifier est <c>NumberStyles.Number</c>.</param>
        /// <param name="provider"><see cref="IFormatProvider" /> qui fournit des informations de format propres à la culture concernant <c>s</c>.</param>
        /// <returns>La valeur Decimal si la conversion réussit; sinon, null.</returns>
        public static decimal? TryParseDecimal(string s, NumberStyles style, IFormatProvider provider)
        {
            decimal value;
            if (decimal.TryParse(s, style, provider, out value))
                return value;
            return null;
        }
    }
}