Migrated cloning and added UnMapped property.

Author: Oren (electricessence)

Node.Clone.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Diagnostics.Contracts;
+
+namespace Open.Hierarchy
+{
+	public sealed partial class Node<T>
+	{
+
+		/// <summary>
+		/// Clones this node by recreating the tree and copying the values.
+		/// The resultant clone does not belong to any tree (detatched) unless newParentForClone is specified.
+		/// </summary>
+		/// <param name="newParentForClone">
+		/// If a parent is specified it will use that node as its parent.
+		/// By default it ends up being detatched.
+		/// </param>
+		/// <param name="onNodeCloned">A function that recieves the old node and its clone.</param>
+		/// <returns>The copy of the tree/branch.</returns>
+		public Node<T> Clone(
+			Node<T> newParentForClone,
+			Action<Node<T>, Node<T>> onNodeCloned = null)
+		{
+			if (newParentForClone != null && newParentForClone._factory != _factory)
+				throw new ArgumentException("The node being provided for cloning does not belong to this factory.", nameof(newParentForClone));
+			Contract.EndContractBlock();
+
+			AssertNotRecycled();
+
+			var clone = _factory.GetBlankNode();
+			clone.Value = Value;
+			newParentForClone?.Add(clone);
+
+			foreach (var child in _children)
+				clone.Add(child.Clone(clone, onNodeCloned));
+
+			clone.UnMapped = UnMapped;
+
+			onNodeCloned?.Invoke(this, clone);
+
+			return clone;
+		}
+
+		/// <summary>
+		/// Clones a node by recreating the tree and copying the values.
+		/// The resultant clone is detached (is its own root).
+		/// </summary>
+		/// <param name="onNodeCloned">A function that recieves the old node and its clone.</param>
+		/// <returns>The copy of the tree/branch.</returns>
+		public Node<T> Clone(
+			Action<Node<T>, Node<T>> onNodeCloned)
+			=> Clone(null, onNodeCloned);
+
+		/// <summary>
+		/// Create's a clone of the entire tree but only returns the clone of this node.
+		/// </summary>
+		/// <returns>A clone of this node as part of a newly cloned tree.</returns>
+		public Node<T> CloneTree(Node<T> target)
+		{
+			Node<T> node = null;
+			target.Root.Clone((n, clone) =>
+			{
+				if (n == target) node = clone;
+			});
+			return node;
+		}
+
+	}
+}

Node.Factory.cs

@@ -75,67 +75,6 @@ static void PrepareForPool(Node<T> n)
 
 			#endregion
 
-			/// <summary>
-			/// Clones a node by recreating the tree and copying the values.
-			/// </summary>
-			/// <param name="target">The node to replicate.</param>
-			/// <param name="newParentForClone">
-			/// If a parent is specified it will use that node as its parent.
-			/// By default it ends up being detatched.
-			/// </param>
-			/// <param name="onNodeCloned">A function that recieves the old node and its clone.</param>
-			/// <returns>The copy of the tree/branch.</returns>
-			public Node<T> Clone(
-				Node<T> target,
-				Node<T> newParentForClone = null,
-				Action<Node<T>, Node<T>> onNodeCloned = null)
-			{
-				if (target == null) throw new ArgumentNullException(nameof(target));
-				if (target._factory != this)
-					throw new ArgumentException("The node being provided for cloning does not belong to this factory.", nameof(target));
-				if (newParentForClone != null && newParentForClone._factory != this)
-					throw new ArgumentException("The node being provided for cloning does not belong to this factory.", nameof(newParentForClone));
-				Contract.EndContractBlock();
-
-				AssertIsAlive();
-
-				var clone = GetBlankNode();
-				clone.Value = target.Value;
-				newParentForClone?.Add(clone);
-
-				foreach (var child in target._children)
-					clone.Add(Clone(child, clone, onNodeCloned));
-
-				onNodeCloned?.Invoke(target, clone);
-
-				return clone;
-			}
-
-			/// <summary>
-			/// Clones a node by recreating the tree and copying the values.
-			/// </summary>
-			/// <param name="target">The node to replicate.</param>
-			/// <param name="onNodeCloned">A function that recieves the old node and its clone.</param>
-			/// <returns>The copy of the tree/branch.</returns>
-			public Node<T> Clone(
-				Node<T> target,
-				Action<Node<T>, Node<T>> onNodeCloned)
-				=> Clone(target, null, onNodeCloned);
-
-			/// <summary>
-			/// Create's a clone of the entire tree but only returns the clone of this node.
-			/// </summary>
-			/// <returns>A clone of this node as part of a newly cloned tree.</returns>
-			public Node<T> CloneTree(Node<T> target)
-			{
-				Node<T> node = null;
-				Clone(target.Root, (n, clone) =>
-				{
-					if (n == target) node = clone;
-				});
-				return node;
-			}
-
 			/// <summary>
 			/// Generates a full hierarchy if the root is an IParent and uses the root as the value of the hierarchy.
 			/// Essentially building a map of the tree.
@@ -153,7 +92,7 @@ public Node<T> Map<TRoot>(TRoot root)
 
 				// Mapping is deferred and occurs on demand.
 				// If values or children change in the node, mapping is disregarded.
-				current._needsMapping = true;
+				current.UnMapped = true;
 
 
 				return current;

Node.cs

@@ -38,35 +38,41 @@ public T Value
 			set
 			{
 				AssertNotRecycled();
-				_needsMapping = false;
+				UnMapped = false;
 				_value = value;
 			}
 		}
 
 		private readonly Factory _factory;
-		private bool _needsMapping;
+
+		/// <summary>
+		/// Indicates that this node is in a state of deferred mapping.
+		/// Will be false if not created by calling Factory.Map or if the value has been mapped.
+		/// Since querying the chidren of this node will cause the value to be mapped, it can be useful to query this value before attempting traversal.
+		/// </summary>
+		public bool UnMapped { get; private set; }
 
 		IReadOnlyList<Node<T>> EnsureChildrenMapped()
 		{
-			if (!_needsMapping)
+			if (!UnMapped)
 				return _childrenReadOnly;
 
 			// Need to avoid double mapping and this method is primarily called when 'reading' from the node and contention will only occur if mapping is needed.
 			lock (_children)
 			{
-				if (!_needsMapping) return _childrenReadOnly;
+				if (!UnMapped) return _childrenReadOnly;
 				if (_value is IParent<T> p)
 				{
 					foreach (var child in p.Children)
 						_children.Add(_factory.Map(child));
 				}
-				_needsMapping = false;
+				UnMapped = false;
 			}
 
 			return _childrenReadOnly;
 		}
 
-		internal Node(Factory factory)
+		Node(Factory factory)
 		{
 			_factory = factory ?? throw new ArgumentNullException(nameof(factory));
 			_children = new List<Node<T>>();
@@ -97,7 +103,7 @@ public bool Remove(Node<T> node)
 			if (!_children.Remove(node)) return false;
 
 			AssertNotRecycled();
-			_needsMapping = false;
+			UnMapped = false;
 			node.Parent = null; // Need to be very careful about retaining parent references as it may cause a 'leak' per-se.
 			return true;
 		}
@@ -127,7 +133,7 @@ public void Clear()
 			if (_children.Count == 0) return;
 
 			AssertNotRecycled();
-			_needsMapping = false;
+			UnMapped = false;
 			foreach (var c in _children)
 				c.Parent = null;
 			_children.Clear();
@@ -171,7 +177,7 @@ public void Replace(Node<T> node, Node<T> replacement)
 				throw new InvalidOperationException("Node being replaced does not belong to this parent.");
 
 			AssertNotRecycled();
-			_needsMapping = false;
+			UnMapped = false;
 			_children[i] = replacement;
 			node.Parent = null;
 			replacement.Parent = this;
@@ -209,7 +215,7 @@ public Node<T> Root
 		/// </summary>
 		public void Teardown()
 		{
-			_needsMapping = false;
+			UnMapped = false;
 			Value = default;
 			Detatch(); // If no parent then this does nothing...
 			TeardownChildren();
@@ -223,7 +229,7 @@ public void TeardownChildren()
 			if (_children.Count == 0) return;
 
 			AssertNotRecycled();
-			_needsMapping = false;
+			UnMapped = false;
 			foreach (var c in _children)
 			{
 				c.Parent = null; // Don't initiate a 'Detach' (which does a lookup) since we are clearing here;
@@ -239,7 +245,7 @@ public void TeardownChildren()
 		public T Recycle()
 		{
 			AssertNotRecycled(); // Avoid double entry in the pool.
-			_needsMapping = false;
+			UnMapped = false;
 			var value = Value;
 			Value = default;
 			Detatch(); // If no parent then this does nothing...
@@ -254,7 +260,7 @@ public void RecycleChildren()
 		{
 			if (_children.Count == 0) return;
 
-			_needsMapping = false;
+			UnMapped = false;
 			foreach (var c in _children)
 			{
 				c.Parent = null; // Don't initiate a 'Detach' (which does a lookup) since we are clearing here;