// Created on: 1992-08-17
// Created by: Mireille MERCIEN
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NoMoreObject.hxx>

// ----------------------------------------------------------------------
// ----------------------------------------------------------------------

// Purpose: Permits to iterate through an ArbitraryTree so that, from
//          the most left leave, it reads it, then its parent, then in
//          the same order what is on its right.
//          IF theTree is (  A (B (C D E)) F G (H (I J K)))
//          THEN it will read ( C B D E A F I H J K G)

//-------------------------------------------------------------------
// Create
//-------------------------------------------------------------------
PCollection_ATInOrderIterator::PCollection_ATInOrderIterator
         (const Handle(PCollection_HArbitraryTree)& ATree) 
{
   CurrentStack = new PCollection_StackArbitraryTree;			
   if (ATree.IsNull()) {
     HasMore = Standard_False;
   }
   else {
//   ... stop at the last child to the left
     RecursiveAppend( ATree);
     CurrentTree = CurrentStack->Top();                      
     HasMore = Standard_True;
  }
}

//-------------------------------------------------------------------
// More
//-------------------------------------------------------------------
Standard_Boolean PCollection_ATInOrderIterator::More () const
{
  return HasMore;
}

//-------------------------------------------------------------------
// Value
//-------------------------------------------------------------------
Handle(PCollection_HArbitraryTree) 
   PCollection_ATInOrderIterator::Value () const
{
  if (!HasMore) Standard_NoSuchObject::Raise();
  return CurrentTree;
}

//-------------------------------------------------------------------
// Clear
//-------------------------------------------------------------------
void PCollection_ATInOrderIterator::Clear ()
{
  CurrentTree.Nullify();
  CurrentStack.Nullify();
  HasMore = Standard_False;
}

//-------------------------------------------------------------------
// Next
//-------------------------------------------------------------------
void PCollection_ATInOrderIterator::Next ()
{
   if (!HasMore) Standard_NoMoreObject::Raise();
   Handle(PCollection_HArbitraryTree) Temp;
   Standard_Integer Nb = CurrentTree->NbChildren();
   if( Nb > 1) {
//   ... go to the other children (first one already visited)
     Temp = CurrentTree->Child(2);
     RecursiveAppend( Temp);
   }
   else {
//   ... was <CurrentTree> the first child ? 
//   ... If yes, nothing more to do than removing it
//   ... if not, go upward, and on the right as soon as possible
     Temp = RecursiveRemove( CurrentTree);
     Handle(PCollection_HArbitraryTree) Left = Temp->LeftSibling();
     if ( !Left.IsNull()) RecursiveAppend(Temp->RightSibling());
   }
// ... CurrentTree's updating
   if (HasMore) CurrentTree = CurrentStack->Top();         
}

//  INTERNAL TOOLS TO MANAGE CurrentStack

//-------------------------------------------------------------------
//-------------------------------------------------------------------
void PCollection_ATInOrderIterator::RecursiveAppend (
             const Handle(PCollection_HArbitraryTree)& ATree) 
{
   CurrentStack->Push(ATree);
// ... is there still some child ?
   if( !ATree->IsLeaf()) {
     RecursiveAppend(ATree->Child(1));
   }
}


//-------------------------------------------------------------------
//-------------------------------------------------------------------
Handle(PCollection_HArbitraryTree) 
   PCollection_ATInOrderIterator::RecursiveRemove (
                const Handle(PCollection_HArbitraryTree)& ATree) {

   Handle(PCollection_HArbitraryTree) Temp = ATree;
   CurrentStack->Pop();                            
   if( CurrentStack->IsEmpty()) {
//   ... it's the end...
     HasMore = Standard_False;
   }
   else {
//   ... are there other trees to be removed ?
     Handle(PCollection_HArbitraryTree) Left =  ATree->LeftSibling();
     Handle(PCollection_HArbitraryTree) Right = ATree->RightSibling();
     if(!Left.IsNull() && Right.IsNull()) {
//     ... it's still necessary to go upward
       Temp = CurrentStack->Top();           
       Temp = RecursiveRemove( Temp);
     }
   }
   return Temp;  
}