From d6e5449ef00438692a5c69afcd377373a60b08b4 Mon Sep 17 00:00:00 2001 From: MemeMan <52583316+imememani@users.noreply.github.com> Date: Wed, 6 Dec 2023 18:08:47 +0000 Subject: [PATCH 1/5] Clean up / Linq removal Cleaned up the methods and added more up to date .NET syntax as well as removing the usage of LINQ. --- .../src/Converters/EasingTypeConverter.cs | 110 +++++++++--------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/src/Core/src/Converters/EasingTypeConverter.cs b/src/Core/src/Converters/EasingTypeConverter.cs index 2df10249bbe1..10b259ce1417 100644 --- a/src/Core/src/Converters/EasingTypeConverter.cs +++ b/src/Core/src/Converters/EasingTypeConverter.cs @@ -1,7 +1,6 @@ using System; using System.ComponentModel; using System.Globalization; -using System.Linq; using System.Reflection; using static Microsoft.Maui.Easing; @@ -25,40 +24,50 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c if (string.IsNullOrWhiteSpace(strValue)) return null; - strValue = strValue?.Trim() ?? ""; - var parts = strValue.Split('.'); + var parts = (strValue = strValue.Trim().ToLowerInvariant()).Split('.'); if (parts.Length == 2 && parts[0] == nameof(Easing)) strValue = parts[parts.Length - 1]; - if (strValue.Equals(nameof(Linear), StringComparison.OrdinalIgnoreCase)) - return Linear; - if (strValue.Equals(nameof(SinIn), StringComparison.OrdinalIgnoreCase)) - return SinIn; - if (strValue.Equals(nameof(SinOut), StringComparison.OrdinalIgnoreCase)) - return SinOut; - if (strValue.Equals(nameof(SinInOut), StringComparison.OrdinalIgnoreCase)) - return SinInOut; - if (strValue.Equals(nameof(CubicIn), StringComparison.OrdinalIgnoreCase)) - return CubicIn; - if (strValue.Equals(nameof(CubicOut), StringComparison.OrdinalIgnoreCase)) - return CubicOut; - if (strValue.Equals(nameof(CubicInOut), StringComparison.OrdinalIgnoreCase)) - return CubicInOut; - if (strValue.Equals(nameof(BounceIn), StringComparison.OrdinalIgnoreCase)) - return BounceIn; - if (strValue.Equals(nameof(BounceOut), StringComparison.OrdinalIgnoreCase)) - return BounceOut; - if (strValue.Equals(nameof(SpringIn), StringComparison.OrdinalIgnoreCase)) - return SpringIn; - if (strValue.Equals(nameof(SpringOut), StringComparison.OrdinalIgnoreCase)) - return SpringOut; - - var fallbackValue = typeof(Easing) - .GetTypeInfo() - .DeclaredFields - .FirstOrDefault(f => f.Name.Equals(strValue, StringComparison.OrdinalIgnoreCase)) - ?.GetValue(null); + switch (easing) + { + case nameof(Linear): + return nameof(Linear); + case nameof(SinIn): + return nameof(SinIn); + case nameof(SinOut): + return nameof(SinOut); + case nameof(SinInOut): + return nameof(SinInOut); + case nameof(CubicIn): + return nameof(CubicIn); + case nameof(CubicOut): + return nameof(CubicOut); + case nameof(CubicInOut): + return nameof(CubicInOut); + case nameof(BounceIn): + return nameof(BounceIn); + case nameof(BounceOut): + return nameof(BounceOut); + case nameof(SpringIn): + return nameof(SpringIn); + case nameof(SpringOut): + return nameof(SpringOut); + } + + var delcaredFields = typeof(Easing) + .GetTypeInfo() + .DeclaredFields; + + var fallbackValue = null; + for (int i = 0; i < delcaredFields.Length; i++) + { + if (delcaredFields[i].Name.Equals(strValue, StringComparison.OrdinalIgnoreCase)) + { + fallbackValue = delcaredFields[i].GetValue(null); + break; + } + } if (fallbackValue is Easing fallbackEasing) return fallbackEasing; @@ -71,30 +80,21 @@ public override object ConvertTo(ITypeDescriptorContext context, CultureInfo cul if (value is not Easing easing) throw new NotSupportedException(); - if (easing == Linear) - return nameof(Linear); - if (easing == SinIn) - return nameof(SinIn); - if (easing == SinOut) - return nameof(SinOut); - if (easing == SinInOut) - return nameof(SinInOut); - if (easing == CubicIn) - return nameof(CubicIn); - if (easing == CubicOut) - return nameof(CubicOut); - if (easing == CubicInOut) - return nameof(CubicInOut); - if (easing == BounceIn) - return nameof(BounceIn); - if (easing == BounceOut) - return nameof(BounceOut); - if (easing == SpringIn) - return nameof(SpringIn); - if (easing == SpringOut) - return nameof(SpringOut); - - throw new NotSupportedException(); + return easing switch + { + nameof(Linear) => nameof(Linear), + nameof(SinIn) => nameof(SinIn), + nameof(SinOut) => nameof(SinOut), + nameof(SinInOut) => nameof(SinInOut), + nameof(CubicIn) => nameof(CubicIn), + nameof(CubicOut) => nameof(CubicOut), + nameof(CubicInOut) => nameof(CubicInOut), + nameof(BounceIn) => nameof(BounceIn), + nameof(BounceOut) => nameof(BounceOut), + nameof(SpringIn) => nameof(SpringIn), + nameof(SpringOut) => nameof(SpringOut), + _ => throw new NotSupportedException(), + }; } public override bool GetStandardValuesSupported(ITypeDescriptorContext context) From 14d0e1924cebe8f9e7f6bd380d051673140b9747 Mon Sep 17 00:00:00 2001 From: MemeMan <52583316+imememani@users.noreply.github.com> Date: Wed, 6 Dec 2023 18:14:12 +0000 Subject: [PATCH 2/5] Removed ToLowerInvariant As the switch makes use of nameof the usage of ToLowerInvariant is redundant. --- src/Core/src/Converters/EasingTypeConverter.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Core/src/Converters/EasingTypeConverter.cs b/src/Core/src/Converters/EasingTypeConverter.cs index 10b259ce1417..60dc32c2fd6c 100644 --- a/src/Core/src/Converters/EasingTypeConverter.cs +++ b/src/Core/src/Converters/EasingTypeConverter.cs @@ -24,7 +24,7 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c if (string.IsNullOrWhiteSpace(strValue)) return null; - var parts = (strValue = strValue.Trim().ToLowerInvariant()).Split('.'); + var parts = (strValue = strValue.Trim()).Split('.'); if (parts.Length == 2 && parts[0] == nameof(Easing)) strValue = parts[parts.Length - 1]; @@ -118,4 +118,4 @@ public override StandardValuesCollection GetStandardValues(ITypeDescriptorContex "SpringOut" }); } -} \ No newline at end of file +} From eb17a463dd819520989aa0a0d8897b96aadb057a Mon Sep 17 00:00:00 2001 From: MemeMan <52583316+imememani@users.noreply.github.com> Date: Sun, 10 Dec 2023 18:07:28 +0000 Subject: [PATCH 3/5] Fix return value / further improvements The value now returns an easing instead of a string (oops!), I have also implemented a local method to check case sensitive strings for the switch statement allowing the same functionality as previous. --- .../src/Converters/EasingTypeConverter.cs | 69 ++++++++++--------- 1 file changed, 36 insertions(+), 33 deletions(-) diff --git a/src/Core/src/Converters/EasingTypeConverter.cs b/src/Core/src/Converters/EasingTypeConverter.cs index 60dc32c2fd6c..74c135c84005 100644 --- a/src/Core/src/Converters/EasingTypeConverter.cs +++ b/src/Core/src/Converters/EasingTypeConverter.cs @@ -11,6 +11,7 @@ namespace Microsoft.Maui.Converters /// public class EasingTypeConverter : TypeConverter { + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) => sourceType == typeof(string); @@ -31,29 +32,30 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c switch (easing) { - case nameof(Linear): - return nameof(Linear); - case nameof(SinIn): - return nameof(SinIn); - case nameof(SinOut): - return nameof(SinOut); - case nameof(SinInOut): - return nameof(SinInOut); - case nameof(CubicIn): - return nameof(CubicIn); - case nameof(CubicOut): - return nameof(CubicOut); - case nameof(CubicInOut): - return nameof(CubicInOut); - case nameof(BounceIn): - return nameof(BounceIn); - case nameof(BounceOut): - return nameof(BounceOut); - case nameof(SpringIn): - return nameof(SpringIn); - case nameof(SpringOut): - return nameof(SpringOut); + case _ when Compare(strValue, Linear): + return Linear; + case _ when Compare(strValue, SinIn): + return SinIn; + case _ when Compare(strValue, SinOut): + return SinOut; + case _ when Compare(strValue, SinInOut): + return SinInOut; + case _ when Compare(strValue, CubicIn): + return CubicIn; + case _ when Compare(strValue, CubicOut): + return CubicOut; + case _ when Compare(strValue, CubicInOut): + return CubicInOut; + case _ when Compare(strValue, BounceIn): + return BounceIn; + case _ when Compare(strValue, BounceOut): + return BounceOut; + case _ when Compare(strValue, SpringIn): + return SpringIn; + case _ when Compare(strValue, SpringOut): + return SpringOut; } + bool Compare(string left, string right) => left.Equals(right, StringComparison.InvariantCultureIgnoreCase); var delcaredFields = typeof(Easing) .GetTypeInfo() @@ -73,6 +75,7 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c return fallbackEasing; throw new InvalidOperationException($"Cannot convert \"{strValue}\" into {typeof(Easing)}"); + } public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) @@ -82,17 +85,17 @@ public override object ConvertTo(ITypeDescriptorContext context, CultureInfo cul return easing switch { - nameof(Linear) => nameof(Linear), - nameof(SinIn) => nameof(SinIn), - nameof(SinOut) => nameof(SinOut), - nameof(SinInOut) => nameof(SinInOut), - nameof(CubicIn) => nameof(CubicIn), - nameof(CubicOut) => nameof(CubicOut), - nameof(CubicInOut) => nameof(CubicInOut), - nameof(BounceIn) => nameof(BounceIn), - nameof(BounceOut) => nameof(BounceOut), - nameof(SpringIn) => nameof(SpringIn), - nameof(SpringOut) => nameof(SpringOut), + _ when easing.Equals(Linear) => nameof(Linear), + _ when easing.Equals(SinIn) => nameof(SinIn), + _ when easing.Equals(SinOut) => nameof(SinOut), + _ when easing.Equals(SinInOut) => nameof(SinInOut), + _ when easing.Equals(CubicIn) => nameof(CubicIn), + _ when easing.Equals(CubicOut) => nameof(CubicOut), + _ when easing.Equals(CubicInOut) => nameof(CubicInOut), + _ when easing.Equals(BounceIn) => nameof(BounceIn), + _ when easing.Equals(BounceOut) => nameof(BounceOut), + _ when easing.Equals(SpringIn) => nameof(SpringIn), + _ when easing.Equals(SpringOut) => nameof(SpringOut), _ => throw new NotSupportedException(), }; } From c9038632ed447e3f0f7bef5064cfcd47aa6b3fc3 Mon Sep 17 00:00:00 2001 From: Matthew Leibowitz Date: Thu, 6 Jun 2024 23:12:30 +0800 Subject: [PATCH 4/5] Tests --- .../src/Converters/EasingTypeConverter.cs | 74 ++++++------------- .../UnitTests/Animations}/EasingTests.cs | 74 +++++++++++++++++-- src/Core/tests/UnitTests/TestCategory.cs | 1 + 3 files changed, 91 insertions(+), 58 deletions(-) rename src/{Controls/tests/Core.UnitTests => Core/tests/UnitTests/Animations}/EasingTests.cs (70%) diff --git a/src/Core/src/Converters/EasingTypeConverter.cs b/src/Core/src/Converters/EasingTypeConverter.cs index 74c135c84005..0263d568efb7 100644 --- a/src/Core/src/Converters/EasingTypeConverter.cs +++ b/src/Core/src/Converters/EasingTypeConverter.cs @@ -1,7 +1,6 @@ using System; using System.ComponentModel; using System.Globalization; -using System.Reflection; using static Microsoft.Maui.Easing; #nullable disable @@ -11,7 +10,6 @@ namespace Microsoft.Maui.Converters /// public class EasingTypeConverter : TypeConverter { - public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) => sourceType == typeof(string); @@ -20,62 +18,36 @@ public override bool CanConvertTo(ITypeDescriptorContext context, Type destinati public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { - var strValue = value?.ToString(); - - if (string.IsNullOrWhiteSpace(strValue)) + if (value is null) return null; - var parts = (strValue = strValue.Trim()).Split('.'); + var strValue = value as string ?? value.ToString(); - if (parts.Length == 2 && parts[0] == nameof(Easing)) - strValue = parts[parts.Length - 1]; - - switch (easing) - { - case _ when Compare(strValue, Linear): - return Linear; - case _ when Compare(strValue, SinIn): - return SinIn; - case _ when Compare(strValue, SinOut): - return SinOut; - case _ when Compare(strValue, SinInOut): - return SinInOut; - case _ when Compare(strValue, CubicIn): - return CubicIn; - case _ when Compare(strValue, CubicOut): - return CubicOut; - case _ when Compare(strValue, CubicInOut): - return CubicInOut; - case _ when Compare(strValue, BounceIn): - return BounceIn; - case _ when Compare(strValue, BounceOut): - return BounceOut; - case _ when Compare(strValue, SpringIn): - return SpringIn; - case _ when Compare(strValue, SpringOut): - return SpringOut; - } - bool Compare(string left, string right) => left.Equals(right, StringComparison.InvariantCultureIgnoreCase); + if (string.IsNullOrWhiteSpace(strValue)) + return null; - var delcaredFields = typeof(Easing) - .GetTypeInfo() - .DeclaredFields; + var parts = strValue.Split('.'); + if (parts.Length == 2 && Compare(parts[0], nameof(Easing))) + strValue = parts[1]; - var fallbackValue = null; - for (int i = 0; i < delcaredFields.Length; i++) + return strValue switch { - if (delcaredFields[i].Name.Equals(strValue, StringComparison.OrdinalIgnoreCase)) - { - fallbackValue = delcaredFields[i].GetValue(null); - break; - } - } - - if (fallbackValue is Easing fallbackEasing) - return fallbackEasing; - - throw new InvalidOperationException($"Cannot convert \"{strValue}\" into {typeof(Easing)}"); + _ when Compare(strValue, nameof(Linear)) => Linear, + _ when Compare(strValue, nameof(SinIn)) => SinIn, + _ when Compare(strValue, nameof(SinOut)) => SinOut, + _ when Compare(strValue, nameof(SinInOut)) => SinInOut, + _ when Compare(strValue, nameof(CubicIn)) => CubicIn, + _ when Compare(strValue, nameof(CubicOut)) => CubicOut, + _ when Compare(strValue, nameof(CubicInOut)) => CubicInOut, + _ when Compare(strValue, nameof(BounceIn)) => BounceIn, + _ when Compare(strValue, nameof(BounceOut)) => BounceOut, + _ when Compare(strValue, nameof(SpringIn)) => SpringIn, + _ when Compare(strValue, nameof(SpringOut)) => SpringOut, + _ => throw new InvalidOperationException($"Cannot convert \"{strValue}\" into {typeof(Easing)}") + }; + static bool Compare(string left, string right) => + left.Equals(right, StringComparison.OrdinalIgnoreCase); } public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) diff --git a/src/Controls/tests/Core.UnitTests/EasingTests.cs b/src/Core/tests/UnitTests/Animations/EasingTests.cs similarity index 70% rename from src/Controls/tests/Core.UnitTests/EasingTests.cs rename to src/Core/tests/UnitTests/Animations/EasingTests.cs index 23b63e7ff126..ecf9baaab278 100644 --- a/src/Controls/tests/Core.UnitTests/EasingTests.cs +++ b/src/Core/tests/UnitTests/Animations/EasingTests.cs @@ -2,12 +2,19 @@ using Microsoft.Maui.Converters; using Xunit; -namespace Microsoft.Maui.Controls.Core.UnitTests +namespace Microsoft.Maui.UnitTests { - - public class EasingTests : BaseTestFixture + [Category(TestCategory.Animations)] + public class EasingTests { - [Theory, MemberData(nameof(TestDataHelpers.Range), 0, 10, 1, MemberType = typeof(TestDataHelpers))] + [Theory] + [InlineData(0.0)] + [InlineData(1.0)] + [InlineData(2.0)] + [InlineData(5.0)] + [InlineData(8.0)] + [InlineData(9.0)] + [InlineData(10.0)] public void Linear(double input) { Assert.Equal(input, Easing.Linear.Ease(input)); @@ -19,6 +26,7 @@ public void Linear(double input) public void AllRunFromZeroToOne(double val) { const double epsilon = 0.001; + Assert.True(Math.Abs(val - Easing.Linear.Ease(val)) < epsilon); Assert.True(Math.Abs(val - Easing.BounceIn.Ease(val)) < epsilon); Assert.True(Math.Abs(val - Easing.BounceOut.Ease(val)) < epsilon); @@ -33,45 +41,97 @@ public void AllRunFromZeroToOne(double val) } [Fact] - public void TestEasingTypeConverter() + public void CanConvert() { var converter = new EasingTypeConverter(); + Assert.True(converter.CanConvertFrom(typeof(string))); - Assert.Null(converter.ConvertFromInvariantString(null)); - Assert.Null(converter.ConvertFromInvariantString(string.Empty)); + } + + [Theory] + [InlineData(null)] + [InlineData("")] + [InlineData(" ")] + public void NonTextEasingsAreNull(string input) + { + var converter = new EasingTypeConverter(); + + Assert.Null(converter.ConvertFromInvariantString(input)); + } + + [Fact] + public void CanConvertFromEasingNameToEasing() + { + var converter = new EasingTypeConverter(); + Assert.Equal(Easing.Linear, converter.ConvertFromInvariantString("Linear")); Assert.Equal(Easing.Linear, converter.ConvertFromInvariantString("linear")); Assert.Equal(Easing.Linear, converter.ConvertFromInvariantString("Easing.Linear")); + Assert.Equal(Easing.SinOut, converter.ConvertFromInvariantString("SinOut")); Assert.Equal(Easing.SinOut, converter.ConvertFromInvariantString("sinout")); Assert.Equal(Easing.SinOut, converter.ConvertFromInvariantString("Easing.SinOut")); + Assert.Equal(Easing.SinIn, converter.ConvertFromInvariantString("SinIn")); Assert.Equal(Easing.SinIn, converter.ConvertFromInvariantString("sinin")); Assert.Equal(Easing.SinIn, converter.ConvertFromInvariantString("Easing.SinIn")); + Assert.Equal(Easing.SinInOut, converter.ConvertFromInvariantString("SinInOut")); Assert.Equal(Easing.SinInOut, converter.ConvertFromInvariantString("sininout")); Assert.Equal(Easing.SinInOut, converter.ConvertFromInvariantString("Easing.SinInOut")); + Assert.Equal(Easing.CubicOut, converter.ConvertFromInvariantString("CubicOut")); Assert.Equal(Easing.CubicOut, converter.ConvertFromInvariantString("cubicout")); Assert.Equal(Easing.CubicOut, converter.ConvertFromInvariantString("Easing.CubicOut")); + Assert.Equal(Easing.CubicIn, converter.ConvertFromInvariantString("CubicIn")); Assert.Equal(Easing.CubicIn, converter.ConvertFromInvariantString("cubicin")); Assert.Equal(Easing.CubicIn, converter.ConvertFromInvariantString("Easing.CubicIn")); + Assert.Equal(Easing.CubicInOut, converter.ConvertFromInvariantString("CubicInOut")); Assert.Equal(Easing.CubicInOut, converter.ConvertFromInvariantString("cubicinout")); Assert.Equal(Easing.CubicInOut, converter.ConvertFromInvariantString("Easing.CubicInOut")); + Assert.Equal(Easing.BounceOut, converter.ConvertFromInvariantString("BounceOut")); Assert.Equal(Easing.BounceOut, converter.ConvertFromInvariantString("bounceout")); Assert.Equal(Easing.BounceOut, converter.ConvertFromInvariantString("Easing.BounceOut")); + Assert.Equal(Easing.BounceIn, converter.ConvertFromInvariantString("BounceIn")); Assert.Equal(Easing.BounceIn, converter.ConvertFromInvariantString("bouncein")); Assert.Equal(Easing.BounceIn, converter.ConvertFromInvariantString("Easing.BounceIn")); + Assert.Equal(Easing.SpringOut, converter.ConvertFromInvariantString("SpringOut")); Assert.Equal(Easing.SpringOut, converter.ConvertFromInvariantString("springout")); Assert.Equal(Easing.SpringOut, converter.ConvertFromInvariantString("Easing.SpringOut")); + Assert.Equal(Easing.SpringIn, converter.ConvertFromInvariantString("SpringIn")); Assert.Equal(Easing.SpringIn, converter.ConvertFromInvariantString("springin")); Assert.Equal(Easing.SpringIn, converter.ConvertFromInvariantString("Easing.SpringIn")); + } + + [Fact] + public void CanConvertFromEasingToEasingName() + { + var converter = new EasingTypeConverter(); + + Assert.Equal("Linear", converter.ConvertToInvariantString(Easing.Linear)); + Assert.Equal("SinOut", converter.ConvertToInvariantString(Easing.SinOut)); + Assert.Equal("SinIn", converter.ConvertToInvariantString(Easing.SinIn)); + Assert.Equal("SinInOut", converter.ConvertToInvariantString(Easing.SinInOut)); + Assert.Equal("CubicOut", converter.ConvertToInvariantString(Easing.CubicOut)); + Assert.Equal("CubicIn", converter.ConvertToInvariantString(Easing.CubicIn)); + Assert.Equal("CubicInOut", converter.ConvertToInvariantString(Easing.CubicInOut)); + Assert.Equal("BounceOut", converter.ConvertToInvariantString(Easing.BounceOut)); + Assert.Equal("BounceIn", converter.ConvertToInvariantString(Easing.BounceIn)); + Assert.Equal("SpringOut", converter.ConvertToInvariantString(Easing.SpringOut)); + Assert.Equal("SpringIn", converter.ConvertToInvariantString(Easing.SpringIn)); + } + + [Fact] + public void InvalidEasingNamesThrow() + { + var converter = new EasingTypeConverter(); + Assert.Throws(() => converter.ConvertFromInvariantString("WrongEasingName")); Assert.Throws(() => converter.ConvertFromInvariantString("Easing.Linear.SinInOut")); } diff --git a/src/Core/tests/UnitTests/TestCategory.cs b/src/Core/tests/UnitTests/TestCategory.cs index e0c37af7ec0d..b774f9a5b593 100644 --- a/src/Core/tests/UnitTests/TestCategory.cs +++ b/src/Core/tests/UnitTests/TestCategory.cs @@ -2,6 +2,7 @@ namespace Microsoft.Maui.UnitTests { public static class TestCategory { + public const string Animations = "Animations"; public const string Core = "Core"; public const string CommandMapping = "CommandMapping"; public const string Layout = "Layout"; From fe7627537e047460bdf4566e296c9ae4d4c17bca Mon Sep 17 00:00:00 2001 From: Matthew Leibowitz Date: Thu, 6 Jun 2024 23:24:45 +0800 Subject: [PATCH 5/5] Update EasingTypeConverter.cs --- src/Core/src/Converters/EasingTypeConverter.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Core/src/Converters/EasingTypeConverter.cs b/src/Core/src/Converters/EasingTypeConverter.cs index 0263d568efb7..04f762d1623d 100644 --- a/src/Core/src/Converters/EasingTypeConverter.cs +++ b/src/Core/src/Converters/EasingTypeConverter.cs @@ -93,4 +93,4 @@ public override StandardValuesCollection GetStandardValues(ITypeDescriptorContex "SpringOut" }); } -} +} \ No newline at end of file