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

using System;
using System.Text.RegularExpressions;

namespace Developpez.Dotnet.Measures
{
    /// <summary>
    /// Représente une mesure de longueur
    /// </summary>
    public interface ILength
    {
        /// <summary>
        /// Obtient la valeur de cette longueur en mètres
        /// </summary>
        double ValueInMeters { get; }
    }

    /// <summary>
    /// Représente une longueur en mètres
    /// </summary>
    public struct Meter : ILength, IComparable<Meter>, IEquatable<Meter>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Meter"/>.
        /// </summary>
        /// <param name="value">La valeur de cette longueur en mètres.</param>
        public Meter(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de cette longueur.
        /// </summary>
        /// <value>
        /// La valeur de cette longueur en mètres
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Meter"/>.
        /// </summary>
        /// <param name="value">Valeur en mètres.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Meter(double value)
        {
            return new Meter(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Meter"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Meter length)
        {
            return length.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Meter a, Meter b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Meter a, Meter b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première longueur est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Meter a, Meter b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Meter a, Meter b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première longueur est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Meter a, Meter b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Meter a, Meter b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La somme des deux longueurs.
        /// </returns>
        public static Meter operator +(Meter a, Meter b)
        {
            return new Meter(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième longueur de la première
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La différence entre les deux longueurs.
        /// </returns>
        public static Meter operator -(Meter a, Meter b)
        {
            return new Meter(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Meter operator *(Meter length, double multiplier)
        {
            return new Meter(length.Value*multiplier);
        }

        /// <summary>
        /// Divise une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Meter operator /(Meter length, double divisor)
        {
            return new Meter(length.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Meter other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} m", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="length">Longueur.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Meter length)
        {
            var regex = new Regex(@"(?<value>.*) ?m");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    length = new Meter(value);
                    return true;
                }
            }

            length = new Meter(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Meter other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Meter)
                return Equals((Meter) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of ILength

        /// <summary>
        /// Obtient la valeur de cette longueur en mètres
        /// </summary>
        double ILength.ValueInMeters
        {
            get { return _value; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une longueur en pieds
    /// </summary>
    public struct Foot : ILength, IComparable<Foot>, IEquatable<Foot>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Foot"/>.
        /// </summary>
        /// <param name="value">La valeur de cette longueur en pieds.</param>
        public Foot(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de cette longueur.
        /// </summary>
        /// <value>
        /// La valeur de cette longueur en pieds
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Foot"/>.
        /// </summary>
        /// <param name="value">Valeur en pieds.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Foot(double value)
        {
            return new Foot(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Foot"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Foot length)
        {
            return length.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Foot a, Foot b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Foot a, Foot b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première longueur est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Foot a, Foot b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Foot a, Foot b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première longueur est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Foot a, Foot b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Foot a, Foot b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La somme des deux longueurs.
        /// </returns>
        public static Foot operator +(Foot a, Foot b)
        {
            return new Foot(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième longueur de la première
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La différence entre les deux longueurs.
        /// </returns>
        public static Foot operator -(Foot a, Foot b)
        {
            return new Foot(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Foot operator *(Foot length, double multiplier)
        {
            return new Foot(length.Value*multiplier);
        }

        /// <summary>
        /// Divise une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Foot operator /(Foot length, double divisor)
        {
            return new Foot(length.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Foot other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} ft", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="length">Longueur.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Foot length)
        {
            var regex = new Regex(@"(?<value>.*) ?ft");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    length = new Foot(value);
                    return true;
                }
            }

            length = new Foot(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Foot other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Foot)
                return Equals((Foot) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of ILength

        /// <summary>
        /// Obtient la valeur de cette longueur en mètres
        /// </summary>
        double ILength.ValueInMeters
        {
            get { return _value * .3048; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une longueur en pouces
    /// </summary>
    public struct Inch : ILength, IComparable<Inch>, IEquatable<Inch>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Inch"/>.
        /// </summary>
        /// <param name="value">La valeur de cette longueur en pouces.</param>
        public Inch(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de cette longueur.
        /// </summary>
        /// <value>
        /// La valeur de cette longueur en pouces
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Inch"/>.
        /// </summary>
        /// <param name="value">Valeur en pouces.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Inch(double value)
        {
            return new Inch(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Inch"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Inch length)
        {
            return length.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Inch a, Inch b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Inch a, Inch b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première longueur est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Inch a, Inch b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Inch a, Inch b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première longueur est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Inch a, Inch b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Inch a, Inch b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La somme des deux longueurs.
        /// </returns>
        public static Inch operator +(Inch a, Inch b)
        {
            return new Inch(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième longueur de la première
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La différence entre les deux longueurs.
        /// </returns>
        public static Inch operator -(Inch a, Inch b)
        {
            return new Inch(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Inch operator *(Inch length, double multiplier)
        {
            return new Inch(length.Value*multiplier);
        }

        /// <summary>
        /// Divise une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Inch operator /(Inch length, double divisor)
        {
            return new Inch(length.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Inch other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} in", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="length">Longueur.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Inch length)
        {
            var regex = new Regex(@"(?<value>.*) ?in");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    length = new Inch(value);
                    return true;
                }
            }

            length = new Inch(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Inch other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Inch)
                return Equals((Inch) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of ILength

        /// <summary>
        /// Obtient la valeur de cette longueur en mètres
        /// </summary>
        double ILength.ValueInMeters
        {
            get { return _value * .0254; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une longueur en miles
    /// </summary>
    public struct Mile : ILength, IComparable<Mile>, IEquatable<Mile>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Mile"/>.
        /// </summary>
        /// <param name="value">La valeur de cette longueur en miles.</param>
        public Mile(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de cette longueur.
        /// </summary>
        /// <value>
        /// La valeur de cette longueur en miles
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Mile"/>.
        /// </summary>
        /// <param name="value">Valeur en miles.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Mile(double value)
        {
            return new Mile(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Mile"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Mile length)
        {
            return length.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Mile a, Mile b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Mile a, Mile b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première longueur est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Mile a, Mile b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Mile a, Mile b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première longueur est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Mile a, Mile b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Mile a, Mile b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La somme des deux longueurs.
        /// </returns>
        public static Mile operator +(Mile a, Mile b)
        {
            return new Mile(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième longueur de la première
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La différence entre les deux longueurs.
        /// </returns>
        public static Mile operator -(Mile a, Mile b)
        {
            return new Mile(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Mile operator *(Mile length, double multiplier)
        {
            return new Mile(length.Value*multiplier);
        }

        /// <summary>
        /// Divise une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Mile operator /(Mile length, double divisor)
        {
            return new Mile(length.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Mile other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} mi", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="length">Longueur.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Mile length)
        {
            var regex = new Regex(@"(?<value>.*) ?mi");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    length = new Mile(value);
                    return true;
                }
            }

            length = new Mile(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Mile other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Mile)
                return Equals((Mile) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of ILength

        /// <summary>
        /// Obtient la valeur de cette longueur en mètres
        /// </summary>
        double ILength.ValueInMeters
        {
            get { return _value * 1609.344; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une longueur en milles marins
    /// </summary>
    public struct NauticalMile : ILength, IComparable<NauticalMile>, IEquatable<NauticalMile>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="NauticalMile"/>.
        /// </summary>
        /// <param name="value">La valeur de cette longueur en milles marins.</param>
        public NauticalMile(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de cette longueur.
        /// </summary>
        /// <value>
        /// La valeur de cette longueur en milles marins
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.NauticalMile"/>.
        /// </summary>
        /// <param name="value">Valeur en milles marins.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator NauticalMile(double value)
        {
            return new NauticalMile(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.NauticalMile"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(NauticalMile length)
        {
            return length.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont égales, false sinon.
        /// </returns>
        public static bool operator ==(NauticalMile a, NauticalMile b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si les deux longueurs sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(NauticalMile a, NauticalMile b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première longueur est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(NauticalMile a, NauticalMile b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(NauticalMile a, NauticalMile b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première longueur est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(NauticalMile a, NauticalMile b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première longueur est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// true si la première longueur est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(NauticalMile a, NauticalMile b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux longueurs.
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La somme des deux longueurs.
        /// </returns>
        public static NauticalMile operator +(NauticalMile a, NauticalMile b)
        {
            return new NauticalMile(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième longueur de la première
        /// </summary>
        /// <param name="a">Première longueur</param>
        /// <param name="b">Deuxième longueur</param>
        /// <returns>
        /// La différence entre les deux longueurs.
        /// </returns>
        public static NauticalMile operator -(NauticalMile a, NauticalMile b)
        {
            return new NauticalMile(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static NauticalMile operator *(NauticalMile length, double multiplier)
        {
            return new NauticalMile(length.Value*multiplier);
        }

        /// <summary>
        /// Divise une longueur par un nombre.
        /// </summary>
        /// <param name="length">Longueur</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static NauticalMile operator /(NauticalMile length, double divisor)
        {
            return new NauticalMile(length.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(NauticalMile other)
        {
            return Value.CompareTo(other.Value);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public override string ToString()
        {
            return ToString(null, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} NM", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="length">Longueur.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out NauticalMile length)
        {
            var regex = new Regex(@"(?<value>.*) ?NM");

            if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success)
            {
                string valueText = regex.Match(text).Groups["value"].Value;

                double value;
                if (double.TryParse(valueText, out value))
                {
                    length = new NauticalMile(value);
                    return true;
                }
            }

            length = new NauticalMile(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(NauticalMile other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is NauticalMile)
                return Equals((NauticalMile) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of ILength

        /// <summary>
        /// Obtient la valeur de cette longueur en mètres
        /// </summary>
        double ILength.ValueInMeters
        {
            get { return _value * 1852; }
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes d'extension pour les longueurs
    /// </summary>
    public static class LengthExtensions
    {
        /// <summary>
        /// Convertit une longueur en mètres
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="length">Longueur à convertir</param>
        /// <returns>Valeur en mètres</returns>
        public static Meter ToMeter<T>(this T length)
            where T : ILength
        {
            return length.ValueInMeters;
        }

        /// <summary>
        /// Convertit une longueur en pieds
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="length">Longueur à convertir</param>
        /// <returns>Valeur en pieds</returns>
        public static Foot ToFoot<T>(this T length)
            where T : ILength
        {
            return length.ValueInMeters / .3048;
        }

        /// <summary>
        /// Convertit une longueur en pouces
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="length">Longueur à convertir</param>
        /// <returns>Valeur en pouces</returns>
        public static Inch ToInch<T>(this T length)
            where T : ILength
        {
            return length.ValueInMeters / .0254;
        }

        /// <summary>
        /// Convertit une longueur en miles
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="length">Longueur à convertir</param>
        /// <returns>Valeur en miles</returns>
        public static Mile ToMile<T>(this T length)
            where T : ILength
        {
            return length.ValueInMeters / 1609.344;
        }

        /// <summary>
        /// Convertit une longueur en milles marins
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="length">Longueur à convertir</param>
        /// <returns>Valeur en milles marins</returns>
        public static NauticalMile ToNauticalMile<T>(this T length)
            where T : ILength
        {
            return length.ValueInMeters / 1852;
        }

    }
}