Replaced the term "default" with "null" appropriately and removed redundant caching of boolean expressions.

Yeah69 · Yeah69 · commit aca66f06159e · 2017-09-24T23:23:59.000+02:00
Signed-off-by: Dima Enns &lt;dieter.enns@gmail.com&gt;
diff --git a/Sources/LambdaConverters.Wpf/Properties/AssemblyInfo.cs b/Sources/LambdaConverters.Wpf/Properties/AssemblyInfo.cs
@@ -9,7 +9,7 @@
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("LambdaConverters")]
-[assembly: AssemblyCopyright("© 2017 Michael Damatov.")]
+[assembly: AssemblyCopyright("© 2017 Michael Damatov, Dimitri Enns.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
diff --git a/Sources/LambdaConverters.Wpf/RuleErrorStrategy.cs b/Sources/LambdaConverters.Wpf/RuleErrorStrategy.cs
@@ -8,9 +8,9 @@ namespace LambdaConverters
     public enum RuleErrorStrategy
     {
         /// <summary>
-        /// The default of <see cref="ValidationRule" /> is returned.
+        /// Null is returned.
         /// </summary>
-        ReturnDefaultValue,
+        ReturnNull,
 
         /// <summary>
         /// An invalid validation result is returned.
diff --git a/Sources/LambdaConverters.Wpf/SelectorErrorStrategy.cs b/Sources/LambdaConverters.Wpf/SelectorErrorStrategy.cs
@@ -1,7 +1,4 @@
-﻿using System.Windows.Controls;
-using System.Windows.Data;
-
-namespace LambdaConverters
+﻿namespace LambdaConverters
 {
     /// <summary>
     /// Defines the selector error strategy.
@@ -11,7 +8,7 @@ public enum SelectorErrorStrategy
         /// <summary>
         /// Null is returned.
         /// </summary>
-        ReturnDefaultValue,
+        ReturnNull,
 
         /// <summary>
         /// A new and empty data template is returned.
diff --git a/Sources/LambdaConverters.Wpf/TemplateSelector.cs b/Sources/LambdaConverters.Wpf/TemplateSelector.cs
@@ -17,15 +17,13 @@ sealed class Selector<I> : System.Windows.Controls.DataTemplateSelector
 
             SelectorErrorStrategy ErrorStrategy { get; }
 
-            bool IsSelectFunctionAvailable { get; }
-
             [Pure]
-            DataTemplate GetErrorValue(DataTemplate defaultValue)
+            DataTemplate GetErrorValue()
             {
                 switch (ErrorStrategy)
                 {
-                    case SelectorErrorStrategy.ReturnDefaultValue:
-                        return defaultValue;
+                    case SelectorErrorStrategy.ReturnNull:
+                        return null;
 
                     case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:
                         return new DataTemplate();
@@ -40,7 +38,6 @@ internal Selector(
                 SelectorErrorStrategy errorStrategy)
             {
                 ErrorStrategy = errorStrategy;
-                IsSelectFunctionAvailable = selectFunction != null;
 
                 this.selectFunction = selectFunction;
             }
@@ -56,7 +53,7 @@ DataTemplate SelectTemplateInternal(object item, DependencyObject container)
                 {
                     EventSource.Log.UnableToCastToInputType(item?.GetType().Name ?? "null", typeof(I).Name, ErrorStrategy.ToString());
 
-                    return GetErrorValue(default(DataTemplate));
+                    return GetErrorValue();
                 }
 
                 Debug.Assert(selectFunction != null);
@@ -66,11 +63,11 @@ DataTemplate SelectTemplateInternal(object item, DependencyObject container)
 
             public override DataTemplate SelectTemplate(object item, DependencyObject container)
             {
-                if (!IsSelectFunctionAvailable)
+                if (this.selectFunction == null)
                 {
                     EventSource.Log.MissingSelectTemplateFunction("selectFunction", ErrorStrategy.ToString());
 
-                    return GetErrorValue(default(DataTemplate));
+                    return GetErrorValue();
                 }
 
                 return SelectTemplateInternal(item, container);
@@ -91,11 +88,11 @@ public override DataTemplate SelectTemplate(object item, DependencyObject contai
         [NotNull]
         public static DataTemplateSelector Create<I>(
             Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction = null,
-            SelectorErrorStrategy errorStrategy = SelectorErrorStrategy.ReturnDefaultValue)
+            SelectorErrorStrategy errorStrategy = SelectorErrorStrategy.ReturnNull)
         {
             switch (errorStrategy)
             {
-                case SelectorErrorStrategy.ReturnDefaultValue:
+                case SelectorErrorStrategy.ReturnNull:
                 case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:
                     break;
 
diff --git a/Sources/LambdaConverters.Wpf/Validator.cs b/Sources/LambdaConverters.Wpf/Validator.cs
@@ -20,21 +20,18 @@ internal Rule(
                 RuleErrorStrategy errorStrategy)
             {
                 ErrorStrategy = errorStrategy;
-                IsRuleFunctionAvailable = ruleFunction != null;
                 this.ruleFunction = ruleFunction;
             }
 
             RuleErrorStrategy ErrorStrategy { get; }
 
-            bool IsRuleFunctionAvailable { get; }
-
             [Pure]
-            ValidationResult GetErrorValue(ValidationResult defaultValue)
+            ValidationResult GetErrorValue()
             {
                 switch (ErrorStrategy)
                 {
-                    case RuleErrorStrategy.ReturnDefaultValue:
-                        return defaultValue;
+                    case RuleErrorStrategy.ReturnNull:
+                        return null;
 
                     case RuleErrorStrategy.ReturnInvalid:
                         return new ValidationResult(false, null);
@@ -58,7 +55,7 @@ ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)
                 {
                     EventSource.Log.UnableToCastToRuleInputType(item?.GetType().Name ?? "null", typeof(I).Name, ErrorStrategy.ToString());
 
-                    return GetErrorValue(default(ValidationResult));
+                    return GetErrorValue();
                 }
 
                 Debug.Assert(ruleFunction != null);
@@ -68,11 +65,11 @@ ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)
 
             public override ValidationResult Validate(object value, CultureInfo cultureInfo)
             {
-                if (!IsRuleFunctionAvailable)
+                if (this.ruleFunction == null)
                 {
                     EventSource.Log.MissingRuleFunction("ruleFunction", ErrorStrategy.ToString());
 
-                    return GetErrorValue(default(ValidationResult));
+                    return GetErrorValue();
                 }
 
                 return ValidateInternal(value, cultureInfo);
@@ -93,11 +90,11 @@ public override ValidationResult Validate(object value, CultureInfo cultureInfo)
         [NotNull]
         public static ValidationRule Create<I>(
             Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction = null,
-            RuleErrorStrategy errorStrategy = RuleErrorStrategy.ReturnDefaultValue)
+            RuleErrorStrategy errorStrategy = RuleErrorStrategy.ReturnNull)
         {
             switch (errorStrategy)
             {
-                case RuleErrorStrategy.ReturnDefaultValue:
+                case RuleErrorStrategy.ReturnNull:
                 case RuleErrorStrategy.ReturnInvalid:
                 case RuleErrorStrategy.ReturnValid:
                     break;

Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,13 @@ sealed class Selector<I> : System.Windows.Controls.DataTemplateSelector`
`17`	`17`
`18`	`18`	`SelectorErrorStrategy ErrorStrategy { get; }`
`19`	`19`
`20`		`- bool IsSelectFunctionAvailable { get; }`
`21`		`-`
`22`	`20`	`[Pure]`
`23`		`- DataTemplate GetErrorValue(DataTemplate defaultValue)`
	`21`	`+ DataTemplate GetErrorValue()`
`24`	`22`	`{`
`25`	`23`	`switch (ErrorStrategy)`
`26`	`24`	`{`
`27`		`- case SelectorErrorStrategy.ReturnDefaultValue:`
`28`		`- return defaultValue;`
	`25`	`+ case SelectorErrorStrategy.ReturnNull:`
	`26`	`+ return null;`
`29`	`27`
`30`	`28`	`case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:`
`31`	`29`	`return new DataTemplate();`
`@@ -40,7 +38,6 @@ internal Selector(`
`40`	`38`	`SelectorErrorStrategy errorStrategy)`
`41`	`39`	`{`
`42`	`40`	`ErrorStrategy = errorStrategy;`
`43`		`- IsSelectFunctionAvailable = selectFunction != null;`
`44`	`41`
`45`	`42`	`this.selectFunction = selectFunction;`
`46`	`43`	`}`
`@@ -56,7 +53,7 @@ DataTemplate SelectTemplateInternal(object item, DependencyObject container)`
`56`	`53`	`{`
`57`	`54`	`EventSource.Log.UnableToCastToInputType(item?.GetType().Name ?? "null", typeof(I).Name, ErrorStrategy.ToString());`
`58`	`55`
`59`		`- return GetErrorValue(default(DataTemplate));`
	`56`	`+ return GetErrorValue();`
`60`	`57`	`}`
`61`	`58`
`62`	`59`	`Debug.Assert(selectFunction != null);`
`@@ -66,11 +63,11 @@ DataTemplate SelectTemplateInternal(object item, DependencyObject container)`
`66`	`63`
`67`	`64`	`public override DataTemplate SelectTemplate(object item, DependencyObject container)`
`68`	`65`	`{`
`69`		`- if (!IsSelectFunctionAvailable)`
	`66`	`+ if (this.selectFunction == null)`
`70`	`67`	`{`
`71`	`68`	`EventSource.Log.MissingSelectTemplateFunction("selectFunction", ErrorStrategy.ToString());`
`72`	`69`
`73`		`- return GetErrorValue(default(DataTemplate));`
	`70`	`+ return GetErrorValue();`
`74`	`71`	`}`
`75`	`72`
`76`	`73`	`return SelectTemplateInternal(item, container);`
`@@ -91,11 +88,11 @@ public override DataTemplate SelectTemplate(object item, DependencyObject contai`
`91`	`88`	`[NotNull]`
`92`	`89`	`public static DataTemplateSelector Create<I>(`
`93`	`90`	`Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction = null,`
`94`		`- SelectorErrorStrategy errorStrategy = SelectorErrorStrategy.ReturnDefaultValue)`
	`91`	`+ SelectorErrorStrategy errorStrategy = SelectorErrorStrategy.ReturnNull)`
`95`	`92`	`{`
`96`	`93`	`switch (errorStrategy)`
`97`	`94`	`{`
`98`		`- case SelectorErrorStrategy.ReturnDefaultValue:`
	`95`	`+ case SelectorErrorStrategy.ReturnNull:`
`99`	`96`	`case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:`
`100`	`97`	`break;`
`101`	`98`
Original file line number	Diff line number	Diff line change
`@@ -20,21 +20,18 @@ internal Rule(`
`20`	`20`	`RuleErrorStrategy errorStrategy)`
`21`	`21`	`{`
`22`	`22`	`ErrorStrategy = errorStrategy;`
`23`		`- IsRuleFunctionAvailable = ruleFunction != null;`
`24`	`23`	`this.ruleFunction = ruleFunction;`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`RuleErrorStrategy ErrorStrategy { get; }`
`28`	`27`
`29`		`- bool IsRuleFunctionAvailable { get; }`
`30`		`-`
`31`	`28`	`[Pure]`
`32`		`- ValidationResult GetErrorValue(ValidationResult defaultValue)`
	`29`	`+ ValidationResult GetErrorValue()`
`33`	`30`	`{`
`34`	`31`	`switch (ErrorStrategy)`
`35`	`32`	`{`
`36`		`- case RuleErrorStrategy.ReturnDefaultValue:`
`37`		`- return defaultValue;`
	`33`	`+ case RuleErrorStrategy.ReturnNull:`
	`34`	`+ return null;`
`38`	`35`
`39`	`36`	`case RuleErrorStrategy.ReturnInvalid:`
`40`	`37`	`return new ValidationResult(false, null);`
`@@ -58,7 +55,7 @@ ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)`
`58`	`55`	`{`
`59`	`56`	`EventSource.Log.UnableToCastToRuleInputType(item?.GetType().Name ?? "null", typeof(I).Name, ErrorStrategy.ToString());`
`60`	`57`
`61`		`- return GetErrorValue(default(ValidationResult));`
	`58`	`+ return GetErrorValue();`
`62`	`59`	`}`
`63`	`60`
`64`	`61`	`Debug.Assert(ruleFunction != null);`
`@@ -68,11 +65,11 @@ ValidationResult ValidateInternal(object item, CultureInfo cultureInfo)`
`68`	`65`
`69`	`66`	`public override ValidationResult Validate(object value, CultureInfo cultureInfo)`
`70`	`67`	`{`
`71`		`- if (!IsRuleFunctionAvailable)`
	`68`	`+ if (this.ruleFunction == null)`
`72`	`69`	`{`
`73`	`70`	`EventSource.Log.MissingRuleFunction("ruleFunction", ErrorStrategy.ToString());`
`74`	`71`
`75`		`- return GetErrorValue(default(ValidationResult));`
	`72`	`+ return GetErrorValue();`
`76`	`73`	`}`
`77`	`74`
`78`	`75`	`return ValidateInternal(value, cultureInfo);`
`@@ -93,11 +90,11 @@ public override ValidationResult Validate(object value, CultureInfo cultureInfo)`
`93`	`90`	`[NotNull]`
`94`	`91`	`public static ValidationRule Create<I>(`
`95`	`92`	`Func<ValidationRuleArgs<I>, ValidationResult> ruleFunction = null,`
`96`		`- RuleErrorStrategy errorStrategy = RuleErrorStrategy.ReturnDefaultValue)`
	`93`	`+ RuleErrorStrategy errorStrategy = RuleErrorStrategy.ReturnNull)`
`97`	`94`	`{`
`98`	`95`	`switch (errorStrategy)`
`99`	`96`	`{`
`100`		`- case RuleErrorStrategy.ReturnDefaultValue:`
	`97`	`+ case RuleErrorStrategy.ReturnNull:`
`101`	`98`	`case RuleErrorStrategy.ReturnInvalid:`
`102`	`99`	`case RuleErrorStrategy.ReturnValid:`
`103`	`100`	`break;`