/Utilities/Collections/TreeNode.cs

using System.Collections.Generic;



namespace Delta.Utilities.Collections

{

	/// <summary>

	/// Tree node class for tree node collections.

	/// </summary>

	public class TreeNode<T>

	{

		#region Parent (Public)

		/// <summary>

		/// Parent node

		/// </summary>

		/// <typeparam name="T">T</typeparam>

		/// <returns>Tree node</returns>

		public TreeNode<T> Parent

		{

			get

			{

				return mParent;

			}

			internal set

			{

				mParent = value;

			}

		}

		#endregion



		#region Children (Public)

		/// <summary>

		/// Node collection of children

		/// </summary>

		/// <typeparam name="T">T</typeparam>

		/// <returns>Node collection</returns>

		public TreeNodeCollection<T> Children

		{

			get

			{

				return mChildren;

			}

		}

		#endregion



		#region Root (Public)

		/// <summary>

		/// Root node

		/// </summary>

		/// <typeparam name="T">T</typeparam>

		/// <returns>Node</returns>

		public TreeNode<T> Root

		{

			get

			{

				if (null == mParent)

				{

					return this;

				}

				return mParent.Root;

			}

		}

		#endregion



		#region Data (Public)

		/// <summary>

		/// Data

		/// </summary>

		/// <typeparam name="T">T</typeparam>

		/// <returns>Element</returns>

		public T Data

		{

			get

			{

				return mData;

			}

		}

		#endregion



		#region Private



		#region mChildren (Private)

		/// <summary>

		/// M children

		/// </summary>

		/// <typeparam name="T">T</typeparam>

		private readonly TreeNodeCollection<T> mChildren;

		#endregion



		#region mData (Private)

		/// <summary>

		/// M data

		/// </summary>

		/// <returns>T</returns>

		/// <typeparam name="T">T</typeparam>

		private readonly T mData;

		#endregion



		#region mParent (Private)

		/// <summary>

		/// M parent

		/// </summary>

		/// <typeparam name="T">T</typeparam>

		private TreeNode<T> mParent;

		#endregion



		#endregion



		#region Constructors

		/// <summary>

		/// Create tree node

		/// </summary>

		/// <param name="nodedata">Nodedata</param>

		public TreeNode(T nodedata)

		{

			mChildren = new TreeNodeCollection<T>(this);

			mData = nodedata;

		}

		#endregion



		#region IsAncestorOf (Public)

		/// <summary>

		/// Is this node an ancestor of the given rhs node.

		/// </summary>

		/// <param name="rhs">Tree node to check</param>

		/// <returns>

		/// True if the given node is an ancestor (directly or recursively).

		/// </returns>

		public bool IsAncestorOf(TreeNode<T> rhs)

		{

			if (mChildren.Contains(rhs))

			{

				return true;

			}

			foreach (TreeNode<T> kid in mChildren)

			{

				if (kid.IsAncestorOf(rhs))

				{

					return true;

				}

			}

			return false;

		}

		#endregion



		#region IsDescendantOf (Public)

		/// <summary>

		/// Is this node a descendant of the given tree node.

		/// </summary>

		/// <param name="rhs">Tree node to check</param>

		/// <returns>True if we are a descendant of rhs, false otherwise.</returns>

		public bool IsDescendantOf(TreeNode<T> rhs)

		{

			if (null == mParent)

			{

				return false;

			}

			if (rhs == mParent)

			{

				return true;

			}

			return mParent.IsDescendantOf(rhs);

		}

		#endregion



		#region DoesShareHierarchyWith (Public)

		/// <summary>

		/// Does share hierarchy with

		/// </summary>

		/// <param name="rhs">rhs</param>

		/// <returns>

		/// True if we share hierarchy (we are either a parent or child of the

		/// given rhs node). False otherwise (disconnected trees).

		/// </returns>

		public bool DoesShareHierarchyWith(TreeNode<T> rhs)

		{

			if (rhs == this ||

			    IsAncestorOf(rhs) ||

			    IsDescendantOf(rhs))

			{

				return true;

			}

			return false;

		}

		#endregion



		#region GetDepthFirstEnumerator (Public)

		/// <summary>

		/// GetDepthFirstEnumerator

		/// </summary>

		/// <returns>IEnumerator</returns>

		public IEnumerator<T> GetDepthFirstEnumerator()

		{

			yield return mData;

			foreach (TreeNode<T> kid in mChildren)

			{

				IEnumerator<T> kidenumerator = kid.GetDepthFirstEnumerator();

				while (kidenumerator.MoveNext())

				{

					yield return kidenumerator.Current;

				}

			}

		}

		#endregion



		#region GetBreadthFirstEnumerator (Public)

		/// <summary>

		/// GetBreadthFirstEnumerator

		/// </summary>

		/// <returns>IEnumerator</returns>

		public IEnumerator<T> GetBreadthFirstEnumerator()

		{

			Queue<TreeNode<T>> todo = new Queue<TreeNode<T>>();

			todo.Enqueue(this);

			while (0 < todo.Count)

			{

				TreeNode<T> n = todo.Dequeue();

				foreach (TreeNode<T> kid in n.mChildren)

				{

					todo.Enqueue(kid);

				}

				yield return n.mData;

			}

		}

		#endregion

	}

}