<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="System.Xml.Linq" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Xml.Linq" #>
// 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
{
///
/// Représente une mesure de longueur
///
public interface IVolume
{
///
/// Obtient la valeur de ce volume en mètres cubes
///
double ValueInCubeMeters { get; }
}
<#
string fileName = Host.ResolvePath("Units.xml");
var doc = XDocument.Load(fileName);
var units =
from u in doc.Root.Element("Volume").Elements("Unit")
select new
{
TypeName = u.Element("TypeName").Value,
DisplayName = u.Element("DisplayName").Value,
ConversionToSI = u.Element("ConversionToSI").Value,
ConversionFromSI = u.Element("ConversionFromSI").Value,
ParseRegex = u.Element("ParseRegex").Value,
StringFormat = u.Element("StringFormat").Value,
};
foreach (var unit in units)
{
#>
///
/// Représente un volume en <#= unit.DisplayName #>
///
public struct <#= unit.TypeName #> : IVolume, IComparable<<#= unit.TypeName #>>, IEquatable<<#= unit.TypeName #>>, IFormattable
{
private readonly double _value;
///
/// Initialise une nouvelle instance de la structure .
///
/// La valeur de ce volume en <#= unit.DisplayName #>
public <#= unit.TypeName #>(double value)
{
_value = value;
}
///
/// Obtient la valeur de ce volume.
///
///
/// La valeur de ce volume en <#= unit.DisplayName #>
///
public double Value
{
get { return _value; }
}
#region Operators
///
/// Effectue une conversion implicite de vers .
///
/// Valeur en <#= unit.DisplayName #>.
///
/// Résultat de la conversion.
///
public static implicit operator <#= unit.TypeName #>(double value)
{
return new <#= unit.TypeName #>(value);
}
///
/// Effectue une conversion explicite de vers .
///
/// Volume
///
/// Résultat de la conversion.
///
public static explicit operator double(<#= unit.TypeName #> volume)
{
return volume.Value;
}
///
/// Teste l'égalité de deux volumes.
///
/// Premier volume
/// Deuxième volume
///
/// true si les deux volumes sont égaux, false sinon.
///
public static bool operator ==(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return a.Equals(b);
}
///
/// Teste la non-égalité de deux volumes.
///
/// Premier volume
/// Deuxième volume
///
/// true si les deux volumes sont différents, false sinon.
///
public static bool operator !=(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return !(a == b);
}
///
/// Teste si le premier volume est inférieur au deuxième.
///
/// Premier volume
/// Deuxième volume
///
/// true si le premier volume est inférieur au deuxième, false sinon.
///
public static bool operator <(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return a.CompareTo(b) < 0;
}
///
/// Teste si le premier volume est supérieur au deuxième.
///
/// Premier volume
/// Deuxième volume
///
/// true si le premier volume est supérieur au deuxième, false sinon.
///
public static bool operator >(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return a.CompareTo(b) > 0;
}
///
/// Teste si le premier volume est inférieur ou égal au deuxième.
///
/// Premier volume
/// Deuxième volume
///
/// true si le premier volume est inférieur ou égal au deuxième, false sinon.
///
public static bool operator <=(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return a.CompareTo(b) <= 0;
}
///
/// Teste si le premier volume est supérieur ou égal au deuxième.
///
/// Premier volume
/// Deuxième volume
///
/// true si le premier volume est supérieur ou égal au deuxième, false sinon.
///
public static bool operator >=(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return a.CompareTo(b) >= 0;
}
///
/// Additionne deux volumes.
///
/// Premier volume
/// Deuxième volume
///
/// La somme des deux volumes.
///
public static <#= unit.TypeName #> operator +(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return new <#= unit.TypeName #>(a.Value + b.Value);
}
///
/// Soustrait le deuxième volume du premier
///
/// Premier volume
/// Deuxième volume
///
/// La différence entre les deux volumes.
///
public static <#= unit.TypeName #> operator -(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return new <#= unit.TypeName #>(a.Value - b.Value);
}
///
/// Multiplie un volume par un nombre.
///
/// volume
/// Multiplicateur
///
/// Le résultat de la multiplication.
///
public static <#= unit.TypeName #> operator *(<#= unit.TypeName #> volume, double multiplier)
{
return new <#= unit.TypeName #>(volume.Value*multiplier);
}
///
/// Divise un volume par un nombre.
///
/// volume
/// Diviseur
///
/// Le résultat de la division.
///
public static <#= unit.TypeName #> operator /(<#= unit.TypeName #> volume, double divisor)
{
return new <#= unit.TypeName #>(volume.Value/divisor);
}
#endregion
#region Methods
///
/// Compare cette instance avec un objet du même type.
///
/// Objet à comparer avec cette instance.
/// Nombre signé indiquant les valeurs relatives de cette instance et other
///
///
/// Valeur de retour
/// Description
///
/// -
/// inférieur à zéro
/// Cette instance est inférieure à other.
///
/// -
/// Zéro
/// Cette instance est égale à other.
///
/// -
/// supérieur à zéro
/// Cette instance est supérieure à other.
///
///
///
public int CompareTo(<#= unit.TypeName #> other)
{
return Value.CompareTo(other.Value);
}
///
/// Retourne une représentation textuelle de l'instance actuelle
///
/// une représentation textuelle de l'instance actuelle
public override string ToString()
{
return ToString(null, null);
}
///
/// Retourne une représentation textuelle de l'instance actuelle
///
/// Le format à utiliser
/// une représentation textuelle de l'instance actuelle
public string ToString(string format)
{
return ToString(format, null);
}
///
/// Retourne une représentation textuelle de l'instance actuelle
///
/// Le format à utiliser
/// Le fournisseur à utiliser pour formater la valeur
/// une représentation textuelle de l'instance actuelle
public string ToString(string format, IFormatProvider formatProvider)
{
var value = Value.ToString(format, formatProvider);
return string.Format("<#= unit.StringFormat #>", value);
}
///
/// Essaye de parser le texte.
///
/// Texte à parser.
/// volume.
/// true, si le parsing est réussi; sinon false.
public static bool TryParse(string text, out <#= unit.TypeName #> volume)
{
var regex = new Regex(@"<#= unit.ParseRegex #>");
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 <#= unit.TypeName #>(value);
return true;
}
}
volume = new <#= unit.TypeName #>(0);
return false;
}
///
/// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
///
/// Objet à comparer avec cette instance.
///
/// true si l'instance courante est égale au paramètre ; sinon, false.
///
public bool Equals(<#= unit.TypeName #> other)
{
return Value.Equals(other.Value);
}
///
/// Determine si l' spécifié est égal à l'instance courante.
///
/// L' à comparer avec l'instance courante.
///
/// true si l' spécifié est égal à cette instance ; sinon, false.
///
public override bool Equals(object obj)
{
if (obj is <#= unit.TypeName #>)
return Equals((<#= unit.TypeName #>) obj);
return false;
}
///
/// Retourne le hash code de cette instance
///
///
/// Code de hashage de l'instance actuelle.
///
public override int GetHashCode()
{
unchecked
{
return Value.GetHashCode();
}
}
#endregion
#region Implementation of IVolume
///
/// Obtient la valeur de cette volume en mètres cubes
///
double IVolume.ValueInCubeMeters
{
get { return <#= string.Format(unit.ConversionToSI, "_value") #>; }
}
#endregion
}
<# } #>
///
/// Fournit des méthodes d'extension pour les volumes
///
public static class VolumeExtensions
{
<# foreach (var unit in units)
{
#>
///
/// Convertit un volume en <#= unit.DisplayName #>
///
/// Le type de l'unité d'origine
/// volume à convertir
/// Valeur en <#= unit.DisplayName #>
public static <#= unit.TypeName #> To<#= unit.TypeName #>(this T volume)
where T : IVolume
{
return <#= string.Format(unit.ConversionFromSI, "volume.ValueInCubeMeters") #>;
}
<# }#>
}
}