Combined similar type doc node type assertion methods in YamlDocNode and ComposedDocNode

Author: grahamboree

src/DarkConfig/DocNode/ComposedDocNode.cs

@@ -33,23 +33,23 @@ public ComposedDocNode(DocNodeType type, int size = -1, string sourceInformation
         /// access the node as if it was a list
         public override DocNode this[int index] {
             get {
-                CheckTypeIs(DocNodeType.List);
+                AssertTypeIs(DocNodeType.List);
                 return list[index];
             }
             set {
-                CheckTypeIs(DocNodeType.List);
+                AssertTypeIs(DocNodeType.List);
                 list[index] = value;
             }
         }
 
         /// access the node as if it was a Dictionary
         public override DocNode this[string key] {
             get {
-                CheckTypeIs(DocNodeType.Dictionary);
+                AssertTypeIs(DocNodeType.Dictionary);
                 return dictionary[key];
             }
             set {
-                CheckTypeIs(DocNodeType.Dictionary);
+                AssertTypeIs(DocNodeType.Dictionary);
                 dictionary[key] = value;
             }
         }
@@ -58,11 +58,11 @@ public override DocNode this[string key] {
             Type switch {
                 DocNodeType.Dictionary => dictionary.Count,
                 DocNodeType.List => list.Count,
-                _ => throw new DocNodeAccessException(GenerateAccessExceptionMessage("Countable (Dictionary or List)"))
+                _ => throw new DocNodeAccessException(GenerateAccessExceptionMessage("Countable (Dictionary or List)", Type.ToString()))
             };
 
         public override bool ContainsKey(string key, bool ignoreCase = false) {
-            CheckTypeIs(DocNodeType.Dictionary);
+            AssertTypeIs(DocNodeType.Dictionary);
             foreach (string dictKey in dictionary.Keys) {
                 if (string.Equals(dictKey, key, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) {
                     return true;
@@ -72,7 +72,7 @@ public override bool ContainsKey(string key, bool ignoreCase = false) {
         }
 
         public override bool TryGetValue(string key, bool ignoreCase, out DocNode result) {
-            CheckTypeIs(DocNodeType.Dictionary);
+            AssertTypeIs(DocNodeType.Dictionary);
             foreach (var kvp in dictionary) {
                 if (string.Equals(kvp.Key, key, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)) {
                     result = kvp.Value;
@@ -86,25 +86,25 @@ public override bool TryGetValue(string key, bool ignoreCase, out DocNode result
 
         public override IEnumerable<DocNode> Values {
             get {
-                CheckTypeIs(DocNodeType.List);
+                AssertTypeIs(DocNodeType.List);
                 return list;
             }
         }
 
         public override IEnumerable<KeyValuePair<string, DocNode>> Pairs {
             get {
-                CheckTypeIs(DocNodeType.Dictionary);
+                AssertTypeIs(DocNodeType.Dictionary);
                 return dictionary;
             }
         }
 
         public override string StringValue {
             get {
-                CheckTypeIs(DocNodeType.Scalar);
+                AssertTypeIs(DocNodeType.Scalar);
                 return scalar;
             }
             set {
-                CheckTypeIs(DocNodeType.Scalar);
+                AssertTypeIs(DocNodeType.Scalar);
                 scalar = value;
             }
         }
@@ -119,32 +119,32 @@ public override string ToString() {
         #endregion
 
         public void Add(DocNode d) {
-            CheckTypeIs(DocNodeType.List);
+            AssertTypeIs(DocNodeType.List);
             list.Add(d);
         }
 
         public void Add(string key, DocNode value) {
-            CheckTypeIs(DocNodeType.Dictionary);
+            AssertTypeIs(DocNodeType.Dictionary);
             dictionary.Add(key, value);
         }
 
         public void InsertAt(int index, DocNode value) {
-            CheckTypeIs(DocNodeType.List);
+            AssertTypeIs(DocNodeType.List);
             list.Insert(index, value);
         }
 
         public void Remove(DocNode d) {
-            CheckTypeIs(DocNodeType.List);
+            AssertTypeIs(DocNodeType.List);
             list.Remove(d);
         }
 
         public void RemoveAt(int index) {
-            CheckTypeIs(DocNodeType.List);
+            AssertTypeIs(DocNodeType.List);
             list.RemoveAt(index);
         }
 
         public void RemoveKey(string key) {
-            CheckTypeIs(DocNodeType.Dictionary);
+            AssertTypeIs(DocNodeType.Dictionary);
             dictionary.Remove(key);
         }
 
@@ -205,17 +205,5 @@ public static ComposedDocNode MakeMutableRef(ref DocNode doc, bool recursive = t
         public static ComposedDocNode DeepClone(DocNode doc) {
             return MakeMutable(doc, recursive: true, force: true);
         }
-
-        /////////////////////////////////////////////////
-
-        void CheckTypeIs(DocNodeType requiredType) {
-            if (Type != requiredType) {
-                throw new DocNodeAccessException(GenerateAccessExceptionMessage(requiredType.ToString()));
-            }
-        }
-
-        string GenerateAccessExceptionMessage(string expectedType) {
-            return $"Accessing ComposedDocNode as {expectedType} but is {Type}. ";
-        }
     }
 }

src/DarkConfig/DocNode/DocNode.cs

@@ -71,9 +71,7 @@ public T As<T>(ReificationOptions? options = null) {
         /// <returns>True if the string exists in this list</returns>
         /// <exception cref="DocNodeAccessException">Thrown if this is not a list</exception>
         public bool Contains(string item) {
-            if (Type != DocNodeType.List) {
-                throw new DocNodeAccessException("Expected List, is " + Type);
-            }
+            AssertTypeIs(DocNodeType.List);
 
             for (int i = 0; i < Count; i++) {
                 if (this[i].StringValue == item) {
@@ -207,5 +205,15 @@ public static DocNode DeepMerge(DocNode lhs, DocNode rhs) {
                 default: throw new ArgumentException($"Can't merge doc nodes of type {lhs.Type}");
             }
         }
+
+        ////////////////////////////////////////////
+
+        protected void AssertTypeIs(DocNodeType type) {
+            if (Type != type) {
+                throw new DocNodeAccessException(GenerateAccessExceptionMessage(type.ToString(), Type.ToString()));
+            }
+        }
+
+        protected string GenerateAccessExceptionMessage(string expectedType, string actualType) => $"Accessing DocNode as {expectedType} but is {actualType}. {SourceInformation}";
     }
 }

src/DarkConfig/DocNode/YamlDocNode.cs

@@ -164,17 +164,5 @@ public override string StringValue {
 
         public override YamlNode SourceNode  { get; }
         public override string SourceFile { get; }
-
-        ////////////////////////////////////////////
-
-        void AssertTypeIs(DocNodeType type) {
-            if (Type != type) {
-                throw new DocNodeAccessException(GenerateAccessExceptionMessage(type.ToString(), Type.ToString()));
-            }
-        }
-
-        string GenerateAccessExceptionMessage(string expectedType, string actualType) {
-            return $"Accessing YamlDocNode as {expectedType} but is {actualType}. {SourceInformation}";
-        }
     }
 }