// 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 IVolume
    {
        /// <summary>
        /// Obtient la valeur de ce volume en mètres cubes
        /// </summary>
        double ValueInCubeMeters { get; }
    }

    /// <summary>
    /// Représente un volume en mètres cubes
    /// </summary>
    public struct CubeMeter : IVolume, IComparable<CubeMeter>, IEquatable<CubeMeter>, IFormattable
    {
        private readonly double _value;

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

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

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(CubeMeter a, CubeMeter b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(CubeMeter a, CubeMeter b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(CubeMeter a, CubeMeter b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(CubeMeter a, CubeMeter b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(CubeMeter a, CubeMeter b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(CubeMeter a, CubeMeter b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static CubeMeter operator +(CubeMeter a, CubeMeter b)
        {
            return new CubeMeter(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static CubeMeter operator -(CubeMeter a, CubeMeter b)
        {
            return new CubeMeter(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static CubeMeter operator /(CubeMeter volume, double divisor)
        {
            return new CubeMeter(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(CubeMeter 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="volume">volume.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out CubeMeter volume)
        {
            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))
                {
                    volume = new CubeMeter(value);
                    return true;
                }
            }

            volume = new CubeMeter(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(CubeMeter 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 CubeMeter)
                return Equals((CubeMeter) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un volume en litres
    /// </summary>
    public struct Liter : IVolume, IComparable<Liter>, IEquatable<Liter>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Liter"/>.
        /// </summary>
        /// <param name="value">La valeur de ce volume en litres</param>
        public Liter(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de ce volume.
        /// </summary>
        /// <value>
        /// La valeur de ce volume en litres
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(Liter a, Liter b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(Liter a, Liter b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(Liter a, Liter b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(Liter a, Liter b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Liter a, Liter b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Liter a, Liter b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static Liter operator +(Liter a, Liter b)
        {
            return new Liter(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static Liter operator -(Liter a, Liter b)
        {
            return new Liter(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Liter operator /(Liter volume, double divisor)
        {
            return new Liter(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Liter 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} l", value);
        }

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

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

            volume = new Liter(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(Liter 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 Liter)
                return Equals((Liter) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value * .001; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un volume en pintes
    /// </summary>
    public struct Pint : IVolume, IComparable<Pint>, IEquatable<Pint>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Pint"/>.
        /// </summary>
        /// <param name="value">La valeur de ce volume en pintes</param>
        public Pint(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de ce volume.
        /// </summary>
        /// <value>
        /// La valeur de ce volume en pintes
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(Pint a, Pint b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(Pint a, Pint b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(Pint a, Pint b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(Pint a, Pint b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Pint a, Pint b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Pint a, Pint b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static Pint operator +(Pint a, Pint b)
        {
            return new Pint(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static Pint operator -(Pint a, Pint b)
        {
            return new Pint(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Pint operator /(Pint volume, double divisor)
        {
            return new Pint(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Pint 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} pt", value);
        }

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

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

            volume = new Pint(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(Pint 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 Pint)
                return Equals((Pint) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value * .00056826125; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un volume en gallons impériaux
    /// </summary>
    public struct Gallon : IVolume, IComparable<Gallon>, IEquatable<Gallon>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Gallon"/>.
        /// </summary>
        /// <param name="value">La valeur de ce volume en gallons impériaux</param>
        public Gallon(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de ce volume.
        /// </summary>
        /// <value>
        /// La valeur de ce volume en gallons impériaux
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(Gallon a, Gallon b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(Gallon a, Gallon b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(Gallon a, Gallon b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(Gallon a, Gallon b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Gallon a, Gallon b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Gallon a, Gallon b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static Gallon operator +(Gallon a, Gallon b)
        {
            return new Gallon(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static Gallon operator -(Gallon a, Gallon b)
        {
            return new Gallon(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Gallon operator /(Gallon volume, double divisor)
        {
            return new Gallon(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Gallon 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} gal GB", value);
        }

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

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

            volume = new Gallon(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(Gallon 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 Gallon)
                return Equals((Gallon) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value * .00454609; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un volume en gallons US
    /// </summary>
    public struct USGallon : IVolume, IComparable<USGallon>, IEquatable<USGallon>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="USGallon"/>.
        /// </summary>
        /// <param name="value">La valeur de ce volume en gallons US</param>
        public USGallon(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de ce volume.
        /// </summary>
        /// <value>
        /// La valeur de ce volume en gallons US
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(USGallon a, USGallon b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(USGallon a, USGallon b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(USGallon a, USGallon b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(USGallon a, USGallon b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(USGallon a, USGallon b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(USGallon a, USGallon b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static USGallon operator +(USGallon a, USGallon b)
        {
            return new USGallon(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static USGallon operator -(USGallon a, USGallon b)
        {
            return new USGallon(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static USGallon operator /(USGallon volume, double divisor)
        {
            return new USGallon(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(USGallon 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} gal US", value);
        }

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

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

            volume = new USGallon(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(USGallon 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 USGallon)
                return Equals((USGallon) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value * .003785411784; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un volume en onces liquides impériales
    /// </summary>
    public struct FluidOunce : IVolume, IComparable<FluidOunce>, IEquatable<FluidOunce>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="FluidOunce"/>.
        /// </summary>
        /// <param name="value">La valeur de ce volume en onces liquides impériales</param>
        public FluidOunce(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de ce volume.
        /// </summary>
        /// <value>
        /// La valeur de ce volume en onces liquides impériales
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(FluidOunce a, FluidOunce b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(FluidOunce a, FluidOunce b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(FluidOunce a, FluidOunce b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(FluidOunce a, FluidOunce b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(FluidOunce a, FluidOunce b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(FluidOunce a, FluidOunce b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static FluidOunce operator +(FluidOunce a, FluidOunce b)
        {
            return new FluidOunce(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static FluidOunce operator -(FluidOunce a, FluidOunce b)
        {
            return new FluidOunce(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static FluidOunce operator /(FluidOunce volume, double divisor)
        {
            return new FluidOunce(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(FluidOunce 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} fl oz", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="volume">volume.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out FluidOunce volume)
        {
            var regex = new Regex(@"(?<value>.*) ?fl 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))
                {
                    volume = new FluidOunce(value);
                    return true;
                }
            }

            volume = new FluidOunce(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(FluidOunce 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 FluidOunce)
                return Equals((FluidOunce) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value * .0000284130625; }
        }

        #endregion
    }

    /// <summary>
    /// Représente un volume en onces liquides US
    /// </summary>
    public struct USFluidOunce : IVolume, IComparable<USFluidOunce>, IEquatable<USFluidOunce>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="USFluidOunce"/>.
        /// </summary>
        /// <param name="value">La valeur de ce volume en onces liquides US</param>
        public USFluidOunce(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur de ce volume.
        /// </summary>
        /// <value>
        /// La valeur de ce volume en onces liquides US
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

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

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

        /// <summary>
        /// Teste l'égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont égaux, false sinon.
        /// </returns>
        public static bool operator ==(USFluidOunce a, USFluidOunce b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si les deux volumes sont différents, false sinon.
        /// </returns>
        public static bool operator !=(USFluidOunce a, USFluidOunce b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si le premier volume est inférieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur au deuxième, false sinon.
        /// </returns>
        public static bool operator <(USFluidOunce a, USFluidOunce b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur au deuxième, false sinon.
        /// </returns>
        public static bool operator >(USFluidOunce a, USFluidOunce b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si le premier volume est inférieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est inférieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator <=(USFluidOunce a, USFluidOunce b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si le premier volume est supérieur ou égal au deuxième.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// true si le premier volume est supérieur ou égal au deuxième, false sinon.
        /// </returns>
        public static bool operator >=(USFluidOunce a, USFluidOunce b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux volumes.
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La somme des deux volumes.
        /// </returns>
        public static USFluidOunce operator +(USFluidOunce a, USFluidOunce b)
        {
            return new USFluidOunce(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait le deuxième volume du premier
        /// </summary>
        /// <param name="a">Premier volume</param>
        /// <param name="b">Deuxième volume</param>
        /// <returns>
        /// La différence entre les deux volumes.
        /// </returns>
        public static USFluidOunce operator -(USFluidOunce a, USFluidOunce b)
        {
            return new USFluidOunce(a.Value - b.Value);
        }

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

        /// <summary>
        /// Divise un volume par un nombre.
        /// </summary>
        /// <param name="volume">volume</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static USFluidOunce operator /(USFluidOunce volume, double divisor)
        {
            return new USFluidOunce(volume.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érieur à 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érieur à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(USFluidOunce 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} fl oz", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="volume">volume.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out USFluidOunce volume)
        {
            var regex = new Regex(@"(?<value>.*) ?fl 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))
                {
                    volume = new USFluidOunce(value);
                    return true;
                }
            }

            volume = new USFluidOunce(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(USFluidOunce 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 USFluidOunce)
                return Equals((USFluidOunce) 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 IVolume

        /// <summary>
        /// Obtient la valeur de cette volume en mètres cubes
        /// </summary>
        double IVolume.ValueInCubeMeters
        {
            get { return _value * .0000295735295625; }
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes d'extension pour les volumes
    /// </summary>
    public static class VolumeExtensions
    {
        /// <summary>
        /// Convertit un volume en mètres cubes
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en mètres cubes</returns>
        public static CubeMeter ToCubeMeter<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters;
        }

        /// <summary>
        /// Convertit un volume en litres
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en litres</returns>
        public static Liter ToLiter<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters / .001;
        }

        /// <summary>
        /// Convertit un volume en pintes
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en pintes</returns>
        public static Pint ToPint<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters / .00056826125;
        }

        /// <summary>
        /// Convertit un volume en gallons impériaux
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en gallons impériaux</returns>
        public static Gallon ToGallon<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters / .00454609;
        }

        /// <summary>
        /// Convertit un volume en gallons US
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en gallons US</returns>
        public static USGallon ToUSGallon<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters / .003785411784;
        }

        /// <summary>
        /// Convertit un volume en onces liquides impériales
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en onces liquides impériales</returns>
        public static FluidOunce ToFluidOunce<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters / .0000284130625;
        }

        /// <summary>
        /// Convertit un volume en onces liquides US
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="volume">volume à convertir</param>
        /// <returns>Valeur en onces liquides US</returns>
        public static USFluidOunce ToUSFluidOunce<T>(this T volume)
            where T : IVolume
        {
            return volume.ValueInCubeMeters / .0000295735295625;
        }

    }
}