<#@ 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 d'angle
///
public interface IAngle
{
///
/// Obtient la valeur de cet angle en radians
///
double ValueInRadians { get; }
}
<#
string fileName = Host.ResolvePath("Units.xml");
var doc = XDocument.Load(fileName);
var units =
from u in doc.Root.Element("Angle").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 angle en <#= unit.DisplayName #>
///
public struct <#= unit.TypeName #> : IAngle, IComparable<<#= unit.TypeName #>>, IEquatable<<#= unit.TypeName #>>, IFormattable
{
private readonly double _value;
///
/// Initialise une nouvelle instance de la structure .
///
/// La valeur de cet angle en <#= unit.DisplayName #>
public <#= unit.TypeName #>(double value)
{
_value = value;
}
///
/// Obtient la valeur ce cet angle.
///
///
/// La valeur de cet angle
///
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 .
///
/// Angle
///
/// Résultat de la conversion.
///
public static explicit operator double(<#= unit.TypeName #> angle)
{
return angle.Value;
}
///
/// Teste l'égalité de deux angles.
///
/// Premier angle
/// Deuxième angle
///
/// true si les deux angles sont égaux, false sinon.
///
public static bool operator ==(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return a.Equals(b);
}
///
/// Teste la non-égalité de deux angles.
///
/// Premier angle
/// Deuxième angle
///
/// true si les deux angles sont différents, false sinon.
///
public static bool operator !=(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return !(a == b);
}
///
/// Teste si le premier angle est inférieur au deuxième.
///
/// Premier angle
/// Deuxième angle
///
/// true si le premier angle 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 angle est supérieur au deuxième.
///
/// Premier angle
/// Deuxième angle
///
/// true si le premier angle 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 angle est inférieur ou égal au deuxième.
///
/// Premier angle
/// Deuxième angle
///
/// true si le premier angle 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 angle est supérieur ou égal au deuxième.
///
/// Premier angle
/// Deuxième angle
///
/// true si le premier angle 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 angles.
///
/// Premier angle
/// Deuxième angle
///
/// La somme des deux angles.
///
public static <#= unit.TypeName #> operator +(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return new <#= unit.TypeName #>(a.Value + b.Value);
}
///
/// Soustrait le deuxième angle du premier
///
/// Premier angle
/// Deuxième angle
///
/// La différence entre les deux angles.
///
public static <#= unit.TypeName #> operator -(<#= unit.TypeName #> a, <#= unit.TypeName #> b)
{
return new <#= unit.TypeName #>(a.Value - b.Value);
}
///
/// Multiplie un angle par un nombre.
///
/// angle
/// Multiplicateur
///
/// Le résultat de la multiplication.
///
public static <#= unit.TypeName #> operator *(<#= unit.TypeName #> angle, double multiplier)
{
return new <#= unit.TypeName #>(angle.Value*multiplier);
}
///
/// Divise un angle par un nombre.
///
/// Angle
/// Diviseur
///
/// Le résultat de la division.
///
public static <#= unit.TypeName #> operator /(<#= unit.TypeName #> angle, double divisor)
{
return new <#= unit.TypeName #>(angle.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érieure à zéro
/// Cette instance est inférieure à other.
///
/// -
/// Zéro
/// Cette instance est égale à other.
///
/// -
/// Supérieure à 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.
/// Angle.
/// true, si le parsing est réussi; sinon false.
public static bool TryParse(string text, out <#= unit.TypeName #> angle)
{
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))
{
angle = new <#= unit.TypeName #>(value);
return true;
}
}
angle = 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 IAngle
///
/// Obtient la valeur de cet angle en radians
///
double IAngle.ValueInRadians
{
get { return <#= string.Format(unit.ConversionToSI, "_value") #>; }
}
#endregion
}
<# } #>
///
/// Fournit des méthodes d'extension pour les angles
///
public static class AngleExtensions
{
<# foreach (var unit in units)
{
#>
///
/// Convertit un angle en <#= unit.DisplayName #>
///
/// Le type de l'unité d'origine
/// Angle à convertir
/// Valeur en <#= unit.DisplayName #>
public static <#= unit.TypeName #> To<#= unit.TypeName #>(this T angle)
where T : IAngle
{
return <#= string.Format(unit.ConversionFromSI, "angle.ValueInRadians") #>;
}
<# }#>
///
/// Renvoie le sinus de l'angle.
///
/// Le type de l'unité d'angle
/// Angle
/// Le sinus de l'angle
public static double Sin(this T angle)
where T : IAngle
{
return Math.Sin(angle.ValueInRadians);
}
///
/// Renvoie le cosinus de l'angle.
///
/// Le type de l'unité d'angle
/// Angle
/// Le cosinus de l'angle
public static double Cos(this T angle)
where T : IAngle
{
return Math.Cos(angle.ValueInRadians);
}
///
/// Renvoie la tangeante de l'angle.
///
/// Le type de l'unité d'angle
/// Angle
/// La tangeante de l'angle
public static double Tan(this T angle)
where T : IAngle
{
return Math.Tan(angle.ValueInRadians);
}
///
/// Renvoie le sinus hyperbolique de l'angle.
///
/// Le type de l'unité d'angle
/// Angle
/// Le sinus hyperbolique de l'angle
public static double Sinh(this T angle)
where T : IAngle
{
return Math.Sinh(angle.ValueInRadians);
}
///
/// Renvoie le cosinus hyperbolique de l'angle.
///
/// Le type de l'unité d'angle
/// Angle
/// Le cosinus hyperbolique de l'angle
public static double Cosh(this T angle)
where T : IAngle
{
return Math.Cosh(angle.ValueInRadians);
}
///
/// Renvoie la tangeante hyperbolique de l'angle.
///
/// Le type de l'unité d'angle
/// Angle
/// La tangeante hyperbolique de l'angle
public static double Tanh(this T angle)
where T : IAngle
{
return Math.Tanh(angle.ValueInRadians);
}
}
}