Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Moving code that is not valid in WRC from Common code to NetFramework… #460

Merged
merged 2 commits into from
Jul 3, 2018
Merged

Moving code that is not valid in WRC from Common code to NetFramework… #460

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
dc66f51
Moving code that is not valid in WRC from Common code to NetFramework…
tmilnthorp Jul 2, 2018
f3cfc05
Whitespace touchup
tmilnthorp Jul 2, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
296 changes: 0 additions & 296 deletions UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -395,204 +395,6 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
return new Acceleration(value, AccelerationUnit.StandardGravity);
}

// Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
/// <summary>
/// Get nullable Acceleration from nullable CentimetersPerSecondSquared.
/// </summary>
public static Acceleration? FromCentimetersPerSecondSquared(QuantityValue? centimeterspersecondsquared)
{
if (centimeterspersecondsquared.HasValue)
{
return FromCentimetersPerSecondSquared(centimeterspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable DecimetersPerSecondSquared.
/// </summary>
public static Acceleration? FromDecimetersPerSecondSquared(QuantityValue? decimeterspersecondsquared)
{
if (decimeterspersecondsquared.HasValue)
{
return FromDecimetersPerSecondSquared(decimeterspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable FeetPerSecondSquared.
/// </summary>
public static Acceleration? FromFeetPerSecondSquared(QuantityValue? feetpersecondsquared)
{
if (feetpersecondsquared.HasValue)
{
return FromFeetPerSecondSquared(feetpersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable InchesPerSecondSquared.
/// </summary>
public static Acceleration? FromInchesPerSecondSquared(QuantityValue? inchespersecondsquared)
{
if (inchespersecondsquared.HasValue)
{
return FromInchesPerSecondSquared(inchespersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable KilometersPerSecondSquared.
/// </summary>
public static Acceleration? FromKilometersPerSecondSquared(QuantityValue? kilometerspersecondsquared)
{
if (kilometerspersecondsquared.HasValue)
{
return FromKilometersPerSecondSquared(kilometerspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable KnotsPerHour.
/// </summary>
public static Acceleration? FromKnotsPerHour(QuantityValue? knotsperhour)
{
if (knotsperhour.HasValue)
{
return FromKnotsPerHour(knotsperhour.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable KnotsPerMinute.
/// </summary>
public static Acceleration? FromKnotsPerMinute(QuantityValue? knotsperminute)
{
if (knotsperminute.HasValue)
{
return FromKnotsPerMinute(knotsperminute.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable KnotsPerSecond.
/// </summary>
public static Acceleration? FromKnotsPerSecond(QuantityValue? knotspersecond)
{
if (knotspersecond.HasValue)
{
return FromKnotsPerSecond(knotspersecond.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable MetersPerSecondSquared.
/// </summary>
public static Acceleration? FromMetersPerSecondSquared(QuantityValue? meterspersecondsquared)
{
if (meterspersecondsquared.HasValue)
{
return FromMetersPerSecondSquared(meterspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable MicrometersPerSecondSquared.
/// </summary>
public static Acceleration? FromMicrometersPerSecondSquared(QuantityValue? micrometerspersecondsquared)
{
if (micrometerspersecondsquared.HasValue)
{
return FromMicrometersPerSecondSquared(micrometerspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable MillimetersPerSecondSquared.
/// </summary>
public static Acceleration? FromMillimetersPerSecondSquared(QuantityValue? millimeterspersecondsquared)
{
if (millimeterspersecondsquared.HasValue)
{
return FromMillimetersPerSecondSquared(millimeterspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable NanometersPerSecondSquared.
/// </summary>
public static Acceleration? FromNanometersPerSecondSquared(QuantityValue? nanometerspersecondsquared)
{
if (nanometerspersecondsquared.HasValue)
{
return FromNanometersPerSecondSquared(nanometerspersecondsquared.Value);
}
else
{
return null;
}
}

/// <summary>
/// Get nullable Acceleration from nullable StandardGravity.
/// </summary>
public static Acceleration? FromStandardGravity(QuantityValue? standardgravity)
{
if (standardgravity.HasValue)
{
return FromStandardGravity(standardgravity.Value);
}
else
{
return null;
}
}

#endif

/// <summary>
/// Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration" />.
Expand All @@ -611,25 +413,6 @@ public static Acceleration From(QuantityValue value, AccelerationUnit fromUnit)
return new Acceleration((double)value, fromUnit);
}

// Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
/// <summary>
/// Dynamically convert from value and unit enum <see cref="AccelerationUnit" /> to <see cref="Acceleration" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>Acceleration unit value.</returns>
public static Acceleration? From(QuantityValue? value, AccelerationUnit fromUnit)
{
if (!value.HasValue)
{
return null;
}

return new Acceleration((double)value.Value, fromUnit);
}
#endif

/// <summary>
/// Get unit abbreviation string.
/// </summary>
Expand Down Expand Up @@ -672,48 +455,6 @@ public static string GetAbbreviation(

#endregion

#region Arithmetic Operators

// Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
public static Acceleration operator -(Acceleration right)
{
return new Acceleration(-right.Value, right.Unit);
}

public static Acceleration operator +(Acceleration left, Acceleration right)
{
return new Acceleration(left.Value + right.AsBaseNumericType(left.Unit), left.Unit);
}

public static Acceleration operator -(Acceleration left, Acceleration right)
{
return new Acceleration(left.Value - right.AsBaseNumericType(left.Unit), left.Unit);
}

public static Acceleration operator *(double left, Acceleration right)
{
return new Acceleration(left * right.Value, right.Unit);
}

public static Acceleration operator *(Acceleration left, double right)
{
return new Acceleration(left.Value * right, left.Unit);
}

public static Acceleration operator /(Acceleration left, double right)
{
return new Acceleration(left.Value / right, left.Unit);
}

public static double operator /(Acceleration left, Acceleration right)
{
return left.MetersPerSecondSquared / right.MetersPerSecondSquared;
}
#endif

#endregion

#region Equality / IComparable

public int CompareTo(object obj)
Expand All @@ -735,43 +476,6 @@ int CompareTo(Acceleration other)
return _value.CompareTo(other.AsBaseNumericType(this.Unit));
}

// Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
public static bool operator <=(Acceleration left, Acceleration right)
{
return left.Value <= right.AsBaseNumericType(left.Unit);
}

public static bool operator >=(Acceleration left, Acceleration right)
{
return left.Value >= right.AsBaseNumericType(left.Unit);
}

public static bool operator <(Acceleration left, Acceleration right)
{
return left.Value < right.AsBaseNumericType(left.Unit);
}

public static bool operator >(Acceleration left, Acceleration right)
{
return left.Value > right.AsBaseNumericType(left.Unit);
}

[Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals($quantityName, double, ComparisonType) to provide the max allowed absolute or relative error.")]
public static bool operator ==(Acceleration left, Acceleration right)
{
// ReSharper disable once CompareOfFloatsByEqualityOperator
return left.Value == right.AsBaseNumericType(left.Unit);
}

[Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals($quantityName, double, ComparisonType) to provide the max allowed absolute or relative error.")]
public static bool operator !=(Acceleration left, Acceleration right)
{
// ReSharper disable once CompareOfFloatsByEqualityOperator
return left.Value != right.AsBaseNumericType(left.Unit);
}
#endif

[Obsolete("It is not safe to compare equality due to using System.Double as the internal representation. It is very easy to get slightly different values due to floating point operations. Instead use Equals($quantityName, double, ComparisonType) to provide the max allowed absolute or relative error.")]
public override bool Equals(object obj)
{
Expand Down
Loading