// 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 masse
    /// </summary>
    public interface IMass
    {
        /// <summary>
        /// Obtient la valeur de cette masse en kilogrammes
        /// </summary>
        double ValueInKilograms { get; }
    }

    /// <summary>
    /// Représente une masse en kilogrammes
    /// </summary>
    public struct Kilogram : IMass, IComparable<Kilogram>, IEquatable<Kilogram>, IFormattable
    {
        private readonly double _value;

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

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

        #region Operators

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

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

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

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

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

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

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

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

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

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

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

        /// <summary>
        /// Divise une masse par un nombre.
        /// </summary>
        /// <param name="mass">Masse</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Kilogram operator /(Kilogram mass, double divisor)
        {
            return new Kilogram(mass.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(Kilogram 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} kg", value);
        }

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

            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))
                {
                    mass = new Kilogram(value);
                    return true;
                }
            }

            mass = new Kilogram(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(Kilogram 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 Kilogram)
                return Equals((Kilogram) 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 IMass

        /// <summary>
        /// Obtient la valeur de cette masse en kilogrammes
        /// </summary>
        double IMass.ValueInKilograms
        {
            get { return _value; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une masse en livres
    /// </summary>
    public struct Pound : IMass, IComparable<Pound>, IEquatable<Pound>, IFormattable
    {
        private readonly double _value;

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

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

        #region Operators

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

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

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

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

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

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

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

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

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

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

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

        /// <summary>
        /// Divise une masse par un nombre.
        /// </summary>
        /// <param name="mass">Masse</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Pound operator /(Pound mass, double divisor)
        {
            return new Pound(mass.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(Pound 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} lb", value);
        }

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

            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))
                {
                    mass = new Pound(value);
                    return true;
                }
            }

            mass = new Pound(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(Pound 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 Pound)
                return Equals((Pound) 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 IMass

        /// <summary>
        /// Obtient la valeur de cette masse en kilogrammes
        /// </summary>
        double IMass.ValueInKilograms
        {
            get { return _value * .45359237; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une masse en onces
    /// </summary>
    public struct Ounce : IMass, IComparable<Ounce>, IEquatable<Ounce>, IFormattable
    {
        private readonly double _value;

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

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

        #region Operators

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

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

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

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

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

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

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

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

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

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

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

        /// <summary>
        /// Divise une masse par un nombre.
        /// </summary>
        /// <param name="mass">Masse</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Ounce operator /(Ounce mass, double divisor)
        {
            return new Ounce(mass.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(Ounce 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} oz", value);
        }

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

            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))
                {
                    mass = new Ounce(value);
                    return true;
                }
            }

            mass = new Ounce(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(Ounce 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 Ounce)
                return Equals((Ounce) 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 IMass

        /// <summary>
        /// Obtient la valeur de cette masse en kilogrammes
        /// </summary>
        double IMass.ValueInKilograms
        {
            get { return _value * .0283495231; }
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes d'extension pour les masses
    /// </summary>
    public static class MassExtensions
    {
        /// <summary>
        /// Convertit une masse en kilogrammes
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="mass">Masse à convertir</param>
        /// <returns>Valeur en kilogrammes</returns>
        public static Kilogram ToKilogram<T>(this T mass)
            where T : IMass
        {
            return mass.ValueInKilograms;
        }

        /// <summary>
        /// Convertit une masse en livres
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="mass">Masse à convertir</param>
        /// <returns>Valeur en livres</returns>
        public static Pound ToPound<T>(this T mass)
            where T : IMass
        {
            return mass.ValueInKilograms / .45359237;
        }

        /// <summary>
        /// Convertit une masse en onces
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="mass">Masse à convertir</param>
        /// <returns>Valeur en onces</returns>
        public static Ounce ToOunce<T>(this T mass)
            where T : IMass
        {
            return mass.ValueInKilograms / .0283495231;
        }

    }
}