/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

* 

* Description:

*

*/

using System;

using System.Collections;

using System.Collections.Generic;

namespace SymbianTree

{

	#region SymNodeEnumeratorSiblings 

	public class SymNodeEnumeratorSiblings : IEnumerator<SymNode>, IEnumerable<SymNode>

	{

		#region Constructors

		public SymNodeEnumeratorSiblings( SymNode aNodeToEnumerate )

		{

			iNode = aNodeToEnumerate;

		}

		#endregion

        #region From IEnumerable<SymNode>

        IEnumerator<SymNode> IEnumerable<SymNode>.GetEnumerator()

        {

            return this;

        }

        IEnumerator IEnumerable.GetEnumerator()

        {

            return this;

        }

        #endregion

		#region IEnumerator Members

		void IEnumerator.Reset()

		{

			iCurrentNode = null;

		}

		object IEnumerator.Current

		{

			get

			{

				return iCurrentNode;

			}

		}

		bool IEnumerator.MoveNext()

		{

			if	( iCurrentNode == null )

			{

				iCurrentNode = iNode;

			}

			else

			{

				iCurrentNode = iCurrentNode.Next;

			}

			bool haveMoreNodes = ( iCurrentNode.Next != null );

			return haveMoreNodes;

		}

		#endregion

        #region From IEnumerator<SymNode>

        SymNode IEnumerator<SymNode>.Current

        {

            get { return iCurrentNode; }

        }

        #endregion

        #region From IDisposable

        public void Dispose()

        {

        }

        #endregion

		#region Data members

		private readonly SymNode iNode;

		private SymNode iCurrentNode = null;

		#endregion

    }

	#endregion

	#region SymNodeEnumeratorChildren 

    public class SymNodeEnumeratorChildren : IEnumerator<SymNode>, IEnumerable<SymNode>

	{

		#region Constructors

		public SymNodeEnumeratorChildren( SymNode aNodeToEnumerate )

		{

			iNode = aNodeToEnumerate;

		}

		#endregion

        #region From IEnumerable<SymNode>

        IEnumerator<SymNode> IEnumerable<SymNode>.GetEnumerator()

        {

            return this;

        }

        IEnumerator IEnumerable.GetEnumerator()

        {

            return this;

        }

        #endregion

		#region IEnumerator Members

		void IEnumerator.Reset()

		{

			iEnumeratorIndex = -1;

		}

		object IEnumerator.Current

		{

			get

			{

				return iNode.Children[ iEnumeratorIndex ];

			}

		}

		bool IEnumerator.MoveNext()

		{

			return ( ++iEnumeratorIndex < iNode.ChildCount );

		}

		#endregion

        #region From IEnumerator<SymNode>

        SymNode IEnumerator<SymNode>.Current

        {

            get { return iNode.Children[ iEnumeratorIndex ]; }

        }

        #endregion

        #region From IDisposable

        public void Dispose()

        {

        }

        #endregion

		#region Data members

		private readonly SymNode iNode;

		private int iEnumeratorIndex = -1;

		#endregion

	}

	#endregion

	#region SymNodeEnumeratorTreeChildrenFirst 

    public class SymNodeEnumeratorTreeChildrenFirst : IEnumerator<SymNode>, IEnumerable<SymNode>

	{

		#region Constructors

		public SymNodeEnumeratorTreeChildrenFirst( SymNode aStartingNode )

		{

			iStartingNode = aStartingNode;

		}

		#endregion

        #region From IEnumerable<SymNode>

        IEnumerator<SymNode> IEnumerable<SymNode>.GetEnumerator()

        {

            return this;

        }

        IEnumerator IEnumerable.GetEnumerator()

        {

            return this;

        }

        #endregion

		#region IEnumerator Members

		void IEnumerator.Reset()

		{

			iCurrentNode = null;

		}

		object IEnumerator.Current

		{

			get

			{

				return iCurrentNode;

			}

		}

		bool IEnumerator.MoveNext()

		{

			iCurrentNode = NextNode( iCurrentNode );

			bool haveMoreNodes = ( NextNode( iCurrentNode ) != null );

			return haveMoreNodes;

		}

		#endregion

        #region From IEnumerator<SymNode>

        SymNode IEnumerator<SymNode>.Current

        {

            get { return iCurrentNode; }

        }

        #endregion

        #region From IDisposable

        public void Dispose()

        {

        }

        #endregion

		#region Internal methods

		private SymNode NextNode( SymNode aCurrentNode )

		{

			SymNode nextNode = null;

			//

			if	( aCurrentNode == null )

			{

				nextNode = iStartingNode;

			}

			else

			{

				#region Example

				//

				//                [A]

				//               /

				//              /

				//            [B]

				//           / | \

				//          /  |  \

				//        [C] [E] [I]

				//       /    / \   \

				//      /    /   \   \

				//    [D]  [F]   [H]  [J]

				//        / 

				//       /

				//     [G]

				//

				// Navigation plan:

				//

				//    [A] -> [B] -> [C] -> [D] -> [E] -> [F] -> [G] -> [H] -> [I] -> [J]

				// 

				#endregion

				if	( aCurrentNode.HasChildren )

				{

					// Try to visit the node's children first.

					nextNode = aCurrentNode.FirstChild;

				}

				else

				{

					// No children...

					if	( aCurrentNode.HasNext )

					{

						// Go to next sibling

						nextNode = aCurrentNode.Next;

					}

					else

					{

						// No (more) siblings - go to parent's next sibling.

						// For example, in the case of the current node being [G]

						// we need to traverse seemlessly to [H]. Therefore

						// we go from [G] -> [F] -> [H]

						nextNode = aCurrentNode.Parent; // [F]

						while( nextNode != null && nextNode.HasNext == false )

						{

							nextNode = nextNode.Parent;

						}

						// We'll now be at [F]

						if	( nextNode != null )

						{

							// Now we'll be at [H]

							nextNode = nextNode.Next;

						}

					}

				}

			}

			//

			return nextNode;

		}

		#endregion

		#region Data members

		private readonly SymNode iStartingNode;

		private SymNode iCurrentNode = null;

		#endregion

	}

	#endregion

	#region SymNodeEnumeratorUpTreeSiblingsFirst

    public class SymNodeEnumeratorUpTreeSiblingsFirst : IEnumerator<SymNode>, IEnumerable<SymNode>

	{

		#region Constructors

		public SymNodeEnumeratorUpTreeSiblingsFirst( SymNode aStartingNode )

		{

			iStartingNode = aStartingNode.FirstSibling;

		}

		#endregion

        #region From IEnumerable<SymNode>

        IEnumerator<SymNode> IEnumerable<SymNode>.GetEnumerator()

        {

            return this;

        }

        IEnumerator IEnumerable.GetEnumerator()

        {

            return this;

        }

        #endregion

		#region IEnumerator Members

		void IEnumerator.Reset()

		{

			iCurrentNode = null;

		}

		object IEnumerator.Current

		{

			get

			{

				return iCurrentNode;

			}

		}

		bool IEnumerator.MoveNext()

		{

			if	( iCurrentNode == null )

			{

				iCurrentNode = iStartingNode;

			}

			else

			{

				if	( iCurrentNode.HasNext )

				{

					iCurrentNode = iCurrentNode.Next;

				}

				else

				{

					iCurrentNode = iCurrentNode.Parent.FirstSibling;

				}

				System.Diagnostics.Debug.Assert( iCurrentNode != null );

			}

			bool haveMoreNodes = iCurrentNode.HasNext;

			if	( haveMoreNodes == false )

			{

				haveMoreNodes = iCurrentNode.HasParent;

			}

			return haveMoreNodes;

		}

		#endregion

        #region From IEnumerator<SymNode>

        SymNode IEnumerator<SymNode>.Current

        {

            get { return iCurrentNode; }

        }

        #endregion

        #region From IDisposable

        public void Dispose()

        {

        }

        #endregion

		#region Data members

		private readonly SymNode iStartingNode;

		private SymNode iCurrentNode = null;

		#endregion

	}

	#endregion

}