From bfaa9dcf35996007deed039b62d692f14c95cf1e Mon Sep 17 00:00:00 2001 From: Go Date: Tue, 9 Jan 2018 12:50:41 -0600 Subject: [PATCH 1/2] Add More Flow Units Fixes https://github.com/angularsen/UnitsNet/issues/360 --- UnitsNet.Tests/CustomCode/FlowTests.cs | 14 + .../GeneratedCode/FlowTestsBase.g.cs | 42 +++ .../Number/NumberToFlowExtensions.g.cs | 238 +++++++++++++ UnitsNet/GeneratedCode/Quantities/Flow.g.cs | 329 ++++++++++++++++++ .../GeneratedCode/UnitSystem.Default.g.cs | 35 ++ UnitsNet/GeneratedCode/Units/FlowUnit.g.cs | 7 + UnitsNet/UnitDefinitions/Flow.json | 108 +++++- 7 files changed, 761 insertions(+), 12 deletions(-) diff --git a/UnitsNet.Tests/CustomCode/FlowTests.cs b/UnitsNet.Tests/CustomCode/FlowTests.cs index 6047ab85a2..9742af1064 100644 --- a/UnitsNet.Tests/CustomCode/FlowTests.cs +++ b/UnitsNet.Tests/CustomCode/FlowTests.cs @@ -54,5 +54,19 @@ public class FlowTests : FlowTestsBase protected override double KilolitersPerMinuteInOneCubicMeterPerSecond => 60.00000; protected override double OilBarrelsPerDayInOneCubicMeterPerSecond => 543439.65056533388306722269588172; + + protected override double CubicFeetPerMinuteInOneCubicMeterPerSecond => 2.11888E3; + + protected override double CubicMetersPerMinuteInOneCubicMeterPerSecond => 6.0E1; + + protected override double CubicYardsPerHourInOneCubicMeterPerSecond => 4.708622232E3; + + protected override double CubicYardsPerMinuteInOneCubicMeterPerSecond => 7.84770372E1; + + protected override double CubicYardsPerSecondInOneCubicMeterPerSecond => 1.30795062; + + protected override double UsGallonsPerHourInOneCubicMeterPerSecond => 9.510193884893328E5; + + protected override double UsGallonsPerSecondInOneCubicMeterPerSecond => 2.64172052358148E2; } } \ No newline at end of file diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs index acf193a3d2..12351c6926 100644 --- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs +++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs @@ -55,9 +55,14 @@ public abstract partial class FlowTestsBase protected abstract double CentilitersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double CubicDecimetersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double CubicFeetPerHourInOneCubicMeterPerSecond { get; } + protected abstract double CubicFeetPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double CubicFeetPerSecondInOneCubicMeterPerSecond { get; } protected abstract double CubicMetersPerHourInOneCubicMeterPerSecond { get; } + protected abstract double CubicMetersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double CubicMetersPerSecondInOneCubicMeterPerSecond { get; } + protected abstract double CubicYardsPerHourInOneCubicMeterPerSecond { get; } + protected abstract double CubicYardsPerMinuteInOneCubicMeterPerSecond { get; } + protected abstract double CubicYardsPerSecondInOneCubicMeterPerSecond { get; } protected abstract double DecilitersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double KilolitersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double LitersPerHourInOneCubicMeterPerSecond { get; } @@ -68,15 +73,22 @@ public abstract partial class FlowTestsBase protected abstract double MillionUsGallonsPerDayInOneCubicMeterPerSecond { get; } protected abstract double NanolitersPerMinuteInOneCubicMeterPerSecond { get; } protected abstract double OilBarrelsPerDayInOneCubicMeterPerSecond { get; } + protected abstract double UsGallonsPerHourInOneCubicMeterPerSecond { get; } protected abstract double UsGallonsPerMinuteInOneCubicMeterPerSecond { get; } + protected abstract double UsGallonsPerSecondInOneCubicMeterPerSecond { get; } // ReSharper disable VirtualMemberNeverOverriden.Global protected virtual double CentilitersPerMinuteTolerance { get { return 1e-5; } } protected virtual double CubicDecimetersPerMinuteTolerance { get { return 1e-5; } } protected virtual double CubicFeetPerHourTolerance { get { return 1e-5; } } + protected virtual double CubicFeetPerMinuteTolerance { get { return 1e-5; } } protected virtual double CubicFeetPerSecondTolerance { get { return 1e-5; } } protected virtual double CubicMetersPerHourTolerance { get { return 1e-5; } } + protected virtual double CubicMetersPerMinuteTolerance { get { return 1e-5; } } protected virtual double CubicMetersPerSecondTolerance { get { return 1e-5; } } + protected virtual double CubicYardsPerHourTolerance { get { return 1e-5; } } + protected virtual double CubicYardsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double CubicYardsPerSecondTolerance { get { return 1e-5; } } protected virtual double DecilitersPerMinuteTolerance { get { return 1e-5; } } protected virtual double KilolitersPerMinuteTolerance { get { return 1e-5; } } protected virtual double LitersPerHourTolerance { get { return 1e-5; } } @@ -87,7 +99,9 @@ public abstract partial class FlowTestsBase protected virtual double MillionUsGallonsPerDayTolerance { get { return 1e-5; } } protected virtual double NanolitersPerMinuteTolerance { get { return 1e-5; } } protected virtual double OilBarrelsPerDayTolerance { get { return 1e-5; } } + protected virtual double UsGallonsPerHourTolerance { get { return 1e-5; } } protected virtual double UsGallonsPerMinuteTolerance { get { return 1e-5; } } + protected virtual double UsGallonsPerSecondTolerance { get { return 1e-5; } } // ReSharper restore VirtualMemberNeverOverriden.Global [Fact] @@ -97,9 +111,14 @@ public void CubicMeterPerSecondToFlowUnits() AssertEx.EqualTolerance(CentilitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CentilitersPerMinute, CentilitersPerMinuteTolerance); AssertEx.EqualTolerance(CubicDecimetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicDecimetersPerMinute, CubicDecimetersPerMinuteTolerance); AssertEx.EqualTolerance(CubicFeetPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicFeetPerHour, CubicFeetPerHourTolerance); + AssertEx.EqualTolerance(CubicFeetPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicFeetPerMinute, CubicFeetPerMinuteTolerance); AssertEx.EqualTolerance(CubicFeetPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicFeetPerSecond, CubicFeetPerSecondTolerance); AssertEx.EqualTolerance(CubicMetersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerHour, CubicMetersPerHourTolerance); + AssertEx.EqualTolerance(CubicMetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerMinute, CubicMetersPerMinuteTolerance); AssertEx.EqualTolerance(CubicMetersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicMetersPerSecond, CubicMetersPerSecondTolerance); + AssertEx.EqualTolerance(CubicYardsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerHour, CubicYardsPerHourTolerance); + AssertEx.EqualTolerance(CubicYardsPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerMinute, CubicYardsPerMinuteTolerance); + AssertEx.EqualTolerance(CubicYardsPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.CubicYardsPerSecond, CubicYardsPerSecondTolerance); AssertEx.EqualTolerance(DecilitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.DecilitersPerMinute, DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(KilolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.KilolitersPerMinute, KilolitersPerMinuteTolerance); AssertEx.EqualTolerance(LitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.LitersPerHour, LitersPerHourTolerance); @@ -110,7 +129,9 @@ public void CubicMeterPerSecondToFlowUnits() AssertEx.EqualTolerance(MillionUsGallonsPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.MillionUsGallonsPerDay, MillionUsGallonsPerDayTolerance); AssertEx.EqualTolerance(NanolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.NanolitersPerMinute, NanolitersPerMinuteTolerance); AssertEx.EqualTolerance(OilBarrelsPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.OilBarrelsPerDay, OilBarrelsPerDayTolerance); + AssertEx.EqualTolerance(UsGallonsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.UsGallonsPerHour, UsGallonsPerHourTolerance); AssertEx.EqualTolerance(UsGallonsPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.UsGallonsPerMinute, UsGallonsPerMinuteTolerance); + AssertEx.EqualTolerance(UsGallonsPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.UsGallonsPerSecond, UsGallonsPerSecondTolerance); } [Fact] @@ -119,9 +140,14 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CentilitersPerMinute).CentilitersPerMinute, CentilitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicDecimeterPerMinute).CubicDecimetersPerMinute, CubicDecimetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicFootPerHour).CubicFeetPerHour, CubicFeetPerHourTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicFootPerMinute).CubicFeetPerMinute, CubicFeetPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicFootPerSecond).CubicFeetPerSecond, CubicFeetPerSecondTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicMeterPerHour).CubicMetersPerHour, CubicMetersPerHourTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicMeterPerMinute).CubicMetersPerMinute, CubicMetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicMeterPerSecond).CubicMetersPerSecond, CubicMetersPerSecondTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicYardPerHour).CubicYardsPerHour, CubicYardsPerHourTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicYardPerMinute).CubicYardsPerMinute, CubicYardsPerMinuteTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.CubicYardPerSecond).CubicYardsPerSecond, CubicYardsPerSecondTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.DecilitersPerMinute).DecilitersPerMinute, DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.KilolitersPerMinute).KilolitersPerMinute, KilolitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.LitersPerHour).LitersPerHour, LitersPerHourTolerance); @@ -132,7 +158,9 @@ public void FromValueAndUnit() AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.MillionUsGallonsPerDay).MillionUsGallonsPerDay, MillionUsGallonsPerDayTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.NanolitersPerMinute).NanolitersPerMinute, NanolitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.OilBarrelsPerDay).OilBarrelsPerDay, OilBarrelsPerDayTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.UsGallonsPerHour).UsGallonsPerHour, UsGallonsPerHourTolerance); AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.UsGallonsPerMinute).UsGallonsPerMinute, UsGallonsPerMinuteTolerance); + AssertEx.EqualTolerance(1, Flow.From(1, FlowUnit.UsGallonsPerSecond).UsGallonsPerSecond, UsGallonsPerSecondTolerance); } [Fact] @@ -142,9 +170,14 @@ public void As() AssertEx.EqualTolerance(CentilitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CentilitersPerMinute), CentilitersPerMinuteTolerance); AssertEx.EqualTolerance(CubicDecimetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicDecimeterPerMinute), CubicDecimetersPerMinuteTolerance); AssertEx.EqualTolerance(CubicFeetPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicFootPerHour), CubicFeetPerHourTolerance); + AssertEx.EqualTolerance(CubicFeetPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicFootPerMinute), CubicFeetPerMinuteTolerance); AssertEx.EqualTolerance(CubicFeetPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicFootPerSecond), CubicFeetPerSecondTolerance); AssertEx.EqualTolerance(CubicMetersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicMeterPerHour), CubicMetersPerHourTolerance); + AssertEx.EqualTolerance(CubicMetersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicMeterPerMinute), CubicMetersPerMinuteTolerance); AssertEx.EqualTolerance(CubicMetersPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicMeterPerSecond), CubicMetersPerSecondTolerance); + AssertEx.EqualTolerance(CubicYardsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicYardPerHour), CubicYardsPerHourTolerance); + AssertEx.EqualTolerance(CubicYardsPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicYardPerMinute), CubicYardsPerMinuteTolerance); + AssertEx.EqualTolerance(CubicYardsPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.CubicYardPerSecond), CubicYardsPerSecondTolerance); AssertEx.EqualTolerance(DecilitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.DecilitersPerMinute), DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(KilolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.KilolitersPerMinute), KilolitersPerMinuteTolerance); AssertEx.EqualTolerance(LitersPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.LitersPerHour), LitersPerHourTolerance); @@ -155,7 +188,9 @@ public void As() AssertEx.EqualTolerance(MillionUsGallonsPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.MillionUsGallonsPerDay), MillionUsGallonsPerDayTolerance); AssertEx.EqualTolerance(NanolitersPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.NanolitersPerMinute), NanolitersPerMinuteTolerance); AssertEx.EqualTolerance(OilBarrelsPerDayInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.OilBarrelsPerDay), OilBarrelsPerDayTolerance); + AssertEx.EqualTolerance(UsGallonsPerHourInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.UsGallonsPerHour), UsGallonsPerHourTolerance); AssertEx.EqualTolerance(UsGallonsPerMinuteInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.UsGallonsPerMinute), UsGallonsPerMinuteTolerance); + AssertEx.EqualTolerance(UsGallonsPerSecondInOneCubicMeterPerSecond, cubicmeterpersecond.As(FlowUnit.UsGallonsPerSecond), UsGallonsPerSecondTolerance); } [Fact] @@ -165,9 +200,14 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Flow.FromCentilitersPerMinute(cubicmeterpersecond.CentilitersPerMinute).CubicMetersPerSecond, CentilitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromCubicDecimetersPerMinute(cubicmeterpersecond.CubicDecimetersPerMinute).CubicMetersPerSecond, CubicDecimetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromCubicFeetPerHour(cubicmeterpersecond.CubicFeetPerHour).CubicMetersPerSecond, CubicFeetPerHourTolerance); + AssertEx.EqualTolerance(1, Flow.FromCubicFeetPerMinute(cubicmeterpersecond.CubicFeetPerMinute).CubicMetersPerSecond, CubicFeetPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromCubicFeetPerSecond(cubicmeterpersecond.CubicFeetPerSecond).CubicMetersPerSecond, CubicFeetPerSecondTolerance); AssertEx.EqualTolerance(1, Flow.FromCubicMetersPerHour(cubicmeterpersecond.CubicMetersPerHour).CubicMetersPerSecond, CubicMetersPerHourTolerance); + AssertEx.EqualTolerance(1, Flow.FromCubicMetersPerMinute(cubicmeterpersecond.CubicMetersPerMinute).CubicMetersPerSecond, CubicMetersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromCubicMetersPerSecond(cubicmeterpersecond.CubicMetersPerSecond).CubicMetersPerSecond, CubicMetersPerSecondTolerance); + AssertEx.EqualTolerance(1, Flow.FromCubicYardsPerHour(cubicmeterpersecond.CubicYardsPerHour).CubicMetersPerSecond, CubicYardsPerHourTolerance); + AssertEx.EqualTolerance(1, Flow.FromCubicYardsPerMinute(cubicmeterpersecond.CubicYardsPerMinute).CubicMetersPerSecond, CubicYardsPerMinuteTolerance); + AssertEx.EqualTolerance(1, Flow.FromCubicYardsPerSecond(cubicmeterpersecond.CubicYardsPerSecond).CubicMetersPerSecond, CubicYardsPerSecondTolerance); AssertEx.EqualTolerance(1, Flow.FromDecilitersPerMinute(cubicmeterpersecond.DecilitersPerMinute).CubicMetersPerSecond, DecilitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromKilolitersPerMinute(cubicmeterpersecond.KilolitersPerMinute).CubicMetersPerSecond, KilolitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromLitersPerHour(cubicmeterpersecond.LitersPerHour).CubicMetersPerSecond, LitersPerHourTolerance); @@ -178,7 +218,9 @@ public void ConversionRoundTrip() AssertEx.EqualTolerance(1, Flow.FromMillionUsGallonsPerDay(cubicmeterpersecond.MillionUsGallonsPerDay).CubicMetersPerSecond, MillionUsGallonsPerDayTolerance); AssertEx.EqualTolerance(1, Flow.FromNanolitersPerMinute(cubicmeterpersecond.NanolitersPerMinute).CubicMetersPerSecond, NanolitersPerMinuteTolerance); AssertEx.EqualTolerance(1, Flow.FromOilBarrelsPerDay(cubicmeterpersecond.OilBarrelsPerDay).CubicMetersPerSecond, OilBarrelsPerDayTolerance); + AssertEx.EqualTolerance(1, Flow.FromUsGallonsPerHour(cubicmeterpersecond.UsGallonsPerHour).CubicMetersPerSecond, UsGallonsPerHourTolerance); AssertEx.EqualTolerance(1, Flow.FromUsGallonsPerMinute(cubicmeterpersecond.UsGallonsPerMinute).CubicMetersPerSecond, UsGallonsPerMinuteTolerance); + AssertEx.EqualTolerance(1, Flow.FromUsGallonsPerSecond(cubicmeterpersecond.UsGallonsPerSecond).CubicMetersPerSecond, UsGallonsPerSecondTolerance); } [Fact] diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToFlowExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToFlowExtensions.g.cs index 429319f6ba..ed2ed7ee9f 100644 --- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToFlowExtensions.g.cs +++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToFlowExtensions.g.cs @@ -146,6 +146,40 @@ public static class NumberToFlowExtensions #endregion + #region CubicFootPerMinute + + /// + public static Flow CubicFeetPerMinute(this int value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow? CubicFeetPerMinute(this int? value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow CubicFeetPerMinute(this long value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow? CubicFeetPerMinute(this long? value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow CubicFeetPerMinute(this double value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow? CubicFeetPerMinute(this double? value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow CubicFeetPerMinute(this float value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow? CubicFeetPerMinute(this float? value) => Flow.FromCubicFeetPerMinute(value); + + /// + public static Flow CubicFeetPerMinute(this decimal value) => Flow.FromCubicFeetPerMinute(Convert.ToDouble(value)); + + /// + public static Flow? CubicFeetPerMinute(this decimal? value) => Flow.FromCubicFeetPerMinute(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region CubicFootPerSecond /// @@ -214,6 +248,40 @@ public static class NumberToFlowExtensions #endregion + #region CubicMeterPerMinute + + /// + public static Flow CubicMetersPerMinute(this int value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow? CubicMetersPerMinute(this int? value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow CubicMetersPerMinute(this long value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow? CubicMetersPerMinute(this long? value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow CubicMetersPerMinute(this double value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow? CubicMetersPerMinute(this double? value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow CubicMetersPerMinute(this float value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow? CubicMetersPerMinute(this float? value) => Flow.FromCubicMetersPerMinute(value); + + /// + public static Flow CubicMetersPerMinute(this decimal value) => Flow.FromCubicMetersPerMinute(Convert.ToDouble(value)); + + /// + public static Flow? CubicMetersPerMinute(this decimal? value) => Flow.FromCubicMetersPerMinute(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region CubicMeterPerSecond /// @@ -248,6 +316,108 @@ public static class NumberToFlowExtensions #endregion + #region CubicYardPerHour + + /// + public static Flow CubicYardsPerHour(this int value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow? CubicYardsPerHour(this int? value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow CubicYardsPerHour(this long value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow? CubicYardsPerHour(this long? value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow CubicYardsPerHour(this double value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow? CubicYardsPerHour(this double? value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow CubicYardsPerHour(this float value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow? CubicYardsPerHour(this float? value) => Flow.FromCubicYardsPerHour(value); + + /// + public static Flow CubicYardsPerHour(this decimal value) => Flow.FromCubicYardsPerHour(Convert.ToDouble(value)); + + /// + public static Flow? CubicYardsPerHour(this decimal? value) => Flow.FromCubicYardsPerHour(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region CubicYardPerMinute + + /// + public static Flow CubicYardsPerMinute(this int value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow? CubicYardsPerMinute(this int? value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow CubicYardsPerMinute(this long value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow? CubicYardsPerMinute(this long? value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow CubicYardsPerMinute(this double value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow? CubicYardsPerMinute(this double? value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow CubicYardsPerMinute(this float value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow? CubicYardsPerMinute(this float? value) => Flow.FromCubicYardsPerMinute(value); + + /// + public static Flow CubicYardsPerMinute(this decimal value) => Flow.FromCubicYardsPerMinute(Convert.ToDouble(value)); + + /// + public static Flow? CubicYardsPerMinute(this decimal? value) => Flow.FromCubicYardsPerMinute(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + + #region CubicYardPerSecond + + /// + public static Flow CubicYardsPerSecond(this int value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow? CubicYardsPerSecond(this int? value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow CubicYardsPerSecond(this long value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow? CubicYardsPerSecond(this long? value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow CubicYardsPerSecond(this double value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow? CubicYardsPerSecond(this double? value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow CubicYardsPerSecond(this float value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow? CubicYardsPerSecond(this float? value) => Flow.FromCubicYardsPerSecond(value); + + /// + public static Flow CubicYardsPerSecond(this decimal value) => Flow.FromCubicYardsPerSecond(Convert.ToDouble(value)); + + /// + public static Flow? CubicYardsPerSecond(this decimal? value) => Flow.FromCubicYardsPerSecond(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region DecilitersPerMinute /// @@ -588,6 +758,40 @@ public static class NumberToFlowExtensions #endregion + #region UsGallonsPerHour + + /// + public static Flow UsGallonsPerHour(this int value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow? UsGallonsPerHour(this int? value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow UsGallonsPerHour(this long value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow? UsGallonsPerHour(this long? value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow UsGallonsPerHour(this double value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow? UsGallonsPerHour(this double? value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow UsGallonsPerHour(this float value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow? UsGallonsPerHour(this float? value) => Flow.FromUsGallonsPerHour(value); + + /// + public static Flow UsGallonsPerHour(this decimal value) => Flow.FromUsGallonsPerHour(Convert.ToDouble(value)); + + /// + public static Flow? UsGallonsPerHour(this decimal? value) => Flow.FromUsGallonsPerHour(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + #region UsGallonsPerMinute /// @@ -622,6 +826,40 @@ public static class NumberToFlowExtensions #endregion + #region UsGallonsPerSecond + + /// + public static Flow UsGallonsPerSecond(this int value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow? UsGallonsPerSecond(this int? value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow UsGallonsPerSecond(this long value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow? UsGallonsPerSecond(this long? value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow UsGallonsPerSecond(this double value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow? UsGallonsPerSecond(this double? value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow UsGallonsPerSecond(this float value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow? UsGallonsPerSecond(this float? value) => Flow.FromUsGallonsPerSecond(value); + + /// + public static Flow UsGallonsPerSecond(this decimal value) => Flow.FromUsGallonsPerSecond(Convert.ToDouble(value)); + + /// + public static Flow? UsGallonsPerSecond(this decimal? value) => Flow.FromUsGallonsPerSecond(value == null ? (double?)null : Convert.ToDouble(value.Value)); + + #endregion + } } #endif diff --git a/UnitsNet/GeneratedCode/Quantities/Flow.g.cs b/UnitsNet/GeneratedCode/Quantities/Flow.g.cs index 1eb6997da1..2f28f30494 100644 --- a/UnitsNet/GeneratedCode/Quantities/Flow.g.cs +++ b/UnitsNet/GeneratedCode/Quantities/Flow.g.cs @@ -153,6 +153,14 @@ public double CubicFeetPerHour get { return _cubicMetersPerSecond/7.8657907199999087346816086183876e-6; } } + /// + /// Get Flow in CubicFeetPerMinute. + /// + public double CubicFeetPerMinute + { + get { return _cubicMetersPerSecond*2118.88000326; } + } + /// /// Get Flow in CubicFeetPerSecond. /// @@ -169,6 +177,14 @@ public double CubicMetersPerHour get { return _cubicMetersPerSecond*3600; } } + /// + /// Get Flow in CubicMetersPerMinute. + /// + public double CubicMetersPerMinute + { + get { return _cubicMetersPerSecond*60; } + } + /// /// Get Flow in CubicMetersPerSecond. /// @@ -177,6 +193,30 @@ public double CubicMetersPerSecond get { return _cubicMetersPerSecond; } } + /// + /// Get Flow in CubicYardsPerHour. + /// + public double CubicYardsPerHour + { + get { return _cubicMetersPerSecond/2.1237634944E-4; } + } + + /// + /// Get Flow in CubicYardsPerMinute. + /// + public double CubicYardsPerMinute + { + get { return _cubicMetersPerSecond/0.0127425809664; } + } + + /// + /// Get Flow in CubicYardsPerSecond. + /// + public double CubicYardsPerSecond + { + get { return _cubicMetersPerSecond/0.764554857984; } + } + /// /// Get Flow in DecilitersPerMinute. /// @@ -257,6 +297,14 @@ public double OilBarrelsPerDay get { return _cubicMetersPerSecond/1.8401307283333333333333333333333e-6; } } + /// + /// Get Flow in UsGallonsPerHour. + /// + public double UsGallonsPerHour + { + get { return _cubicMetersPerSecond*951019.38848933424; } + } + /// /// Get Flow in UsGallonsPerMinute. /// @@ -265,6 +313,14 @@ public double UsGallonsPerMinute get { return _cubicMetersPerSecond*15850.323141489; } } + /// + /// Get Flow in UsGallonsPerSecond. + /// + public double UsGallonsPerSecond + { + get { return _cubicMetersPerSecond*264.1720523581484; } + } + #endregion #region Static @@ -328,6 +384,24 @@ public static Flow FromCubicFeetPerHour(QuantityValue cubicfeetperhour) } #endif + /// + /// Get Flow from CubicFeetPerMinute. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromCubicFeetPerMinute(double cubicfeetperminute) + { + double value = (double) cubicfeetperminute; + return new Flow(value/2118.88000326); + } +#else + public static Flow FromCubicFeetPerMinute(QuantityValue cubicfeetperminute) + { + double value = (double) cubicfeetperminute; + return new Flow((value/2118.88000326)); + } +#endif + /// /// Get Flow from CubicFeetPerSecond. /// @@ -364,6 +438,24 @@ public static Flow FromCubicMetersPerHour(QuantityValue cubicmetersperhour) } #endif + /// + /// Get Flow from CubicMetersPerMinute. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromCubicMetersPerMinute(double cubicmetersperminute) + { + double value = (double) cubicmetersperminute; + return new Flow(value/60); + } +#else + public static Flow FromCubicMetersPerMinute(QuantityValue cubicmetersperminute) + { + double value = (double) cubicmetersperminute; + return new Flow((value/60)); + } +#endif + /// /// Get Flow from CubicMetersPerSecond. /// @@ -382,6 +474,60 @@ public static Flow FromCubicMetersPerSecond(QuantityValue cubicmeterspersecond) } #endif + /// + /// Get Flow from CubicYardsPerHour. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromCubicYardsPerHour(double cubicyardsperhour) + { + double value = (double) cubicyardsperhour; + return new Flow(value*2.1237634944E-4); + } +#else + public static Flow FromCubicYardsPerHour(QuantityValue cubicyardsperhour) + { + double value = (double) cubicyardsperhour; + return new Flow((value*2.1237634944E-4)); + } +#endif + + /// + /// Get Flow from CubicYardsPerMinute. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromCubicYardsPerMinute(double cubicyardsperminute) + { + double value = (double) cubicyardsperminute; + return new Flow(value*0.0127425809664); + } +#else + public static Flow FromCubicYardsPerMinute(QuantityValue cubicyardsperminute) + { + double value = (double) cubicyardsperminute; + return new Flow((value*0.0127425809664)); + } +#endif + + /// + /// Get Flow from CubicYardsPerSecond. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromCubicYardsPerSecond(double cubicyardspersecond) + { + double value = (double) cubicyardspersecond; + return new Flow(value*0.764554857984); + } +#else + public static Flow FromCubicYardsPerSecond(QuantityValue cubicyardspersecond) + { + double value = (double) cubicyardspersecond; + return new Flow((value*0.764554857984)); + } +#endif + /// /// Get Flow from DecilitersPerMinute. /// @@ -562,6 +708,24 @@ public static Flow FromOilBarrelsPerDay(QuantityValue oilbarrelsperday) } #endif + /// + /// Get Flow from UsGallonsPerHour. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromUsGallonsPerHour(double usgallonsperhour) + { + double value = (double) usgallonsperhour; + return new Flow(value/951019.38848933424); + } +#else + public static Flow FromUsGallonsPerHour(QuantityValue usgallonsperhour) + { + double value = (double) usgallonsperhour; + return new Flow((value/951019.38848933424)); + } +#endif + /// /// Get Flow from UsGallonsPerMinute. /// @@ -580,6 +744,24 @@ public static Flow FromUsGallonsPerMinute(QuantityValue usgallonsperminute) } #endif + /// + /// Get Flow from UsGallonsPerSecond. + /// +#if WINDOWS_UWP + [Windows.Foundation.Metadata.DefaultOverload] + public static Flow FromUsGallonsPerSecond(double usgallonspersecond) + { + double value = (double) usgallonspersecond; + return new Flow(value/264.1720523581484); + } +#else + public static Flow FromUsGallonsPerSecond(QuantityValue usgallonspersecond) + { + double value = (double) usgallonspersecond; + return new Flow((value/264.1720523581484)); + } +#endif + // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx #if !WINDOWS_UWP /// @@ -627,6 +809,21 @@ public static Flow FromUsGallonsPerMinute(QuantityValue usgallonsperminute) } } + /// + /// Get nullable Flow from nullable CubicFeetPerMinute. + /// + public static Flow? FromCubicFeetPerMinute(QuantityValue? cubicfeetperminute) + { + if (cubicfeetperminute.HasValue) + { + return FromCubicFeetPerMinute(cubicfeetperminute.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable CubicFeetPerSecond. /// @@ -657,6 +854,21 @@ public static Flow FromUsGallonsPerMinute(QuantityValue usgallonsperminute) } } + /// + /// Get nullable Flow from nullable CubicMetersPerMinute. + /// + public static Flow? FromCubicMetersPerMinute(QuantityValue? cubicmetersperminute) + { + if (cubicmetersperminute.HasValue) + { + return FromCubicMetersPerMinute(cubicmetersperminute.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable CubicMetersPerSecond. /// @@ -672,6 +884,51 @@ public static Flow FromUsGallonsPerMinute(QuantityValue usgallonsperminute) } } + /// + /// Get nullable Flow from nullable CubicYardsPerHour. + /// + public static Flow? FromCubicYardsPerHour(QuantityValue? cubicyardsperhour) + { + if (cubicyardsperhour.HasValue) + { + return FromCubicYardsPerHour(cubicyardsperhour.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable CubicYardsPerMinute. + /// + public static Flow? FromCubicYardsPerMinute(QuantityValue? cubicyardsperminute) + { + if (cubicyardsperminute.HasValue) + { + return FromCubicYardsPerMinute(cubicyardsperminute.Value); + } + else + { + return null; + } + } + + /// + /// Get nullable Flow from nullable CubicYardsPerSecond. + /// + public static Flow? FromCubicYardsPerSecond(QuantityValue? cubicyardspersecond) + { + if (cubicyardspersecond.HasValue) + { + return FromCubicYardsPerSecond(cubicyardspersecond.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable DecilitersPerMinute. /// @@ -822,6 +1079,21 @@ public static Flow FromUsGallonsPerMinute(QuantityValue usgallonsperminute) } } + /// + /// Get nullable Flow from nullable UsGallonsPerHour. + /// + public static Flow? FromUsGallonsPerHour(QuantityValue? usgallonsperhour) + { + if (usgallonsperhour.HasValue) + { + return FromUsGallonsPerHour(usgallonsperhour.Value); + } + else + { + return null; + } + } + /// /// Get nullable Flow from nullable UsGallonsPerMinute. /// @@ -837,6 +1109,21 @@ public static Flow FromUsGallonsPerMinute(QuantityValue usgallonsperminute) } } + /// + /// Get nullable Flow from nullable UsGallonsPerSecond. + /// + public static Flow? FromUsGallonsPerSecond(QuantityValue? usgallonspersecond) + { + if (usgallonspersecond.HasValue) + { + return FromUsGallonsPerSecond(usgallonspersecond.Value); + } + else + { + return null; + } + } + #endif /// @@ -861,12 +1148,22 @@ public static Flow From(QuantityValue value, FlowUnit fromUnit) return FromCubicDecimetersPerMinute(value); case FlowUnit.CubicFootPerHour: return FromCubicFeetPerHour(value); + case FlowUnit.CubicFootPerMinute: + return FromCubicFeetPerMinute(value); case FlowUnit.CubicFootPerSecond: return FromCubicFeetPerSecond(value); case FlowUnit.CubicMeterPerHour: return FromCubicMetersPerHour(value); + case FlowUnit.CubicMeterPerMinute: + return FromCubicMetersPerMinute(value); case FlowUnit.CubicMeterPerSecond: return FromCubicMetersPerSecond(value); + case FlowUnit.CubicYardPerHour: + return FromCubicYardsPerHour(value); + case FlowUnit.CubicYardPerMinute: + return FromCubicYardsPerMinute(value); + case FlowUnit.CubicYardPerSecond: + return FromCubicYardsPerSecond(value); case FlowUnit.DecilitersPerMinute: return FromDecilitersPerMinute(value); case FlowUnit.KilolitersPerMinute: @@ -887,8 +1184,12 @@ public static Flow From(QuantityValue value, FlowUnit fromUnit) return FromNanolitersPerMinute(value); case FlowUnit.OilBarrelsPerDay: return FromOilBarrelsPerDay(value); + case FlowUnit.UsGallonsPerHour: + return FromUsGallonsPerHour(value); case FlowUnit.UsGallonsPerMinute: return FromUsGallonsPerMinute(value); + case FlowUnit.UsGallonsPerSecond: + return FromUsGallonsPerSecond(value); default: throw new NotImplementedException("fromUnit: " + fromUnit); @@ -917,12 +1218,22 @@ public static Flow From(QuantityValue value, FlowUnit fromUnit) return FromCubicDecimetersPerMinute(value.Value); case FlowUnit.CubicFootPerHour: return FromCubicFeetPerHour(value.Value); + case FlowUnit.CubicFootPerMinute: + return FromCubicFeetPerMinute(value.Value); case FlowUnit.CubicFootPerSecond: return FromCubicFeetPerSecond(value.Value); case FlowUnit.CubicMeterPerHour: return FromCubicMetersPerHour(value.Value); + case FlowUnit.CubicMeterPerMinute: + return FromCubicMetersPerMinute(value.Value); case FlowUnit.CubicMeterPerSecond: return FromCubicMetersPerSecond(value.Value); + case FlowUnit.CubicYardPerHour: + return FromCubicYardsPerHour(value.Value); + case FlowUnit.CubicYardPerMinute: + return FromCubicYardsPerMinute(value.Value); + case FlowUnit.CubicYardPerSecond: + return FromCubicYardsPerSecond(value.Value); case FlowUnit.DecilitersPerMinute: return FromDecilitersPerMinute(value.Value); case FlowUnit.KilolitersPerMinute: @@ -943,8 +1254,12 @@ public static Flow From(QuantityValue value, FlowUnit fromUnit) return FromNanolitersPerMinute(value.Value); case FlowUnit.OilBarrelsPerDay: return FromOilBarrelsPerDay(value.Value); + case FlowUnit.UsGallonsPerHour: + return FromUsGallonsPerHour(value.Value); case FlowUnit.UsGallonsPerMinute: return FromUsGallonsPerMinute(value.Value); + case FlowUnit.UsGallonsPerSecond: + return FromUsGallonsPerSecond(value.Value); default: throw new NotImplementedException("fromUnit: " + fromUnit); @@ -1124,12 +1439,22 @@ public double As(FlowUnit unit) return CubicDecimetersPerMinute; case FlowUnit.CubicFootPerHour: return CubicFeetPerHour; + case FlowUnit.CubicFootPerMinute: + return CubicFeetPerMinute; case FlowUnit.CubicFootPerSecond: return CubicFeetPerSecond; case FlowUnit.CubicMeterPerHour: return CubicMetersPerHour; + case FlowUnit.CubicMeterPerMinute: + return CubicMetersPerMinute; case FlowUnit.CubicMeterPerSecond: return CubicMetersPerSecond; + case FlowUnit.CubicYardPerHour: + return CubicYardsPerHour; + case FlowUnit.CubicYardPerMinute: + return CubicYardsPerMinute; + case FlowUnit.CubicYardPerSecond: + return CubicYardsPerSecond; case FlowUnit.DecilitersPerMinute: return DecilitersPerMinute; case FlowUnit.KilolitersPerMinute: @@ -1150,8 +1475,12 @@ public double As(FlowUnit unit) return NanolitersPerMinute; case FlowUnit.OilBarrelsPerDay: return OilBarrelsPerDay; + case FlowUnit.UsGallonsPerHour: + return UsGallonsPerHour; case FlowUnit.UsGallonsPerMinute: return UsGallonsPerMinute; + case FlowUnit.UsGallonsPerSecond: + return UsGallonsPerSecond; default: throw new NotImplementedException("unit: " + unit); diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 1a0537c3df..42586372ad 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1069,6 +1069,11 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "cf/hr"), }), + new CulturesForEnumValue((int) FlowUnit.CubicFootPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "ft³/min"), + }), new CulturesForEnumValue((int) FlowUnit.CubicFootPerSecond, new[] { @@ -1080,12 +1085,32 @@ private static readonly ReadOnlyCollection DefaultLocalization new AbbreviationsForCulture("en-US", "m³/h"), new AbbreviationsForCulture("ru-RU", "м³/ч"), }), + new CulturesForEnumValue((int) FlowUnit.CubicMeterPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "m³/min"), + }), new CulturesForEnumValue((int) FlowUnit.CubicMeterPerSecond, new[] { new AbbreviationsForCulture("en-US", "m³/s"), new AbbreviationsForCulture("ru-RU", "м³/с"), }), + new CulturesForEnumValue((int) FlowUnit.CubicYardPerHour, + new[] + { + new AbbreviationsForCulture("en-US", "yd³/h"), + }), + new CulturesForEnumValue((int) FlowUnit.CubicYardPerMinute, + new[] + { + new AbbreviationsForCulture("en-US", "yd³/min"), + }), + new CulturesForEnumValue((int) FlowUnit.CubicYardPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "yd³/s"), + }), new CulturesForEnumValue((int) FlowUnit.DecilitersPerMinute, new[] { @@ -1137,11 +1162,21 @@ private static readonly ReadOnlyCollection DefaultLocalization { new AbbreviationsForCulture("en-US", "bbl/d", "BOPD"), }), + new CulturesForEnumValue((int) FlowUnit.UsGallonsPerHour, + new[] + { + new AbbreviationsForCulture("en-US", "galUS/h"), + }), new CulturesForEnumValue((int) FlowUnit.UsGallonsPerMinute, new[] { new AbbreviationsForCulture("en-US", "GPM"), }), + new CulturesForEnumValue((int) FlowUnit.UsGallonsPerSecond, + new[] + { + new AbbreviationsForCulture("en-US", "galUS/s"), + }), }), new UnitLocalization(typeof (ForceUnit), new[] diff --git a/UnitsNet/GeneratedCode/Units/FlowUnit.g.cs b/UnitsNet/GeneratedCode/Units/FlowUnit.g.cs index 4deebd7ec6..15d5e9dae8 100644 --- a/UnitsNet/GeneratedCode/Units/FlowUnit.g.cs +++ b/UnitsNet/GeneratedCode/Units/FlowUnit.g.cs @@ -45,9 +45,14 @@ public enum FlowUnit CentilitersPerMinute, CubicDecimeterPerMinute, CubicFootPerHour, + CubicFootPerMinute, CubicFootPerSecond, CubicMeterPerHour, + CubicMeterPerMinute, CubicMeterPerSecond, + CubicYardPerHour, + CubicYardPerMinute, + CubicYardPerSecond, DecilitersPerMinute, KilolitersPerMinute, LitersPerHour, @@ -58,6 +63,8 @@ public enum FlowUnit MillionUsGallonsPerDay, NanolitersPerMinute, OilBarrelsPerDay, + UsGallonsPerHour, UsGallonsPerMinute, + UsGallonsPerSecond, } } diff --git a/UnitsNet/UnitDefinitions/Flow.json b/UnitsNet/UnitDefinitions/Flow.json index 61c5c6dd70..0ed2a69ac8 100644 --- a/UnitsNet/UnitDefinitions/Flow.json +++ b/UnitsNet/UnitDefinitions/Flow.json @@ -18,6 +18,18 @@ "Abbreviations": [ "м³/с" ] } ] + }, + { + "SingularName": "CubicMeterPerMinute", + "PluralName": "CubicMetersPerMinute", + "FromUnitToBaseFunc": "x/60", + "FromBaseToUnitFunc": "x*60", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "m³/min" ] + } + ] }, { "SingularName": "CubicMeterPerHour", @@ -47,6 +59,66 @@ } ] }, + { + "SingularName": "CubicFootPerMinute", + "PluralName": "CubicFeetPerMinute", + "FromUnitToBaseFunc": "x/2118.88000326", + "FromBaseToUnitFunc": "x*2118.88000326", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "ft³/min" ] + } + ] + }, + { + "SingularName": "CubicFootPerHour", + "PluralName": "CubicFeetPerHour", + "FromUnitToBaseFunc": "x*7.8657907199999087346816086183876e-6", + "FromBaseToUnitFunc": "x/7.8657907199999087346816086183876e-6", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "cf/hr" ] + } + ] + }, + { + "SingularName": "CubicYardPerSecond", + "PluralName": "CubicYardsPerSecond", + "FromUnitToBaseFunc": "x*0.764554857984", + "FromBaseToUnitFunc": "x/0.764554857984", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "yd³/s" ] + } + ] + }, + { + "SingularName": "CubicYardPerMinute", + "PluralName": "CubicYardsPerMinute", + "FromUnitToBaseFunc": "x*0.0127425809664", + "FromBaseToUnitFunc": "x/0.0127425809664", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "yd³/min" ] + } + ] + }, + { + "SingularName": "CubicYardPerHour", + "PluralName": "CubicYardsPerHour", + "FromUnitToBaseFunc": "x*2.1237634944E-4", + "FromBaseToUnitFunc": "x/2.1237634944E-4", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "yd³/h" ] + } + ] + }, { "SingularName": "MillionUsGallonsPerDay", "PluralName": "MillionUsGallonsPerDay", @@ -101,6 +173,18 @@ "Abbreviations": [ "л/ч" ] } ] + }, + { + "SingularName": "UsGallonsPerSecond", + "PluralName": "UsGallonsPerSecond", + "FromUnitToBaseFunc": "x/264.1720523581484", + "FromBaseToUnitFunc": "x*264.1720523581484", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "galUS/s" ] + } + ] }, { "SingularName": "UsGallonsPerMinute", @@ -113,6 +197,18 @@ "Abbreviations": [ "GPM" ] } ] + }, + { + "SingularName": "UsGallonsPerHour", + "PluralName": "UsGallonsPerHour", + "FromUnitToBaseFunc": "x/951019.38848933424", + "FromBaseToUnitFunc": "x*951019.38848933424", + "Localization": [ + { + "Culture": "en-US", + "Abbreviations": [ "galUS/h" ] + } + ] }, { "SingularName": "CubicDecimeterPerMinute", @@ -141,18 +237,6 @@ "Abbreviations": [ "bbl/d", "BOPD" ] } ] - }, - { - "SingularName": "CubicFootPerHour", - "PluralName": "CubicFeetPerHour", - "FromUnitToBaseFunc": "x*7.8657907199999087346816086183876e-6", - "FromBaseToUnitFunc": "x/7.8657907199999087346816086183876e-6", - "Localization": [ - { - "Culture": "en-US", - "Abbreviations": [ "cf/hr" ] - } - ] } ] } From 122b921865b582fa3314020354b3cf74081755db Mon Sep 17 00:00:00 2001 From: gojanpaolo Date: Fri, 12 Jan 2018 08:41:37 -0600 Subject: [PATCH 2/2] Consistent Abbreviations Review https://github.com/angularsen/UnitsNet/pull/361#pullrequestreview-88280991 --- UnitsNet/GeneratedCode/UnitSystem.Default.g.cs | 8 ++++---- UnitsNet/UnitDefinitions/Flow.json | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs index 42586372ad..34fe33f4cf 100644 --- a/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs +++ b/UnitsNet/GeneratedCode/UnitSystem.Default.g.cs @@ -1067,7 +1067,7 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) FlowUnit.CubicFootPerHour, new[] { - new AbbreviationsForCulture("en-US", "cf/hr"), + new AbbreviationsForCulture("en-US", "ft³/h", "cf/hr"), }), new CulturesForEnumValue((int) FlowUnit.CubicFootPerMinute, new[] @@ -1165,17 +1165,17 @@ private static readonly ReadOnlyCollection DefaultLocalization new CulturesForEnumValue((int) FlowUnit.UsGallonsPerHour, new[] { - new AbbreviationsForCulture("en-US", "galUS/h"), + new AbbreviationsForCulture("en-US", "gal (U.S.)/h"), }), new CulturesForEnumValue((int) FlowUnit.UsGallonsPerMinute, new[] { - new AbbreviationsForCulture("en-US", "GPM"), + new AbbreviationsForCulture("en-US", "gal (U.S.)/min", "GPM"), }), new CulturesForEnumValue((int) FlowUnit.UsGallonsPerSecond, new[] { - new AbbreviationsForCulture("en-US", "galUS/s"), + new AbbreviationsForCulture("en-US", "gal (U.S.)/s"), }), }), new UnitLocalization(typeof (ForceUnit), diff --git a/UnitsNet/UnitDefinitions/Flow.json b/UnitsNet/UnitDefinitions/Flow.json index 0ed2a69ac8..5a09fe8311 100644 --- a/UnitsNet/UnitDefinitions/Flow.json +++ b/UnitsNet/UnitDefinitions/Flow.json @@ -79,7 +79,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "cf/hr" ] + "Abbreviations": [ "ft³/h", "cf/hr" ] } ] }, @@ -182,7 +182,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "galUS/s" ] + "Abbreviations": [ "gal (U.S.)/s" ] } ] }, @@ -194,7 +194,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "GPM" ] + "Abbreviations": [ "gal (U.S.)/min", "GPM" ] } ] }, @@ -206,7 +206,7 @@ "Localization": [ { "Culture": "en-US", - "Abbreviations": [ "galUS/h" ] + "Abbreviations": [ "gal (U.S.)/h" ] } ] },