// Created on: 1992-08-13
// 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   root, it reads each   element  on the left,
//          until  the first leave, then  goes to its rightSibling
//          and upward.  
//          IF theTree is ( A (B (C D E)) F G (H (I J K))) 
//          THEN it will read ( A B C D E F G H I J K)

// -----------
// constructor :
// -----------
PCollection_ATPreOrderIterator::
       PCollection_ATPreOrderIterator
         (const Handle(PCollection_HArbitraryTree)& ATree) 
{
   CurrentStack = new PCollection_StackArbitraryTree;
   if (ATree.IsNull()) {
     HasMore = Standard_False;
   }
   else {
     HasMore = Standard_True;
     CurrentTree = ATree;
     CurrentStack->Push(ATree);
   }           
} 

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

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

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

// --------
// Next
// --------
void PCollection_ATPreOrderIterator::Next() 
{
   if (!HasMore) Standard_NoMoreObject::Raise();
   Handle(PCollection_HArbitraryTree) Temp;
   if (CurrentTree->IsLeaf()) {
//   ... no child, so go upward, then to the right 
     Temp = RecursiveRemove( CurrentTree);
//   ... and adds the right neighbour of the last removed tree
      if ( HasMore) {
        CurrentTree = Temp->RightSibling();
        CurrentStack->Push(CurrentTree);      
      }
   }
   else {
// ... just go down for one step
   CurrentTree = CurrentTree->Child(1);
   CurrentStack->Push(CurrentTree); 
   }
}


// PRIVATE TOOLS TO MANAGE CURRENTSTACK

Handle(PCollection_HArbitraryTree) 
       PCollection_ATPreOrderIterator::RecursiveRemove(
                      const Handle(PCollection_HArbitraryTree)& ATree) 
{
  Handle(PCollection_HArbitraryTree) Temp;
  CurrentStack->Pop();
  if ( CurrentStack->IsEmpty()) {
    HasMore = Standard_False;
    Temp = ATree;                             // ... to be returned
  }
  else { 
//  ... is there somebody to the right ?  if yes, stop removing
//  ... if not, go on removing
    Temp = ATree->RightSibling();
    if (!Temp.IsNull()) {
      Temp = ATree;                      // ... to be returned
    }
    else {
      Temp = CurrentStack->Top();     
      Temp = RecursiveRemove( Temp);
    }
  }
  return Temp;
}