From e63cf4e2b9b554d234c29b7484065ee44a016c59 Mon Sep 17 00:00:00 2001 From: Erik Ovegard Date: Tue, 1 Mar 2016 21:48:20 +0100 Subject: [PATCH] Regenerated code with missing constructors --- UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs | 51 +++++++++ UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs | 102 ++++++++++++++++++ .../UnitClasses/ForceChangeRate.g.cs | 102 ++++++++++++++++++ .../UnitClasses/RotationalSpeed.g.cs | 68 ++++++++++++ 4 files changed, 323 insertions(+) diff --git a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs index 97723f4b34..262d98741a 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Angle.g.cs @@ -362,6 +362,21 @@ public static Angle FromRadians(double radians) } } + /// + /// Get nullable Angle from nullable Microdegrees. + /// + public static Angle? FromMicrodegrees(double? microdegrees) + { + if (microdegrees.HasValue) + { + return FromMicrodegrees(microdegrees.Value); + } + else + { + return null; + } + } + /// /// Get nullable Angle from nullable Microradians. /// @@ -377,6 +392,21 @@ public static Angle FromRadians(double radians) } } + /// + /// Get nullable Angle from nullable Millidegrees. + /// + public static Angle? FromMillidegrees(double? millidegrees) + { + if (millidegrees.HasValue) + { + return FromMillidegrees(millidegrees.Value); + } + else + { + return null; + } + } + /// /// Get nullable Angle from nullable Milliradians. /// @@ -392,6 +422,21 @@ public static Angle FromRadians(double radians) } } + /// + /// Get nullable Angle from nullable Nanodegrees. + /// + public static Angle? FromNanodegrees(double? nanodegrees) + { + if (nanodegrees.HasValue) + { + return FromNanodegrees(nanodegrees.Value); + } + else + { + return null; + } + } + /// /// Get nullable Angle from nullable Nanoradians. /// @@ -491,10 +536,16 @@ public static Angle From(double value, AngleUnit fromUnit) return FromDegrees(value.Value); case AngleUnit.Gradian: return FromGradians(value.Value); + case AngleUnit.Microdegree: + return FromMicrodegrees(value.Value); case AngleUnit.Microradian: return FromMicroradians(value.Value); + case AngleUnit.Millidegree: + return FromMillidegrees(value.Value); case AngleUnit.Milliradian: return FromMilliradians(value.Value); + case AngleUnit.Nanodegree: + return FromNanodegrees(value.Value); case AngleUnit.Nanoradian: return FromNanoradians(value.Value); case AngleUnit.Radian: diff --git a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs index 644491b3e7..1b85c9f2b3 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/Flow.g.cs @@ -256,6 +256,21 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) } + /// + /// Get nullable Flow from nullable CentilitersPerMinute. + /// + public static Flow? FromCentilitersPerMinute(double? centilitersperminute) + { + if (centilitersperminute.HasValue) + { + return FromCentilitersPerMinute(centilitersperminute.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable CubicFeetPerSecond. /// @@ -301,6 +316,36 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) } } + /// + /// Get nullable Flow from nullable DecilitersPerMinute. + /// + public static Flow? FromDecilitersPerMinute(double? decilitersperminute) + { + if (decilitersperminute.HasValue) + { + return FromDecilitersPerMinute(decilitersperminute.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable KilolitersPerMinute. + /// + public static Flow? FromKilolitersPerMinute(double? kilolitersperminute) + { + if (kilolitersperminute.HasValue) + { + return FromKilolitersPerMinute(kilolitersperminute.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable LitersPerMinute. /// @@ -316,6 +361,36 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) } } + /// + /// Get nullable Flow from nullable MicrolitersPerMinute. + /// + public static Flow? FromMicrolitersPerMinute(double? microlitersperminute) + { + if (microlitersperminute.HasValue) + { + return FromMicrolitersPerMinute(microlitersperminute.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable MillilitersPerMinute. + /// + public static Flow? FromMillilitersPerMinute(double? millilitersperminute) + { + if (millilitersperminute.HasValue) + { + return FromMillilitersPerMinute(millilitersperminute.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable MillionUsGallonsPerDay. /// @@ -331,6 +406,21 @@ public static Flow FromUsGallonsPerMinute(double usgallonsperminute) } } + /// + /// Get nullable Flow from nullable NanolitersPerMinute. + /// + public static Flow? FromNanolitersPerMinute(double? nanolitersperminute) + { + if (nanolitersperminute.HasValue) + { + return FromNanolitersPerMinute(nanolitersperminute.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable UsGallonsPerMinute. /// @@ -401,16 +491,28 @@ public static Flow From(double value, FlowUnit fromUnit) } switch (fromUnit) { + case FlowUnit.CentilitersPerMinute: + return FromCentilitersPerMinute(value.Value); case FlowUnit.CubicFootPerSecond: return FromCubicFeetPerSecond(value.Value); case FlowUnit.CubicMeterPerHour: return FromCubicMetersPerHour(value.Value); case FlowUnit.CubicMeterPerSecond: return FromCubicMetersPerSecond(value.Value); + case FlowUnit.DecilitersPerMinute: + return FromDecilitersPerMinute(value.Value); + case FlowUnit.KilolitersPerMinute: + return FromKilolitersPerMinute(value.Value); case FlowUnit.LitersPerMinute: return FromLitersPerMinute(value.Value); + case FlowUnit.MicrolitersPerMinute: + return FromMicrolitersPerMinute(value.Value); + case FlowUnit.MillilitersPerMinute: + return FromMillilitersPerMinute(value.Value); case FlowUnit.MillionUsGallonsPerDay: return FromMillionUsGallonsPerDay(value.Value); + case FlowUnit.NanolitersPerMinute: + return FromNanolitersPerMinute(value.Value); case FlowUnit.UsGallonsPerMinute: return FromUsGallonsPerMinute(value.Value); diff --git a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs index 6ff752910d..da69e537c8 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/ForceChangeRate.g.cs @@ -176,6 +176,96 @@ public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond) } + /// + /// Get nullable ForceChangeRate from nullable CentinewtonsPerSecond. + /// + public static ForceChangeRate? FromCentinewtonsPerSecond(double? centinewtonspersecond) + { + if (centinewtonspersecond.HasValue) + { + return FromCentinewtonsPerSecond(centinewtonspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable ForceChangeRate from nullable DecinewtonsPerSecond. + /// + public static ForceChangeRate? FromDecinewtonsPerSecond(double? decinewtonspersecond) + { + if (decinewtonspersecond.HasValue) + { + return FromDecinewtonsPerSecond(decinewtonspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable ForceChangeRate from nullable KilonewtonsPerSecond. + /// + public static ForceChangeRate? FromKilonewtonsPerSecond(double? kilonewtonspersecond) + { + if (kilonewtonspersecond.HasValue) + { + return FromKilonewtonsPerSecond(kilonewtonspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable ForceChangeRate from nullable MicronewtonsPerSecond. + /// + public static ForceChangeRate? FromMicronewtonsPerSecond(double? micronewtonspersecond) + { + if (micronewtonspersecond.HasValue) + { + return FromMicronewtonsPerSecond(micronewtonspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable ForceChangeRate from nullable MillinewtonsPerSecond. + /// + public static ForceChangeRate? FromMillinewtonsPerSecond(double? millinewtonspersecond) + { + if (millinewtonspersecond.HasValue) + { + return FromMillinewtonsPerSecond(millinewtonspersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable ForceChangeRate from nullable NanonewtonsPerSecond. + /// + public static ForceChangeRate? FromNanonewtonsPerSecond(double? nanonewtonspersecond) + { + if (nanonewtonspersecond.HasValue) + { + return FromNanonewtonsPerSecond(nanonewtonspersecond.Value); + } + else + { + return null; + } + } + /// /// Get nullable ForceChangeRate from nullable NewtonsPerSecond. /// @@ -236,6 +326,18 @@ public static ForceChangeRate From(double value, ForceChangeRateUnit fromUnit) } switch (fromUnit) { + case ForceChangeRateUnit.CentinewtonPerSecond: + return FromCentinewtonsPerSecond(value.Value); + case ForceChangeRateUnit.DecinewtonPerSecond: + return FromDecinewtonsPerSecond(value.Value); + case ForceChangeRateUnit.KilonewtonPerSecond: + return FromKilonewtonsPerSecond(value.Value); + case ForceChangeRateUnit.MicronewtonPerSecond: + return FromMicronewtonsPerSecond(value.Value); + case ForceChangeRateUnit.MillinewtonPerSecond: + return FromMillinewtonsPerSecond(value.Value); + case ForceChangeRateUnit.NanonewtonPerSecond: + return FromNanonewtonsPerSecond(value.Value); case ForceChangeRateUnit.NewtonPerSecond: return FromNewtonsPerSecond(value.Value); diff --git a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs index 95d653fefd..dece33f1a0 100644 --- a/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs +++ b/UnitsNet/GeneratedCode/UnitClasses/RotationalSpeed.g.cs @@ -286,6 +286,36 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco } } + /// + /// Get nullable RotationalSpeed from nullable DegreesPerSecond. + /// + public static RotationalSpeed? FromDegreesPerSecond(double? degreespersecond) + { + if (degreespersecond.HasValue) + { + return FromDegreesPerSecond(degreespersecond.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable RotationalSpeed from nullable MicrodegreesPerSecond. + /// + public static RotationalSpeed? FromMicrodegreesPerSecond(double? microdegreespersecond) + { + if (microdegreespersecond.HasValue) + { + return FromMicrodegreesPerSecond(microdegreespersecond.Value); + } + else + { + return null; + } + } + /// /// Get nullable RotationalSpeed from nullable MicroradiansPerSecond. /// @@ -301,6 +331,21 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco } } + /// + /// Get nullable RotationalSpeed from nullable MillidegreesPerSecond. + /// + public static RotationalSpeed? FromMillidegreesPerSecond(double? millidegreespersecond) + { + if (millidegreespersecond.HasValue) + { + return FromMillidegreesPerSecond(millidegreespersecond.Value); + } + else + { + return null; + } + } + /// /// Get nullable RotationalSpeed from nullable MilliradiansPerSecond. /// @@ -316,6 +361,21 @@ public static RotationalSpeed FromRevolutionsPerSecond(double revolutionsperseco } } + /// + /// Get nullable RotationalSpeed from nullable NanodegreesPerSecond. + /// + public static RotationalSpeed? FromNanodegreesPerSecond(double? nanodegreespersecond) + { + if (nanodegreespersecond.HasValue) + { + return FromNanodegreesPerSecond(nanodegreespersecond.Value); + } + else + { + return null; + } + } + /// /// Get nullable RotationalSpeed from nullable NanoradiansPerSecond. /// @@ -435,10 +495,18 @@ public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit) return FromCentiradiansPerSecond(value.Value); case RotationalSpeedUnit.DeciradianPerSecond: return FromDeciradiansPerSecond(value.Value); + case RotationalSpeedUnit.DegreePerSecond: + return FromDegreesPerSecond(value.Value); + case RotationalSpeedUnit.MicrodegreePerSecond: + return FromMicrodegreesPerSecond(value.Value); case RotationalSpeedUnit.MicroradianPerSecond: return FromMicroradiansPerSecond(value.Value); + case RotationalSpeedUnit.MillidegreePerSecond: + return FromMillidegreesPerSecond(value.Value); case RotationalSpeedUnit.MilliradianPerSecond: return FromMilliradiansPerSecond(value.Value); + case RotationalSpeedUnit.NanodegreePerSecond: + return FromNanodegreesPerSecond(value.Value); case RotationalSpeedUnit.NanoradianPerSecond: return FromNanoradiansPerSecond(value.Value); case RotationalSpeedUnit.RadianPerSecond: