0024663: Removing unused "generic" classes. Part 4
authordln <dln@opencascade.com>
Thu, 20 Feb 2014 05:28:46 +0000 (09:28 +0400)
committerabv <abv@opencascade.com>
Thu, 6 Mar 2014 11:47:44 +0000 (15:47 +0400)
In scope of this issue next unused generic class will be removed:

- TCollection_AVLBaseNode
- TCollection_AVLIterator
- TCollection_AVLList
- TCollection_AVLNode
- TCollection_AVLSearchTree

- PCollection_ATInOrderIterator
- PCollection_ATPostOrderIterator
- PCollection_ATPreOrderIterator
- PCollection_AVLIterator
- PCollection_AVLNode
- PCollection_AdjacentVerticesIterator
- PCollection_BackEdgesIterator
- PCollection_BreadthFirstIterator
- PCollection_DepthFirstIterator
- PCollection_DoubleMapIterator
- PCollection_DoubleMapNode
- PCollection_Edge
- PCollection_EdgesIterator
- PCollection_FrontEdgesIterator
- PCollection_HAVLSearchTree
- PCollection_HArbitraryTree
- PCollection_HDirectedGraph
- PCollection_HDoubleMap
- PCollection_HQueue
- PCollection_HSet
- PCollection_HStack
- PCollection_LeavesIterator
- PCollection_QueueIterator
- PCollection_RootsIterator
- PCollection_SetIterator
- PCollection_StackIterator
- PCollection_Vertex
- PCollection_VerticesIterator
- PCollection_HDataMap
- PCollection_HIndexedDataMap
- PCollection_IndexedDataMapNode
- PCollection_MapIterator
- PCollection_MapNode

59 files changed:
src/PCollection/PCollection.cdl
src/PCollection/PCollection_ATInOrderIterator.gxx [deleted file]
src/PCollection/PCollection_ATPostOrderIterator.gxx [deleted file]
src/PCollection/PCollection_ATPreOrderIterator.gxx [deleted file]
src/PCollection/PCollection_AVLIterator.gxx [deleted file]
src/PCollection/PCollection_AVLNode.gxx [deleted file]
src/PCollection/PCollection_AdjacentVerticesIterator.gxx [deleted file]
src/PCollection/PCollection_BackEdgesIterator.gxx [deleted file]
src/PCollection/PCollection_BreadthFirstIterator.gxx [deleted file]
src/PCollection/PCollection_DepthFirstIterator.gxx [deleted file]
src/PCollection/PCollection_DoubleMapIterator.gxx [deleted file]
src/PCollection/PCollection_DoubleMapNode.gxx [deleted file]
src/PCollection/PCollection_Edge.gxx [deleted file]
src/PCollection/PCollection_EdgesIterator.gxx [deleted file]
src/PCollection/PCollection_FrontEdgesIterator.gxx [deleted file]
src/PCollection/PCollection_HAVLSearchTree.cdl [deleted file]
src/PCollection/PCollection_HAVLSearchTree.gxx [deleted file]
src/PCollection/PCollection_HArbitraryTree.cdl [deleted file]
src/PCollection/PCollection_HArbitraryTree.gxx [deleted file]
src/PCollection/PCollection_HDataMap.cdl [deleted file]
src/PCollection/PCollection_HDataMap.gxx [deleted file]
src/PCollection/PCollection_HDataMap.lxx [deleted file]
src/PCollection/PCollection_HDirectedGraph.cdl [deleted file]
src/PCollection/PCollection_HDirectedGraph.gxx [deleted file]
src/PCollection/PCollection_HDoubleMap.cdl [deleted file]
src/PCollection/PCollection_HDoubleMap.gxx [deleted file]
src/PCollection/PCollection_HIndexedDataMap.cdl [deleted file]
src/PCollection/PCollection_HIndexedDataMap.gxx [deleted file]
src/PCollection/PCollection_HQueue.cdl [deleted file]
src/PCollection/PCollection_HQueue.gxx [deleted file]
src/PCollection/PCollection_HSet.cdl [deleted file]
src/PCollection/PCollection_HSet.gxx [deleted file]
src/PCollection/PCollection_HStack.cdl [deleted file]
src/PCollection/PCollection_HStack.gxx [deleted file]
src/PCollection/PCollection_IndexedDataMapNode.gxx [deleted file]
src/PCollection/PCollection_LeavesIterator.gxx [deleted file]
src/PCollection/PCollection_MapIterator.gxx [deleted file]
src/PCollection/PCollection_MapNode.gxx [deleted file]
src/PCollection/PCollection_QueueIterator.gxx [deleted file]
src/PCollection/PCollection_RootsIterator.gxx [deleted file]
src/PCollection/PCollection_SetIterator.gxx [deleted file]
src/PCollection/PCollection_StackIterator.gxx [deleted file]
src/PCollection/PCollection_Vertex.gxx [deleted file]
src/PCollection/PCollection_VerticesIterator.gxx [deleted file]
src/TCollection/FILES
src/TCollection/TCollection.cdl
src/TCollection/TCollection_AVLBaseNode.cdl [deleted file]
src/TCollection/TCollection_AVLBaseNode.cxx [deleted file]
src/TCollection/TCollection_AVLBaseNode.lxx [deleted file]
src/TCollection/TCollection_AVLIterator.gxx [deleted file]
src/TCollection/TCollection_AVLIterator.lxx [deleted file]
src/TCollection/TCollection_AVLList.gxx [deleted file]
src/TCollection/TCollection_AVLList.lxx [deleted file]
src/TCollection/TCollection_AVLNode.gxx [deleted file]
src/TCollection/TCollection_AVLNode.hxx [deleted file]
src/TCollection/TCollection_AVLNode.lxx [deleted file]
src/TCollection/TCollection_AVLSearchTree.cdl [deleted file]
src/TCollection/TCollection_AVLSearchTree.gxx [deleted file]
src/TCollection/TCollection_AVLSearchTree.lxx [deleted file]

index dbd1a95..c16a4a1 100644 (file)
@@ -49,58 +49,12 @@ is
                ---Purpose: Generic sequence of elements
                -- indexed by an integer in the range 1..N.
 
-       generic class HQueue,QueueNode,QueueIterator;
-
-               ---Purpose: A queue is a sequence of items in which items 
-               -- are added at one end (called the back of the queue) 
-               -- and removed at the other end (calledthe front).
-                -- The Queue is empty if there are no elements.
-
-       
-       generic class HSet,SetNode,SetIterator;
-               ---Purpose: A set is an unordered collection of items
-               -- We can not have duplicated items in a given set.
-
-
-       generic class HStack,StackNode,StackIterator;
-
-               ---Purpose: A stack is a list of items in which items are
-                -- added and removed from the same end, called the 
-                -- top of the stack.
 
        generic class Hash;
        
        ---Purpose: Definition of hash function. This class is used by Map 
        -- class and may be redefined by user.
 
-       generic class HDataMap,MapNode,Array,MapIterator;
-
-               ---Purpose: A map is a Collection of bindings
-               -- between two objects. One is considered as
-               -- the key and a hash code value must be 
-               -- computed for it.
-
-       generic class HDoubleMap,
-                      DoubleMapNode,
-                      ArrayDoubleMap,
-                      DoubleMapIterator;
-                ---Purpose: A double map is a collection of bindings 
-                -- between two objects.
-                -- It can be retrieved either by its Key or its Item; 
-                -- A hash code value must be computed for both.
-
-       generic class HIndexedDataMap,
-                     IndexedDataMapNode,
-                     ArrayIndexedDataMap;
-                ---Purpose: The IndexedDataMap is a hashed set of objects of 
-                -- Type Key, called Keys. Keys can be inserted in 
-                -- the Map but not removed. The Map keeps the number 
-                -- of keys called NbKeys. Each time a Key is inserted
-                -- the Map tests if this Key is already in the Map. 
-                -- If it is, nothing is done. If not, NbKeys is 
-                -- incremented and it's value is bound to the Key 
-                -- and called the Index.
 
         deferred generic class Compare ;
                                    
@@ -121,39 +75,10 @@ is
                
         enumeration Side is Left , Right;
 
-        generic class HAVLSearchTree,
-                      AVLNode,
-                      AVLNodeStack, 
-                      AVLIterator ;
-
         exception IsNotRoot inherits Failure;
         exception IsNullTree inherits Failure;
         exception IsContained inherits Failure;
 
-        generic class HArbitraryTree,
-                      SeqArbitraryTree,
-                      StackArbitraryTree, 
-                      ATPreOrderIterator ,
-                      ATPostOrderIterator, 
-                      ATInOrderIterator ;          
-
-        generic class HDirectedGraph,
-                     Vertex,
-                     Edge,
-                     SetOfVertex,
-                     SetOfEdge,
-                     StackOfVertex,
-                     QueueOfVertex,
-                     FrontEdgesIterator,
-                     BackEdgesIterator,
-                     DepthFirstIterator,
-                     BreadthFirstIterator,
-                     AdjacentVerticesIterator,
-                     VerticesIterator,
-                     RootsIterator,
-                     LeavesIterator,
-                     EdgesIterator;
-
         class HAsciiString;
 
        class HExtendedString;
diff --git a/src/PCollection/PCollection_ATInOrderIterator.gxx b/src/PCollection/PCollection_ATInOrderIterator.gxx
deleted file mode 100644 (file)
index bba9c62..0000000
+++ /dev/null
@@ -1,141 +0,0 @@
-// Created on: 1992-08-17
-// Created by: Mireille MERCIEN
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#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;  
-}
-
-
diff --git a/src/PCollection/PCollection_ATPostOrderIterator.gxx b/src/PCollection/PCollection_ATPostOrderIterator.gxx
deleted file mode 100644 (file)
index daf5291..0000000
+++ /dev/null
@@ -1,117 +0,0 @@
-// Created on: 1992-08-13
-// Created by: Mireille MERCIEN
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_OutOfRange.hxx>
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// ----------------------------------------------------------------------
-// ----------------------------------------------------------------------
-
-// Purpose: Permits to iterate through an ArbitraryTree beginning by 
-//          the most left leave and its rightSibling, then upward to
-//          its parent, ..
-//          IF theTree is (  A (B (C D E)) F G (H (I J K)))
-//          THEN it will read ( C D E B F I J K H G A)
-
-
-// --------
-// Create
-// --------
-PCollection_ATPostOrderIterator::
-       PCollection_ATPostOrderIterator
-         (const Handle(PCollection_HArbitraryTree)& ATree) 
-{
-   CurrentStack = new PCollection_StackArbitraryTree;                  
-   if (ATree.IsNull()) {
-     HasMore = Standard_False;
-   }
-   else {
-     HasMore = Standard_True;
-     RecursiveAppend(ATree);
-     CurrentTree = CurrentStack->Top();
-   }
-}
-
-// --------
-// More
-// --------
-Standard_Boolean PCollection_ATPostOrderIterator::More () const
-{
-  return HasMore;
-}
-
-// --------
-// Value
-// --------
-Handle(PCollection_HArbitraryTree) 
-   PCollection_ATPostOrderIterator::Value () const
-{
-  if (!HasMore) Standard_NoSuchObject::Raise();
-  return CurrentTree;
-}
-
-// --------
-// Clear
-// --------
-void PCollection_ATPostOrderIterator::Clear ()
-{
-  CurrentTree.Nullify();
-  CurrentStack.Nullify();
-  HasMore = Standard_False;
-}
-
-// --------
-// Next
-// --------
-void PCollection_ATPostOrderIterator::Next ()
-{
-   if (!HasMore) Standard_NoMoreObject::Raise();
-// ... removes the last tree
-   CurrentStack->Pop();
-   if (CurrentStack->IsEmpty())  {
-     HasMore = Standard_False;
-   }
-   else  {
-//   ... is there still someone on the right ? 
-//   ... if yes, go on to the right
-     Handle(PCollection_HArbitraryTree) Temp = CurrentTree->RightSibling();
-     if (!Temp.IsNull())  { 
-       RecursiveAppend(Temp);
-     }
-     CurrentTree = CurrentStack->Top();
-   }
-}  
-
-// PRIVATE TOOLS TO MANAGE CURRENTSTACK
-
-// --------
-// --------
-void PCollection_ATPostOrderIterator::RecursiveAppend (
-                  const Handle(PCollection_HArbitraryTree)& ATree) 
-{
-   CurrentStack->Push(ATree);    
-// ... is there still some child ?
-   if ( !ATree->IsLeaf()) {
-     RecursiveAppend( ATree->Child(1));
-   }
-}     
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_ATPreOrderIterator.gxx b/src/PCollection/PCollection_ATPreOrderIterator.gxx
deleted file mode 100644 (file)
index 3b37bab..0000000
+++ /dev/null
@@ -1,131 +0,0 @@
-// Created on: 1992-08-13
-// Created by: Mireille MERCIEN
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#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;
-}
-
-
-
-
-
diff --git a/src/PCollection/PCollection_AVLIterator.gxx b/src/PCollection/PCollection_AVLIterator.gxx
deleted file mode 100644 (file)
index da0ca9f..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-// Created on: 1992-05-13
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// Revised:    Wed Oct,21 1992
-// By     :     Mireille MERCIEN
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-typedef PCollection_AVLNodeStack Stack;
-typedef PCollection_HAVLSearchTree Tree;
-typedef Handle(PCollection_HAVLSearchTree) Handle(Tree);
-typedef PCollection_AVLNode Node;
-typedef Handle(PCollection_AVLNode) Handle(Node);
-
-//-----------------------------------------------------------------------------
-PCollection_AVLIterator::
-              PCollection_AVLIterator ( const Handle(Tree)& aTree) 
-{
-  CurrentStack = new Stack;                     // Create an empty Stack
-  Handle(Node) Root = aTree->GetRoot();     // Current node = root of tree
-  if (Root.IsNull()) {
-     HasMore = False;
-  }
-  else {
-     HasMore = True;
-     // CURRENTSTACK MANAGEMENT
-     Append( Root);
-  }
-}
-
-//-----------------------------------------------------------------------------
-Boolean PCollection_AVLIterator::More () const 
-{
-  return  HasMore;
-}
-
-//-----------------------------------------------------------------------------
-Handle(Node) PCollection_AVLIterator::Value () const 
-{
-  if (!HasMore) NoSuchObject::Raise();
-  return CurrentNode;
-}
-
-//-----------------------------------------------------------------------------
-void PCollection_AVLIterator::Clear () 
-{
-  CurrentNode.Nullify();
-  CurrentStack.Nullify();
-  HasMore = False;
-}
-
-//-----------------------------------------------------------------------------
-void PCollection_AVLIterator::Next () 
-{
-  if (!HasMore) NoMoreObject::Raise();
-  Handle(Node) Right = CurrentNode->RightChild();
-
-  // WHAT ARE THE FOLLOWING ELEMENTS ?
-  if ( Right.IsNull()) {
-    RecursiveRemove(CurrentNode);
-    // MAYBE IT'S THE END
-    if (CurrentStack->IsEmpty()) 
-       HasMore = False;
-    else 
-       CurrentNode = CurrentStack->Top();
-  }
-  else {
-    Append (Right);
-  }
-}
-
-
-// PRIVATE TOOLS TO ITERATE
-
-
-void PCollection_AVLIterator::Append ( const Handle(Node)& Root) 
-{
-  RecursiveAppend( Root);
-  CurrentNode = CurrentStack->Top();
-}
-
-
-void PCollection_AVLIterator::RecursiveAppend(const Handle(Node)& ANode) 
-{
-  if (!ANode.IsNull()) {
-    CurrentStack->Push(ANode);
-    Handle(Node) Left = ANode->LeftChild();
-    RecursiveAppend( Left);
-  }
-}
-
-
-void PCollection_AVLIterator::RecursiveRemove(const Handle(Node)& theNode) 
-{       
-     CurrentStack->Pop();
-     if (CurrentStack->IsEmpty()) return;
-     Handle(Node) NewNode = CurrentStack->Top();
-     if (theNode == NewNode->RightChild()) {
-        RecursiveRemove(NewNode);
-     }
-}
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_AVLNode.gxx b/src/PCollection/PCollection_AVLNode.gxx
deleted file mode 100644 (file)
index 5561724..0000000
+++ /dev/null
@@ -1,167 +0,0 @@
-// Created on: 1991-05-24
-// Created by: Annick PANCHER
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// Updated:     Jean-Pierre TIRAULT Apr,6 1992, Mireille MERCIEN
-
-#include <PCollection_Side.hxx>
-typedef PCollection_Side Side;
-typedef PCollection_AVLNode Node;
-typedef Handle(PCollection_AVLNode) Handle(Node);
-
-//---------------------------------------------------------------------------
-// Create
-// --------------------------------------------------------------------------
-PCollection_AVLNode::PCollection_AVLNode(const Item& theItem) 
-{
-  MyItem = theItem;
-  Count  = 1;
-  MyRightChild.Nullify();
-  MyLeftChild.Nullify();
-}
-
-// -------------------------- READING ---------------------------------------
-
-//----------------------------------------------------------------------------
-// RightChild
-// --------------------------------------------------------------------------
-Handle(Node)  PCollection_AVLNode::RightChild () const 
-{
-  return MyRightChild;
-}
-
-//---------------------------------------------------------------------------
-// LeftChild
-// --------------------------------------------------------------------------
-Handle(Node) PCollection_AVLNode::LeftChild () const 
-{
-  return MyLeftChild;
-}
-
-//--------------------------------------------------------------------------
-// Value
-// --------------------------------------------------------------------------
-Item PCollection_AVLNode::Value () const 
-{
-  return MyItem;
-}
-
-//---------------------------------------------------------------------------
-// GetMultiplicity
-// --------------------------------------------------------------------------
-Integer PCollection_AVLNode::GetMultiplicity () const 
-{
-  return Count;
-}
-// -------------------- WRITING ---------------------------------------------
-
-//--------------------------------------------------------------------------
-// Setvalue
-// --------------------------------------------------------------------------
-void PCollection_AVLNode::SetValue(const Item& theValue) 
-{
-  MyItem = theValue;
-}
-
-//---------------------------------------------------------------------------
-// SetRightChild
-// --------------------------------------------------------------------------
-void PCollection_AVLNode::
-               SetRightChild(const Handle(Node)& theNode) 
-{
-  MyRightChild = theNode;
-}
-
-
-//--------------------------------------------------------------------------
-// SetLeftChild
-// --------------------------------------------------------------------------
-void PCollection_AVLNode::
-                   SetLeftChild(const Handle(Node)& theNode) 
-{
-  MyLeftChild = theNode;
-}
-
-//---------------------------------------------------------------------------
-// SetChild
-// --------------------------------------------------------------------------
-void PCollection_AVLNode::SetChild
-             ( const Handle(Node)& theNode, const Side theSide) 
-{
-  if (theSide == PCollection_Left) {       
-    MyLeftChild = theNode;
-  }
-  else {
-    MyRightChild = theNode;
-  }
-}
-
-
-//--------------------------------------------------------------------------
-// SetMultiplicity
-// --------------------------------------------------------------------------
-void PCollection_AVLNode::SetMultiplicity(const Integer theCount) 
-{
-  Count = theCount;
-}
-
-//----------------------------------------------------------------------------
-// Copy
-//-----------------------------------------------------------------------------
-Handle(Node) PCollection_AVLNode::Copy() const 
-{
-  Handle(Node) newNode = new Node(MyItem);
-  newNode->SetMultiplicity(Count);
-  if (!MyLeftChild.IsNull()) newNode->SetLeftChild(MyLeftChild->Copy());
-  if (!MyRightChild.IsNull()) newNode->SetRightChild(MyRightChild->Copy());
-  return newNode;
-}
-
-// ------------  REDEFINED
-
-// --------------------------------------------------------------------------
-// ShallowCopy
-// --------------------------------------------------------------------------
-Handle(Standard_Persistent) PCollection_AVLNode::ShallowCopy() const
-{
-   Handle(Node) TheCopy;
-   TheCopy = new Node(MyItem);
-   TheCopy->SetMultiplicity (Count);
-   TheCopy->SetValue        (MyItem);
-   TheCopy->SetRightChild   (MyRightChild);
-   TheCopy->SetLeftChild    (MyLeftChild);
-   return TheCopy;
-
-}
-
-//---------------------------------------------------------------------------
-// ShallowDump
-// ----------------------------------------------------------------------------
-void PCollection_AVLNode::ShallowDump(Standard_OStream& S) const
-{
-  S << "begin class AVLNode "<< endl;
-//  MyItem->ShallowDump(S) ;
-  S << "Count      : "<< Count << "times." << endl;
-  MyLeftChild->ShallowDump(S);
-  MyRightChild->ShallowDump(S);
-  S << "end class AVLNode" << endl;
-}
-
-   
-
-
-
-
-
diff --git a/src/PCollection/PCollection_AdjacentVerticesIterator.gxx b/src/PCollection/PCollection_AdjacentVerticesIterator.gxx
deleted file mode 100644 (file)
index 851ca85..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_AdjacentVerticesIterator::PCollection_AdjacentVerticesIterator
-   (const Handle(PCollection_Vertex)& V):MyEdgeIterator(V->GetFrontEdges())
-{
-  HasMore = MyEdgeIterator.More();
-}
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_AdjacentVerticesIterator::More () const 
-{
-  return HasMore;
-}
-
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_AdjacentVerticesIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  MyEdgeIterator.Next();
-  HasMore = MyEdgeIterator.More();
-}
-
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_AdjacentVerticesIterator::Value () const 
-{
-  if (!HasMore) Standard_NoSuchObject::Raise();
-  Handle(PCollection_Edge) AnEdge = MyEdgeIterator.Value();
-  return AnEdge->Destination();
-}
-
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_AdjacentVerticesIterator::Clear () 
-{
-  HasMore = False;
-}
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_BackEdgesIterator.gxx b/src/PCollection/PCollection_BackEdgesIterator.gxx
deleted file mode 100644 (file)
index 49aebb5..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_BackEdgesIterator::PCollection_BackEdgesIterator
-     (const Handle(PCollection_Vertex)& V):MyEdgeIterator(V->GetBackEdges()) 
-{
-  HasMore = MyEdgeIterator.More();
-}
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_BackEdgesIterator::More () const 
-{
-  return HasMore;
-}
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_BackEdgesIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  MyEdgeIterator.Next();
-  HasMore = MyEdgeIterator.More();
-}
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Edge) PCollection_BackEdgesIterator::Value () const 
-{
-  if (HasMore) {
-    return MyEdgeIterator.Value();
-  }
-  else {
-    NoSuchObject::Raise();
-  }
-}
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_BackEdgesIterator::Clear () 
-{
-  HasMore = False;
-}
-
-
-
-
diff --git a/src/PCollection/PCollection_BreadthFirstIterator.gxx b/src/PCollection/PCollection_BreadthFirstIterator.gxx
deleted file mode 100644 (file)
index a306ea0..0000000
+++ /dev/null
@@ -1,93 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_BreadthFirstIterator::
-      PCollection_BreadthFirstIterator (const Handle(PCollection_Vertex)& V) 
-{
-  Visited = new PCollection_SetOfVertex;
-  Ready = new PCollection_QueueOfVertex;
-  Visited->Add(V);
-//mip  Ready->Add(V);
-  Ready->Push(V);  
-  HasMore = !(Ready->IsEmpty());
-}
-
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_BreadthFirstIterator::More () const 
-{
-  return HasMore;
-}
-
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_BreadthFirstIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  Handle(PCollection_Vertex) w1 = Ready->Front();
-  Ready->Pop();
-  PCollection_FrontEdgesIterator It(w1);
-  while (It.More()) {
-    Handle(PCollection_Vertex) w2 = It.Value()->Destination();
-    if (! (Visited->Contains(w2))) {
-//mip       Ready->Add(w2);
-       Ready->Push(w2);
-       Visited->Add(w2);
-    }
-    It.Next();
-  }
-  HasMore = !(Ready->IsEmpty());
-}
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_BreadthFirstIterator::Value () const 
-{
-  if (!HasMore) Standard_NoSuchObject::Raise();
-  return Ready->Front();
-}
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_BreadthFirstIterator::Clear () 
-{
-  HasMore = False;
-}
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_DepthFirstIterator.gxx b/src/PCollection/PCollection_DepthFirstIterator.gxx
deleted file mode 100644 (file)
index 4d91c76..0000000
+++ /dev/null
@@ -1,85 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_DepthFirstIterator::
-     PCollection_DepthFirstIterator(const Handle(PCollection_Vertex)& V) 
-{
-  Visited = new PCollection_SetOfVertex;
-  Ready = new PCollection_StackOfVertex;
-  Visited->Add(V);
-  Ready->Push(V);
-  HasMore = ! (Ready->IsEmpty());
-}
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_DepthFirstIterator::More () const 
-{
-  return HasMore;
-}
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_DepthFirstIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  Handle(PCollection_Vertex) w1 = Ready->Top();
-  Ready->Pop();
-  PCollection_FrontEdgesIterator It(w1);
-  while (It.More()) {
-    Handle(PCollection_Vertex) w2 = It.Value()->Destination();
-    if (! (Visited->Contains(w2))) {
-      Ready->Push(w2);
-      Visited->Add(w2);
-    }
-    It.Next();
-  }
-  HasMore = !(Ready->IsEmpty());
-}
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_DepthFirstIterator::Value () const 
-{
-  if (HasMore) 
-     return Ready->Top();
-  else 
-     Standard_NoSuchObject::Raise();
-}
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
- void PCollection_DepthFirstIterator::Clear () 
-{
-  HasMore = False;
-  Ready->Nullify();
-  Visited->Nullify();
-}
diff --git a/src/PCollection/PCollection_DoubleMapIterator.gxx b/src/PCollection/PCollection_DoubleMapIterator.gxx
deleted file mode 100644 (file)
index 9bb0274..0000000
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//-Version: 
-
-//  Version    Date         Purpose
-//              07/01/93     Creation   
-
-//-Language     C++2.0
-
-//-Declarations
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-//=======================================================================
-// Function : DoubleMapIterator
-//=======================================================================
-
-PCollection_DoubleMapIterator::PCollection_DoubleMapIterator
-  ( const Handle(PCollection_HDoubleMap) &aDoubleMap )
-{
-  Standard_Boolean Found = Standard_False;
-
-  myBuckets = aDoubleMap->GetArrayKey();
-// Sets the index and the node on the first "no empty" entry
-  if ( aDoubleMap->IsEmpty() ) myCurrentIndex = myBuckets->Length() + 1;
-  else myCurrentIndex = 1;
-  
-  while ( myCurrentIndex <= myBuckets->Length() && !Found ) {
-    if ( ! myBuckets->Value(myCurrentIndex).IsNull() ) {
-      myCurrentNode = myBuckets->Value(myCurrentIndex);
-      Found = Standard_True;
-    }
-    else myCurrentIndex++;
-  }
-}
-
-//=======================================================================
-// Function : More
-//=======================================================================
-
-Standard_Boolean PCollection_DoubleMapIterator::More() const
-{
-  Standard_Boolean Ok = ( myCurrentIndex <= myBuckets->Length()) && 
-                        (! myCurrentNode.IsNull());
-
-  return Ok;
-}
-                                                     
-//=======================================================================
-// Function : Next
-//=======================================================================
-
-void PCollection_DoubleMapIterator::Next()
-{
-  Standard_Boolean Found = Standard_False;
-  Standard_Boolean HasMore = ( myCurrentIndex <= myBuckets->Length()) && 
-                        (! myCurrentNode.IsNull());
-
-  if ( !HasMore ) Standard_NoMoreObject::Raise();
-
-  myCurrentNode = myCurrentNode->NextKey();
-  if ( myCurrentNode.IsNull() ) {
-    myCurrentIndex++;
-    while ( myCurrentIndex <= myBuckets->Length() && !Found ) {
-      myCurrentNode = myBuckets->Value(myCurrentIndex);
-      if ( myCurrentNode.IsNull() ) 
-       myCurrentIndex++;
-      else
-       Found = Standard_True;
-    }
-  }
-    
-}
-                                                     
-//=======================================================================
-// Function : KeyValue
-//=======================================================================
-
-Key PCollection_DoubleMapIterator::KeyValue () const
-{
-  if ( myCurrentNode.IsNull() ) Standard_NoSuchObject::Raise();
-  return myCurrentNode->GetKey();
-}
-                                                     
-//=======================================================================
-// Function : ItemValue
-//=======================================================================
-
-Item PCollection_DoubleMapIterator::ItemValue () const
-{
-  if ( myCurrentNode.IsNull() ) Standard_NoSuchObject::Raise();
-  return myCurrentNode->GetItem();
-}
diff --git a/src/PCollection/PCollection_DoubleMapNode.gxx b/src/PCollection/PCollection_DoubleMapNode.gxx
deleted file mode 100644 (file)
index 3e35f3b..0000000
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//-Version: 
-
-//  Version    Date         Purpose
-//              14/12/92     Creation   
-
-//-Language     C++2.0
-
-//=======================================================================
-// Function : DoubleMapNode
-//=======================================================================
-
-PCollection_DoubleMapNode::PCollection_DoubleMapNode
-  (
-   const Key &aKey, 
-   const Item &anItem,
-   const Handle(PCollection_DoubleMapNode) &nextKey,
-   const Handle(PCollection_DoubleMapNode) &nextItem ) :
-
-  myKey(aKey), myItem(anItem), myNextKey(nextKey), myNextItem(nextItem)
-
-{
-}
-
-//=======================================================================
-// Function : SetNextKey
-//=======================================================================
-
-void PCollection_DoubleMapNode::SetNextKey
-  ( const Handle(PCollection_DoubleMapNode) &aNode )
-{
-  myNextKey = aNode;
-}
-                                                     
-//=======================================================================
-// Function : SetNextItem
-//=======================================================================
-
-void PCollection_DoubleMapNode::SetNextItem
-  ( const Handle(PCollection_DoubleMapNode) &aNode )
-{
-  myNextItem = aNode;
-}
-                                                     
-//=======================================================================
-// Function : GetKey
-//=======================================================================
-
-Key PCollection_DoubleMapNode::GetKey () const
-{
-  return myKey;
-}
-                                                     
-//=======================================================================
-// Function : GetItem
-//=======================================================================
-
-Item PCollection_DoubleMapNode::GetItem () const
-{
-  return myItem;
-}
-                                                     
-//=======================================================================
-// Function : NextKey
-//=======================================================================
-
-Handle(PCollection_DoubleMapNode) 
-     PCollection_DoubleMapNode::NextKey() const
-{
-  return myNextKey;
-}
-                                                     
-//=======================================================================
-// Function : SetNextItem
-//=======================================================================
-
-Handle(PCollection_DoubleMapNode) 
-     PCollection_DoubleMapNode::NextItem() const
-{
-  return myNextItem;
-}
-                                                     
diff --git a/src/PCollection/PCollection_Edge.gxx b/src/PCollection/PCollection_Edge.gxx
deleted file mode 100644 (file)
index c600f9e..0000000
+++ /dev/null
@@ -1,115 +0,0 @@
-// Created on: 1991-05-30
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_Edge::
-     PCollection_Edge(const Handle(PCollection_Vertex)& Source, 
-                     const Handle(PCollection_Vertex)& Destination, 
-                     const Attribute& Value) 
-{
-  MyAttribute   = Value;
-  MySource      = Source;
-  MyDestination = Destination;
-}
-
-//---------------------------------------------------------------------------
-// GetAttribute
-//---------------------------------------------------------------------------
-Attribute PCollection_Edge::GetAttribute () const 
-{
-  return MyAttribute;
-}
-
-//---------------------------------------------------------------------------
-// SetAttribute
-//---------------------------------------------------------------------------
-void PCollection_Edge::SetAttribute (const Attribute& Value) 
-{
-  MyAttribute = Value;
-}
-
-//---------------------------------------------------------------------------
-// Source
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_Edge::Source () const 
-{
-  return MySource;
-}
-
-//---------------------------------------------------------------------------
-// Destination
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_Edge::Destination () const 
-{
-  return MyDestination;
-}
-
-
-//---------------------------------------------------------------------------
-// SetSource
-//---------------------------------------------------------------------------
-void PCollection_Edge::SetSource (const Handle(PCollection_Vertex)& V)  
-{
-  MySource = V;
-}
-
-//---------------------------------------------------------------------------
-// SetDestination
-//---------------------------------------------------------------------------
-void PCollection_Edge::SetDestination (const Handle(PCollection_Vertex)& V) 
-{
-  MyDestination = V;
-}
-
-//---------------------------------------------------------------------------
-// Reverse
-//---------------------------------------------------------------------------
-void PCollection_Edge::Reverse () 
-{
-  Handle(PCollection_Edge) me = this;
-  MyDestination->RemoveBackEdge(me);
-  MySource->RemoveFrontEdge(me);
-  MyDestination->AddFrontEdge(me);
-  MySource->AddBackEdge(me);
-  Handle (PCollection_Vertex) temp = MyDestination;
-  MyDestination = MySource;
-  MySource = temp;
-}
-
-//---------------------------------------------------------------------------
-// IsLoop
-//---------------------------------------------------------------------------
-Boolean PCollection_Edge::IsLoop () const 
-{
-  return (MyDestination == MySource);
-}
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_EdgesIterator.gxx b/src/PCollection/PCollection_EdgesIterator.gxx
deleted file mode 100644 (file)
index c058201..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_EdgesIterator::PCollection_EdgesIterator 
-   (const Handle(PCollection_HDirectedGraph)& G):MyEdgeIterator(G->GetEdges()) 
-{
-  HasMore = MyEdgeIterator.More();
-}
-
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_EdgesIterator::More () const 
-{
-  return HasMore;
-}
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_EdgesIterator::Next ()  
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  MyEdgeIterator.Next();
-  HasMore = MyEdgeIterator.More();
-}
-
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Edge) PCollection_EdgesIterator::Value () const 
-{
-  if (!HasMore) Standard_NoSuchObject::Raise();
-  return MyEdgeIterator.Value();
-}
-
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_EdgesIterator::Clear () 
-{
-  HasMore = False;
-}
-
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_FrontEdgesIterator.gxx b/src/PCollection/PCollection_FrontEdgesIterator.gxx
deleted file mode 100644 (file)
index 70c8093..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_FrontEdgesIterator::PCollection_FrontEdgesIterator
-     (const Handle(PCollection_Vertex)& V):MyEdgeIterator(V->GetFrontEdges())
-{
-  HasMore = MyEdgeIterator.More();
-}
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_FrontEdgesIterator::More () const 
-{
-  return HasMore;
-}
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_FrontEdgesIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  MyEdgeIterator.Next();
-  HasMore = MyEdgeIterator.More();
-}
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Edge) PCollection_FrontEdgesIterator::Value () const 
-{
-  if (HasMore) {
-    return MyEdgeIterator.Value();
-  }
-  else {
-    Standard_NoSuchObject::Raise();
-  }
-}
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_FrontEdgesIterator::Clear () 
-{
-  HasMore = False;
-}
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HAVLSearchTree.cdl b/src/PCollection/PCollection_HAVLSearchTree.cdl
deleted file mode 100644 (file)
index 9e8be7d..0000000
+++ /dev/null
@@ -1,403 +0,0 @@
--- Created on: 1991-05-21
--- Created by: Annick PANCHER
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
--- Revised:    Mireille MERCIEN
-
-
-generic class HAVLSearchTree from PCollection (
-               Item as Storable;
-               Comparator as Compare from PCollection(Item))
-
-inherits Persistent
----Purpose: Defines a binary search tree, e.g.  an ordered and
-       -- balanced binary tree.  An AVLSearchTree is created with a   
-       -- kind of   Item and  a   Comparator. It's composed with Nodes. 
-       -- One item is contained only by one  Node, and a 'count' stores  
-       -- the number of its occurences.
-       -- The  only  public  operations on an AVLSearchTree,
-               -- except reading ( the number of its Nodes, its Root
-               -- or the  Node containing  an item) are to insert or
-               -- remove an item, plus, of course, to find an item.
-               -- 
-        -- Then,  it's possible to  ask to  a Node its value,
-        -- the number of  occurences  of this value, and  its
-        -- right and left children. Other methods of Node are
-        -- private  and  called   by the private   methods of
-        -- AVLSearchTree which  manage the  Find method,  and
-        -- Insert and    Remove  operations,  always ensuring
-        -- order and balance. 
-       -- 1. ORDER  :  
-       -- If the tree  contains  three elements A,B,C, which
-       -- are ordered,  regarding  to a comparator  Comp, as
-       -- following:
-       -- A  <  B < C
-       -- Then TheRoot of the tree will contain B, with A as
-       -- LeftChild and C as RightChild. 
-       -- Each element on  the left of a  node A are 'lower'
-       -- than A  in respect  with the used  comparator, and
-       -- each element on its right are greater.
-       -- 
-       -- 2. BALANCE : The height of two children of  a Node
-       -- will never   have a difference  of  more  than one
-       -- level. An AVLSearch Tree is ALWAYS balanced.
-       --  Keywords: binary tree, ordered, balanced
-       --  Warning: To use  an AVLSearchTree,  since it's  ordered and
-       -- balanced each time an item is inserted or removed,
-       -- may be a bad   choice if there  are more  changing
-       -- operations  than    searching       requests,  for
-       -- performances criterias.   It can  be judicious  to
-       -- use it when  there  are   many  items to   consult
-       -- frequently.  
-               --  References: Classix,    Reusable  C++  Components(  Empathy
-               -- incorporated, 1990).         
-               -- Algorithms are attributed to :
-               --    G.M.Adel'son-Vel'skii and E.M.Landis, 1962.
-
-
-uses   Side from PCollection 
-
-
-raises NoSuchObject from Standard,
-       NoMoreObject from Standard
-
-
-
-    class AVLNode  inherits PManaged
-    uses Side from PCollection
-    is
-    
-       ---Purpose: Private class. This class provides tools to manipulate
-       -- an AVLSearchTree node.
-    
-       Create( theItem: Item)
-           returns mutable AVLNode ;
-
-       RightChild( me) returns mutable AVLNode;
-           ---Purpose: Reads the value of MyRightChild.    
-
-               LeftChild( me) returns mutable AVLNode;
-           ---Purpose: Reads the value of MyLeftChild.
-    
-       Value( me) returns any Item;
-           ---Purpose: Reads TheItem.
-    
-       GetMultiplicity( me)
-           ---Purpose: Returns number of occurences of Item contained
-           --          by <me>.
-           returns Integer from Standard;
-    
-
-       SetRightChild( me:mutable; theNode: AVLNode);
-           ---Purpose: Modifies the value of MyRightChild.
-    
-       SetLeftChild( me:mutable; theNode: AVLNode);
-           ---Purpose: Modifies the value of MyLeftChild.
-
-       SetChild ( me: mutable; theNode: AVLNode; 
-                   theSide: Side from PCollection);
-           ---Purpose: Modifies the value of right or left child.
-        
-       SetValue( me:mutable; theValue: Item);
-           ---Purpose: Modifies the value of TheItem.
-    
-       SetMultiplicity( me:mutable; theCount: Integer from Standard);
-           ---Purpose: Modifies the value of Count.
-     
-        Copy(me)
-           returns mutable AVLNode
-          is private;
-
-       -- REDEFINED
-
-       ShallowCopy(me) returns mutable like me 
-               is redefined;
-               ---Purpose: ShallowCopy redefinition.
-               ---C++: function call
-
-
-       ShallowDump (me; s: in out OStream) 
-               is redefined;
-               ---Purpose: ShallowDump redefinition.
-               ---C++: function call
-
-
-    fields
-       MyRightChild: AVLNode;
-       MyLeftChild : AVLNode;
-       MyItem      : Item;
-       Count       : Integer from Standard;
-       
-    friends class HAVLSearchTree from PCollection
-        
-    end;
-
-    class AVLNodeStack instantiates HStack(AVLNode);
-
-    class AVLIterator
-
-    raises NoMoreObject from Standard, NoSuchObject from Standard
-    is
-       ---Purpose: This class provides to iterate on an AVLSearchTree.
-       -- The type of traversal is the in-order traversal.
-       --  Example : If the AVLTree is the following:
-       --                            5
-       --                      2           7
-       --                    1   3      6     8
-       --                    
-       --            The result is:
-       --             1 2 3 5 6 7 8
-       --                      
-
-       Create( aTree: HAVLSearchTree)
-           ---Purpose: Creates an iterator on <aTree>.
-            ---Level: Public
-           returns AVLIterator;
-
-       More( me)
-           ---Purpose: Returns True if there is still an element to be read.
-            ---Level: Public
-           returns Boolean from Standard;
-           
-       Next( me: in out) raises NoMoreObject from Standard;
-           ---Purpose: Goes to next element of <me>.
-            ---Level: Public
-    
-       Value( me)
-           returns mutable AVLNode
-            ---Level: Public
-           raises NoSuchObject from Standard;
-          
-        Clear (me: in out);
-           ---Purpose: Empties my structure, so that if next call on <me>,
-           -- it will raise an exception NoMoreObject.
-            ---Level: Public
-
-        Append (me: in out; ANode:AVLNode)
-            ---Purpose: Adds Nodes to <CurrentStack> from <ANode>.
-            ---Level: Internal
-           is private;
-    
-        RecursiveAppend (me: in out; ANode:AVLNode)
-           ---Purpose: Called by Append to add <ANode> to
-           -- <CurrentStack>, and goes down to left
-            ---Level: Internal
-           is private;
-
-        RecursiveRemove (me: in out; ANode:AVLNode)
-           ---Purpose: Called by Next to remove <ANode> and
-           -- the Node which is before in CurrentStack.
-           -- If <ANode> was its rightChild.
-            ---Level: Internal
-           is private;
-       
-fields
-    CurrentNode  : AVLNode;
-    CurrentStack : AVLNodeStack;
-    HasMore      : Boolean;
-end;
-
-
-is
-
-    Create( aComparator: Comparator)
-       ---Purpose: Creates an empty tree (root points to NULL).
-       returns mutable HAVLSearchTree;
-    
-    
-    IsEmpty( me)
-        ---Level: Public
-       returns Boolean from Standard;
-
-    Extent( me)
-       ---Purpose: Returns  number of different items contained by <me>
-        ---Level: Public
-       returns Integer from Standard;
-    
-    TotalExtent( me)
-       ---Purpose: Returns total number of items (considers account of each Node)
-        ---Level: Public
-       returns Integer from Standard;
-    
-    Find( me; theItem: Item)
-       ---Purpose: Returns the Node containing <theItem>.
-        ---Level: Public
-       returns AVLNode;
-    
-    GetRoot( me)
-       returns AVLNode;
-        ---Level: Public
-    
-
-    Insert( me: mutable; theItem: Item);
-       ---Purpose: Inserts <theItem>  at  the  right place;  if  it's
-       -- already in <me>, only changes its <count>.
-        --  Level: Public
-       --  Example: 
-       -- Before 
-       --   me = ( i5( i3( i1)) -i7) and theItem = i2
-       -- After
-       --   me = ( i5( i2( i1 -i3)) -i7))
-       -- ( i means LeftChild, -i means RightChild)
-
-    InsertOnce(me: mutable; theItem: Item)
-       ---Purpose: Inserts <theItem> at the right place,  but only if
-       -- it isn't already in <me>; returns False if already there.
-        --  Level: Public
-       --  Example:
-       -- Before 
-       --   me = ( i5( i3( i1)) -i7) and theItem = i3
-       -- After
-       --   me = ( i5( i3( i1)) -i7) and return False
-       returns Boolean from Standard;
-
-    Remove( me : mutable; theItem : Item)
-       ---Purpose: Removes  from <me> the  Node containing <theItem>,
-       -- if its count=1,  or reduces its  count if count>1;
-       -- in this   aim,  calls   the   recursive  method
-       -- RecursiveRemove, with <forAll>=False;
-        --  Level: Public
-       --  Example:
-       -- Before 
-       --   me = ( i5( i3( i1)) -i7) and theItem = i7
-       -- After
-       --   me = ( i3( i1 -i5))        if count(i7)=1
-       -- Or
-       --   me = ( i5( i3( i1)) -i7)   if count(i7)>1
-       raises NoSuchObject from Standard;
-    
-    RemoveAll( me: mutable; theItem: Item)
-       ---Purpose: Removes  from <me>  the Node containing <theItem>;
-       -- in   this  aim,  calls   the   recursive    method
-       -- RecursiveRemove, with <forAll>=True;
-        --  Level: Public
-       --  Example
-       -- Before 
-       --   me = ( i5( i3( i1)) -i7) and theItem = i7
-       -- After
-       --   me = ( i3( i1 -i5))        
-       raises NoSuchObject from Standard;
-
-    Merge (me; another:HAVLSearchTree)
-       ---Purpose: Creates a third one from <me> and <another>.
-        ---Level: Public
-       returns mutable HAVLSearchTree;
-
-    Copy(me)
-        returns mutable HAVLSearchTree
-        ---Level: Internal
-       is private;
-
-    SetRoot( me: mutable; theNode: mutable AVLNode)
-        ---Level: Internal
-       is private;
-
-    RotateLeft( me; theNode : in out mutable AVLNode)
-       ---Purpose: right child A of <theNode> becomes the parent, and
-       -- <theNode> becomes its left  child; left child of A
-       -- becomes  the  right  child of  <theNode>.     This
-       -- rotation will  permit to  balance   <me>  after  a
-       -- pertubating action ( insert or remove) on it.
-        ---Level: Internal
-       is private;
-
-    RotateRight( me; theNode : in out mutable AVLNode)
-       ---Purpose: left child A of <theNode> becomes  the parent, and
-       -- <theNode> becomes its right  child; right child of
-       -- A  becomes  the left  child    of <theNode>.  This
-       -- rotation  will permit to   balance  <me>  after  a
-       -- pertubating action ( insert or remove) on it.
-        ---Level: Internal
-       is private;
-
-    LeftBalance( me; theNode : in out mutable AVLNode)
-       ---Purpose: Called after inserting or removing an item, if the
-       -- left branch of <theNode> is too long
-        ---Level: Internal
-       is private;
-
-    RightBalance( me; theNode : in out mutable AVLNode)
-       ---Purpose: Called after inserting or removing an item, if the
-       -- right branch of <theNode> is too long.
-        ---Level: Internal
-       is private;
-
-    InsertBalance( me; theNode  : in out mutable AVLNode; 
-                       theFather: mutable AVLNode;
-                       theSide  : Side from PCollection)
-       ---Purpose: Balances <me> after inserting an item.
-       returns Boolean from Standard
-        ---Level: Internal
-       is private;
-
-    RemoveBalance( me; theNode  : in out mutable AVLNode; 
-                       theFather: mutable AVLNode;
-                       theSide  : Side from PCollection)
-       ---Purpose: Balances <me> after inserting an item.
-        ---Level: Internal
-               returns Boolean from Standard
-       is private;
-
-    RecursiveInsert( me; theNode  : in out mutable AVLNode;
-                         theFather: mutable AVLNode;
-                         theSide  : Side from PCollection; 
-                          theItem  : Item;
-                         forOnce  : in out Boolean from Standard)
-       ---Purpose: Recursive method to  insert a new  Node OR to find
-       -- the existing one containing <theItem> and increase its count.
-               -- Returns True  when a new Node has  been created to
-               -- know  it needs to  be  balanced, and then  returns
-               -- False again.
-        ---Level: Internal
-       returns Boolean from Standard
-       is private;
-
-    RecursiveRemove( me; theNode  : in out mutable AVLNode;
-                         theFather: mutable AVLNode;
-                         theSide  : Side from PCollection; 
-                         theItem  : Item; 
-                         forAll   : Boolean from Standard)
-       ---Purpose: Recursive   method to   find  the Node  containing
-       -- <theItem>.  In case it's <theNode>,  removes it if
-       -- <forAll> is True, or reduces its count if <forAll> is False.
-       -- Returns True when theItem has been found
-        ---Level: Internal
-       returns Boolean from Standard
-        is private;
-
-       
-     ShallowCopy(me) returns mutable like me 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-     ShallowDump (me; s: in out OStream) 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-fields
-
-    TheRoot       : AVLNode;
-    TheComparator : Comparator;
-
-end;
-
-
-
-
diff --git a/src/PCollection/PCollection_HAVLSearchTree.gxx b/src/PCollection/PCollection_HAVLSearchTree.gxx
deleted file mode 100644 (file)
index 8fad88d..0000000
+++ /dev/null
@@ -1,456 +0,0 @@
-// Created on: 1991-05-23
-// Created by: Annick PANCHER
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// Revised by:  Jean-Pierre TIRAULT,Mireille MERCIEN
-//              May,14 1992
-
-#include <Standard_NoSuchObject.hxx>
-#include <PCollection_Side.hxx>
-typedef PCollection_Side Side;
-typedef PCollection_AVLNode Node;
-typedef Handle(PCollection_AVLNode) Handle(Node);
-typedef PCollection_HAVLSearchTree Tree;
-typedef Handle(PCollection_HAVLSearchTree) Handle(Tree);
-typedef PCollection_AVLIterator AVLIterator;
-
-
-//-----------------------------------------------------------------------------
-// Internal function Height : returns the height of an AVLtree
-//-----------------------------------------------------------------------------
-static Integer Height(const Handle(Node)& ANode) 
-{
-//   ... Length of the longest child
-     if(ANode.IsNull()) return 0;
-     return (1 + Max( Height(ANode->LeftChild()), 
-                      Height(ANode->RightChild()) ) );
-}
-
-//-----------------------------------------------------------------------------
-// Create : creates an empty AVLSearchTree
-//-----------------------------------------------------------------------------
-PCollection_HAVLSearchTree::
-    PCollection_HAVLSearchTree(const Comparator& AComparator)
-{
-  TheComparator = AComparator;
-  Handle(Node) NullNode;
-  NullNode.Nullify();
-  TheRoot = NullNode;
-}
-
-//-----------------------------------------------------------------------------
-// IsEmpty : Is the current tree empty ?
-//-----------------------------------------------------------------------------
-Boolean PCollection_HAVLSearchTree::IsEmpty () const
-{
-  return (TheRoot.IsNull());
-}
-
-//-----------------------------------------------------------------------------
-// GetRoot : Returns the root of the current tree
-//-----------------------------------------------------------------------------
-Handle(Node) PCollection_HAVLSearchTree::GetRoot () const 
-{
-  return TheRoot;
-}
-
-// ---------------------------------------------------------------------------
-// SetRoot : Replaces the root of the current tree
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::SetRoot(const Handle(Node)& ANode)
-{
-  TheRoot = ANode;
-}
-
-//-----------------------------------------------------------------------------
-// Extent : Number of different items in the current tree
-//-----------------------------------------------------------------------------
-// ... Management tools to have the number of nodes from a given one
-static Integer RecursiveExtent(const Handle(Node)& ANode) 
-{
-  if (ANode.IsNull()) return 0;
-  return  (1 +  RecursiveExtent(ANode->LeftChild())   
-             +  RecursiveExtent(ANode->RightChild())  );
-}
-
-//----------------------------------------------------------------------------
-Integer PCollection_HAVLSearchTree::Extent () const
-{
-  return RecursiveExtent(TheRoot);
-}
-
-//-----------------------------------------------------------------------------
-// Extent : Number of different items in the current tree according to
-//          the multiplicity
-//-----------------------------------------------------------------------------
-// ... Management tools to have the number of nodes from a given one
-static Integer RecursiveTotalExtent(const Handle(Node)& ANode) 
-{
-  if ( ANode.IsNull()) return 0;
-  return ( RecursiveTotalExtent(ANode->LeftChild())  +  
-           RecursiveTotalExtent(ANode->RightChild()) + 
-           ANode->GetMultiplicity() );
-}
-
-//----------------------------------------------------------------------------
-Integer PCollection_HAVLSearchTree::TotalExtent () const
-{
-  return RecursiveTotalExtent(TheRoot);
-}
-
-//-----------------------------------------------------------------------------
-// Find : Find the node containing an item
-//-----------------------------------------------------------------------------
-// ... Management tools
-static Handle(Node) RecursiveFind( const Comparator& Comp,
-                                   const Handle(Node)& SubRoot,
-                                   const Item& TheItem) 
-{
-  if ( SubRoot.IsNull() ) return SubRoot;
-  if ( Comp.IsLower(TheItem, SubRoot->Value()) ) {
-    return RecursiveFind(Comp, SubRoot->LeftChild(), TheItem);
-  }
-  if (Comp.IsGreater(TheItem, SubRoot->Value()) ) {
-    return RecursiveFind(Comp, SubRoot->RightChild(), TheItem);
-  }
-  return SubRoot;
-}
-
-//----------------------------------------------------------------------------
-Handle(Node) PCollection_HAVLSearchTree::Find(const Item& TheItem) const
-{
-  return RecursiveFind(TheComparator, TheRoot, TheItem);
-}
-
-//----------------------------------------------------------------------------
-// RotateRight
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::RotateRight(Handle(Node)& TheNode) const 
-{
-// the left child becomes the parent...
-  Handle(Node) Temp = TheNode->LeftChild();
-  TheNode->SetLeftChild(Temp->RightChild());
-  Temp->SetRightChild(TheNode);
-  TheNode = Temp;
-}
-
-//-----------------------------------------------------------------------------
-// RotateLeft
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::
-                      RotateLeft(Handle(Node)& TheNode) const 
-{
-// the right child becomes the parent...
-  Handle(Node) Temp = TheNode->RightChild();
-  TheNode->SetRightChild(Temp->LeftChild());
-  Temp->SetLeftChild(TheNode);
-  TheNode = Temp;
-}
-
-//-----------------------------------------------------------------------------
-// LeftBalance
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::LeftBalance(Handle(Node)& Root) const 
-{
-  Handle(Node) TheNode = Root->LeftChild();
-  if( Height(TheNode->LeftChild()) >= Height(TheNode->RightChild()) )  {
-    RotateRight(Root);
-    return;
-  }
-  RotateLeft(TheNode);
-  Root->SetLeftChild(TheNode);
-  RotateRight(Root);
-}
-
-//----------------------------------------------------------------------------
-// RightBalance
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::RightBalance(Handle(Node)& Root) const 
-{
-  Handle(Node) TheNode = Root->RightChild();
-  if( Height(TheNode->RightChild()) >= Height(TheNode->LeftChild())) {
-    RotateLeft(Root);
-    return;
-  }
-  RotateRight(TheNode);
-  Root->SetRightChild(TheNode);
-  RotateLeft(Root);
-}
-
-//-----------------------------------------------------------------------------
-// InsertBalance
-//-----------------------------------------------------------------------------
-Boolean PCollection_HAVLSearchTree::InsertBalance(Handle(Node)& Child, 
-                                            const Handle(Node)& Father,
-                                           const Side theSide) const 
-{
-// Balance after insertion
-  switch (Height(Child->LeftChild()) - Height(Child->RightChild())) {
-        case 2  : LeftBalance(Child);
-                  if (!Father.IsNull()) Father->SetChild(Child, theSide);
-                  return False;
-        case -2 : RightBalance(Child);
-                  if (!Father.IsNull()) Father->SetChild(Child, theSide);
-                  return False;
-        case 0  : return False;
-        default : return True;
-  }
-}
-
-//----------------------------------------------------------------------------
-// RemoveBalance
-//-----------------------------------------------------------------------------
-Boolean PCollection_HAVLSearchTree::
-                           RemoveBalance(Handle(Node)& Child, 
-                                          const Handle(Node)& Father,
-                                         const Side theSide) const 
-{
-// Balance after Remove           
-  switch (Height(Child->LeftChild()) - Height(Child->RightChild())) {
-         case 2  : LeftBalance(Child);
-                   if (!Father.IsNull()) Father->SetChild(Child, theSide);
-                  return True;
-         case -2 : RightBalance(Child);
-                   if (!Father.IsNull()) Father->SetChild(Child, theSide);
-                  return True;
-        default : return True;
-         }
-}
-
-//---------------------------------------------------------------------------
-// RecursiveInsert
-//-----------------------------------------------------------------------------
-Boolean PCollection_HAVLSearchTree::
-                           RecursiveInsert(Handle(Node)& Child,
-                                            const Handle(Node)& Father,
-                                           const Side theSide,
-                                            const Item& theItem,
-                                            Boolean& forOnce) const 
-{
-// FINDS WHERE TO INSERT theItem AND DOES IT
-  Handle(Node) Temp;
-  Boolean Result = False;
-  Integer Number;
-  if(TheComparator.IsLower(theItem, Child->Value())) {
-    Temp = Child->LeftChild();
-    if (Temp.IsNull()) {
-      Child->SetLeftChild( new Node(theItem));
-      return True;
-    }
-    Result = RecursiveInsert( Temp, Child, PCollection_Left,
-                               theItem, forOnce);
-    if(Result) return InsertBalance(Child, Father, theSide) ;
-    else return False;
-  }
-  else if (TheComparator.IsGreater(theItem, Child->Value())) {
-    Temp = Child->RightChild();
-    if (Temp.IsNull()) {
-      Child->SetRightChild( new Node(theItem));
-      return True;
-    }
-    Result = RecursiveInsert( Temp, Child, PCollection_Right, 
-                               theItem, forOnce);
-    if(Result) return InsertBalance(Child, Father, theSide);
-    else  return False;
-  }
-  else {
-//  ITEM FOUND // SET MULTIPLICITY
-    if (forOnce) {
-      forOnce = False;
-    }
-    else {
-      Number = Child->GetMultiplicity();
-      Child->SetMultiplicity(++Number);
-    }
-    return False;
-  }
-}
-
-//-----------------------------------------------------------------------------
-// RecursiveRemove
-//-----------------------------------------------------------------------------
-
-Boolean PCollection_HAVLSearchTree::RecursiveRemove(
-                                       Handle(Node)& Child, 
-                                       const Handle(Node)& Father, 
-                                      const Side theSide,
-                                       const Item& TheItem,
-                                      const Boolean ForAll) const
-{
-
-  Boolean Result;
-  Integer Number;
-// ITEM NOT FOUND
-  if (Child.IsNull()) NoSuchObject::Raise(); 
-  Handle(Node) TheLeft  = Child->LeftChild();
-  Handle(Node) TheRight = Child->RightChild();
-  if (TheComparator.IsLower(TheItem, Child->Value())) {
-    Result = RecursiveRemove( TheLeft, Child, 
-                               PCollection_Left, 
-                              TheItem, ForAll);
-  }
-  
-  else if (TheComparator.IsGreater(TheItem, Child->Value())) {
-    Result = RecursiveRemove( TheRight, Child, 
-                               PCollection_Right, 
-                               TheItem, ForAll);
-  }
-  else {                        
-//  theItem IS FOUND
-    Number = Child->GetMultiplicity();
-    Child->SetMultiplicity(--Number);
-//  SOMETIMES IT'S NOT NECESSARY REMOVING theItem
-    if (!ForAll && Number > 0) return True;
-//  IF IT IS, LOOKING FOR THE NEW VALUE OF Child
-    if (! TheLeft.IsNull() && ! TheRight.IsNull()) {
-//    Child HAS TWO CHILDREN
-      Handle(Node) T;
-      Handle(Node) Temp = TheRight;
-      while (! Temp.IsNull()) {
-        T = Temp;
-        Temp = Temp->LeftChild();
-      }
-//    WE HAVE FOUND THE GOOD NODE
-      Child->SetValue(T->Value());
-      Child->SetMultiplicity(T->GetMultiplicity());
-
-
-      const Item anItem = Child->Value();
-
-      Result = RecursiveRemove( TheRight, Child, PCollection_Right, 
-//JPT/RBA on sait pas pourquoi ? Child->Value(), ForAll);
-                               anItem, ForAll);
-    }
-    else {
-//    ONLY ONE CHILD, SO IT'S THE GOOD ONE
-// Mip-12-janv-93 : integration de la gestion memoire
-//      if (TheLeft.IsNull()) 
-//        Child = TheRight;
-//      else  
-//        Child = TheLeft;
-      Child.Delete();
-      if (TheLeft.IsNull()) { 
-        Child = TheRight;
-      }
-      else {  
-        Child = TheLeft;
-      }
-      Father->SetChild(Child, theSide);
-      return True;
-    }
-  }
-  if (Result) return RemoveBalance(Child, Father, theSide);
-  return False;   //     Child has not been found for now
-}
-
-//----------------------------------------------------------------------------
-// Insert
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::Insert (const Item& theItem)
-{
-  if (TheRoot.IsNull()) {
-     TheRoot = new Node(theItem);
-     return;
-  }
-  Handle(Node) Bid;
-  Boolean forOnce = False;
-  RecursiveInsert( TheRoot, Bid, PCollection_Left, theItem, forOnce);
-}
-
-//-----------------------------------------------------------------------------
-// InsertOnce
-//-----------------------------------------------------------------------------
-Boolean PCollection_HAVLSearchTree::InsertOnce (const Item& theItem)
-{
-  if (TheRoot.IsNull()) {
-    TheRoot = new Node(theItem);
-    return True;
-  }
-  Handle(Node) Bid;
-  Boolean forOnce = True;
-  RecursiveInsert( TheRoot, Bid, PCollection_Left, theItem, forOnce);
-  return forOnce;
-}
-
-//-----------------------------------------------------------------------------
-// Remove
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::Remove (const Item& theItem)
-{
-  Handle(Node) Bid;
-  RecursiveRemove( TheRoot, Bid, PCollection_Left, theItem, False);
-}
-
-//----------------------------------------------------------------------------
-// RemoveAll
-//-----------------------------------------------------------------------------
-void PCollection_HAVLSearchTree::RemoveAll (const Item& theItem)
-{
-  Handle(Node) Bid;
-  RecursiveRemove( TheRoot, Bid, PCollection_Left, theItem, True);
-}
-
-//----------------------------------------------------------------------------
-// Copy
-//-----------------------------------------------------------------------------
-Handle(Tree) PCollection_HAVLSearchTree::Copy() const 
-{
-  Handle(Tree) aTree = new Tree(TheComparator);
-  aTree->SetRoot(TheRoot->Copy());
-  return aTree;
-}
-
-//----------------------------------------------------------------------------
-// Merge
-//-----------------------------------------------------------------------------
-Handle(Tree) PCollection_HAVLSearchTree::Merge(const Handle(Tree)& aTree) const 
-{
-  Item theItem;
-  AVLIterator Iter( aTree);
-  Handle(Tree) newTree = Copy();
-  while( Iter.More()) {
-    theItem = Iter.Value()->Value();
-    newTree->Insert(theItem);
-    Iter.Next();
-  }
-  return newTree;
-}
-
-
-// ----------------------------------------------------------
-//
-// These methods must be implemented
-//
-// ----------------------------------------------------------
-
-Handle(Standard_Persistent) PCollection_HAVLSearchTree::ShallowCopy() const
-{
-
-cout << "HAVLSearchTree::ShallowCopy Not yet implemented" << endl;
-return This();
-}
-
-
-// ----------------------------------------------------
-// 
-//                                ShallowDump 
-// ----------------------------------------------------
-void PCollection_HAVLSearchTree::ShallowDump(Standard_OStream& S) const
-{
-cout << "HAVLSearchTree::ShallowDump Not yet implemented" << endl;
-}
-
-
-
diff --git a/src/PCollection/PCollection_HArbitraryTree.cdl b/src/PCollection/PCollection_HArbitraryTree.cdl
deleted file mode 100644 (file)
index 27717e9..0000000
+++ /dev/null
@@ -1,467 +0,0 @@
--- Created on: 1991-06-20
--- Created by: Annick PANCHER
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
--- Revised:     Mireille MERCIEN
-
-
-generic class HArbitraryTree from PCollection ( 
-               Item as Storable)
-
-
-    ---Purpose: Description of  a  tree  with an arbitrary  number  of
-    -- children  at   each  level.   Each    'node'   is   an
-    -- ArbitraryTree which knows its parent and its children.
-    -- An ArbitraryTree  can't  contain an empty  child.   To
-    -- separate  a  part  B from  an   ArbitraryTree A,  it's
-    -- possible to swap B with a Null tree: the parent A will
-    -- remove its child B, which is returned.
-    -- 
-    -- There are three iterators known  for an ArbitraryTree(
-    -- PreOrder,  PostOrder and InOrder).   Each  of  them
-    -- manages a stack whose depth is always less or equal to
-    -- the tree's  height, and which  describes the  way from
-    -- the root to the current tree. 
-  --  Warning: It could be a bad choice to use an ArbitraryTree for
-    -- a great number of items if it's frequently necessary 
-    -- to search them, for there is no optimisation to find
-    -- an item in an unordered tree. 
-    -- The same item can be stored several times in several places.
-
-inherits Persistent
-raises IsNotRoot    ,
-       IsNullTree   ,
-       IsContained  ,
-       NoMoreObject from Standard,
-       NoSuchObject from Standard,
-       OutOfRange   from Standard
-
-
-    class SeqArbitraryTree instantiates 
-                HSequence from PCollection(HArbitraryTree);
-    class StackArbitraryTree instantiates 
-                HStack from PCollection(HArbitraryTree);
-        
-    class ATPreOrderIterator 
-
-        ---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)
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is        
-
-       Create( theTree : HArbitraryTree) 
-            ---Purpose: Creates an iterator on <theTree>.
-             returns ATPreOrderIterator;
-
-       More( me) 
-           ---Purpose: Returns True if there is at least one element to be read.
-            ---Level: Public
-            returns Boolean from Standard;
-           
-       Next( me : in out) raises NoMoreObject from Standard; 
-            ---Purpose: Manages currentStack  which  always  contains
-            -- the way from the root to the  next leaf to be
-            -- visited.  Updates currentTree.
-             ---Level: Public
-
-       Value( me )
-            ---Purpose: Returns the current element.   
-            ---Level: Public
-           returns mutable HArbitraryTree
-           raises NoSuchObject from Standard;
-           
-       Clear( me : in out);
-           ---Purpose: Empties <me>, so that More() will answer False.
-            ---Level: Public
-
-
-        
-       RecursiveRemove( me : in out; aTree : HArbitraryTree)
-           ---Purpose: Removes the end of currentStack until finding a 
-           -- tree having a right sibling: removes it too, and returns it.
-           returns mutable HArbitraryTree
-            ---Level: Internal
-           is private;
-           
-    fields 
-       HasMore     : Boolean from Standard;
-       CurrentTree : HArbitraryTree;
-       CurrentStack: StackArbitraryTree;           
-    end;
-
-
-    class ATPostOrderIterator
-
-        ---Purpose: Permits to iterate through an ArbitraryTree beginning by 
-        -- the most left leave and its rightSibling, then upward to its parent.
-        -- IF theTree is (  A (B (C D E)) F G (H (I J K)))
-        -- THEN it will read ( C D E B F I J K H G A)
-       
-    raises NoMoreObject from Standard,
-           NoSuchObject from Standard
-          
-    is    
-
-       Create( theTree : HArbitraryTree) 
-           ---Purpose: Creates an iterator on the tree theTree
-            returns ATPostOrderIterator;
-
-       More( me) returns Boolean from Standard;
-           ---Purpose: Returns True if there is at least one element to
-           -- be read.
-            ---Level: Public
-
-       Next( me : in out) raises NoMoreObject from Standard; 
-           ---Purpose: Sets the iterator on the next element
-            ---Level: Public
-
-       Value( me) 
-            ---Level: Public
-           returns mutable HArbitraryTree
-           raises NoSuchObject from Standard;
-           
-       Clear( me : in out);
-           ---Purpose: Empties <me>, so that More() will answer False
-            ---Level: Public
-       
-       RecursiveAppend( me : in out; aTree : HArbitraryTree)
-           ---Purpose: adds a new branch to currentStack, until
-           -- reaching a leaf; the branch's parent is <aTree>
-            ---Level: Internal
-           is private;
-           
-    fields
-       HasMore     : Boolean from Standard;
-       CurrentTree : HArbitraryTree;
-       CurrentStack: StackArbitraryTree;
-           
-    end;
-
-
-    class ATInOrderIterator
-
-        ---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)
-
-    raises NoMoreObject from Standard, 
-           NoSuchObject from Standard
-    is
-    
-       Create( theTree : HArbitraryTree) 
-           ---Purpose: Create an iterator on the tree theTree
-            returns ATInOrderIterator;
-           
-       More( me) returns Boolean from Standard;
-           ---Purpose: Returns True if there is at least one element to be read.
-            ---Level: Public
-
-       Next( me : in out) raises NoMoreObject from Standard; 
-           ---Purpose: Sets the iterator to the next element.
-            ---Level: Public
-
-       Value( me) 
-           returns mutable HArbitraryTree
-           raises NoSuchObject from Standard;
-            ---Level: Public
-           
-       Clear( me : in out);
-           ---Purpose: Empties <me>, so that More() will answer False.
-            ---Level: Public
-
-       RecursiveAppend( me : in out; aTree : HArbitraryTree)
-           ---Purpose: Adds to currentStack a new branch of the tree,
-           -- which has not been visited; this branch's parent is <aTree>.
-            ---Level: Internal
-           is private;
-           
-       RecursiveRemove( me : in out; aTree : HArbitraryTree)
-           ---Purpose: Removes from currentStack one or more trees,
-           -- which have already been visited and have no
-           -- more children not visited; the first tree
-           -- removed is <aTree>.
-            ---Level: Internal
-           returns mutable HArbitraryTree
-           is private;
-           
-    fields
-       HasMore     : Boolean from Standard;
-       CurrentTree : HArbitraryTree;
-       CurrentStack: StackArbitraryTree;
-    end;
-
-
-is 
-
-    
-    Create ( TheItem : Item) 
-        ---Purpose: Creation of a root tree of value Item with no child(e.g. a leaf)
-        --  Example:
-        -- if <TheItem> = i0 
-        -- returns
-        --  ( i0 )
-        -- The field <MyParent> is Null and so is <MyChildren>.
-       returns mutable HArbitraryTree;
-               
-    Children( me)
-       ---Purpose: Reads all children of <me>, to be able to know the
-       -- location of one of them.
-        ---Level: Internal
-       returns mutable SeqArbitraryTree
-       is private;
-
-    Child( me; Index : Integer from Standard) 
-       ---Purpose: Returns the child of <me> at the range <Index>.
-       -- Raises an exception if <Index> is out of range.
-       --  Example:Before
-       --   me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ), Index = 2
-       -- After
-       --   me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) )
-       -- returns   (i2)
-        ---Level: Public
-       returns mutable HArbitraryTree 
-        raises OutOfRange from Standard;
-
-    Value( me) returns any Item;
-       ---Purpose: Returns the value of <me>.
-       --  Example:Before and After
-       --   me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) )
-       -- returns  i0
-        ---Level: Public
-
-    NbChildren( me) returns Integer from Standard;
-       ---Purpose: Returns the number of children of me.
-       --  Example: me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) )
-       -- returns 3
-        ---Level: Public
-
-    IsLeaf( me) returns Boolean from Standard;
-       ---Purpose: Returns True if the tree <me> is a leaf.
-       --  Example: me = ( i0 )
-       -- returns True
-        ---Level: Public
-
-    Parent( me) 
-       ---Purpose: Returns the father of <me>.
-       -- The returned ArbitraryTree can be Null.
-       --  Example: if T = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ) and 
-       --   me = ( i1 (i4 i5) )
-       -- returns T.
-        ---Level: Public
-       returns mutable HArbitraryTree;
-       
-    IsRoot( me)
-       ---Purpose: Returns True if <me> has no father.
-        ---Level: Public
-        returns Boolean from Standard;
-
-    Root( me) 
-       ---Purpose: Returns the root of the tree <me>.
-       -- If <me> is a root, returns <me>
-       --  Example: if T = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ) and 
-       --   me = (i1( i4 i5 )) and T->IsRoot == True
-       -- returns  T 
-        ---Level: Public
-       returns mutable HArbitraryTree ;
-
-    LeftSibling( me) 
-       ---Purpose: Returns the left neighbour of the tree <me>.
-       -- May return a Null tree.
-       -- if T = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ) 
-       --   and me = (i2)
-       -- returns  ( i1 (i4 i5) )
-        ---Level: Public
-        returns mutable HArbitraryTree;
-
-    RightSibling( me) 
-       ---Purpose: Returns the right neighbour of the tree <me>.
-       -- May return a Null tree.
-       --  Example: if T = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ) 
-       --   and  me = (i2)
-       -- returns  ( i3 (i6 i7) )
-        ---Level: Public
-        returns mutable HArbitraryTree;
-
-    Contains( me; aTree: HArbitraryTree)
-       ---Purpose: Checks <aTree> is contained by <me>.
-        ---Level: Public
-       returns Boolean from Standard
-       raises IsNullTree ;
-
-    SetValue( me : mutable ; theItem : Item) ;
-        ---Purpose: Changes the value of MyItem.
-        --  Example: before
-        --   me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ), theItem= i10
-        -- after
-        --   me = ( i10 (i1 (i4 i5) i2 i3 (i6 i7) ) )
-        ---Level: Public
-
-    SwapChild( me : mutable ; Index : Integer from Standard; 
-              WithTree : in out mutable HArbitraryTree)
-       ---Purpose: Replaces the child of <me> at range <Index> by <WithTree>
-       -- and conversely.
-       -- Only removes Child at range <Index> if <WithTree> is Null.
-       --  Trigger: Raises an exception if <Index> is greater than NbChildren;
-       -- raises IsNotRoot if <WithTree> is not a root;
-       --  Example: Before
-       --   me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ), 
-       --   Index = 2,  WithTree = ( i8 (i9  i10) )
-       -- After
-       --   me = ( i0 (i1 (i4 i5) i8 (i9 i10) i3 (i6 i7) ) )
-       --   WithTree = (i2)
-        ---Level: Public
-        raises OutOfRange from Standard, 
-               IsNotRoot;
-
-    SwapChildren( me : mutable ; subtree1, subtree2 : mutable HArbitraryTree)
-       ---Purpose: TradeOff between two subtrees of <me>.
-       --  Example: Before
-       --   me = ( i0 (i1 (i4 i5) i2 i3 (i6 i7) ) ), 
-       --   subtree1 = (i4), subtree2 = (i3 (i6 i7)),
-       -- After
-       --   me = ( i0 (i1 ( i3 (i6 i7) i5)  i2 i4))
-       --  Trigger:Raises an  exception if <subtree1>  or  <subtree2>
-       -- are not subtrees of <me>.
-       -- Raises an exception if one of the  two subtrees is
-       -- contained by the other one.For instance :
-       --  Example: IF subtree1 = (i3( i6 i7)) and subtree2 = (i6).
-        -- Raises an exception if one of the two subtrees is null.
-        ---Level: Public
-        raises OutOfRange from Standard, 
-               NoSuchObject from Standard, 
-               IsContained,
-              IsNullTree;
-              
-    AppendChild( me: mutable; theTree: HArbitraryTree)
-       ---Purpose: Appends <theTree> as last child of <me>
-       --  Example:
-       -- Before
-       --   me = ( i0 ( i1 i2 i3)) 
-       --   theTree = ( i4)
-       -- After
-       --   me = ( i0 ( i1 i2 i3 i4))
-       --  Trigger: Raises IsNotRoot if <theTree> is not a root.
-               -- Raises IsNullTree if <theTree> is Null.
-        ---Level: Public
-       raises IsNotRoot, 
-               IsNullTree;
-       
-    PrependChild( me: mutable; theTree: HArbitraryTree)
-       ---Purpose: Appends <theTree> as first child of <me>.
-       --  Example:
-       -- Before
-       --   me = ( i0 ( i1 i2 i3)) 
-       --   theTree = ( i4)
-       -- After
-       --   me = ( i0 ( i4 i1 i2 i3))
-       --  Trigger: Raises IsNotRoot if <theTree> is not a root.
-               -- Raises IsNullTree if <theTree> is Null.
-        ---Level: Public
-       raises IsNotRoot, 
-               IsNullTree;
-
-    InsertChildBefore( me : mutable; Index : Integer from Standard;
-                      theTree: HArbitraryTree)
-        ---Purpose: Adds   <theTree> to  the   field  <MyChildren>, at
-        -- <Index>, and all  children  from <Index> pushed on
-        -- the right.
-       --  Example: Before
-       --   me = ( i0 ( i1 i2 i3)) 
-       --   theTree = ( i4), Index = 2
-       -- After
-       --   me = ( i0 ( i1 i4 i2 i3))
-        -- Trigger: Raises  OutOfRange if   <Index>  is  greater  than
-        -- NbChildren.         
-        -- Raises IsNotRoot if <theTree> is not a root.
-        -- Raises IsNullTree if <theTree> is Null.
-        ---Level: Public
-       raises OutOfRange from Standard, 
-               IsNotRoot, 
-               IsNullTree;
-       
-    InsertChildAfter( me: mutable; Index: Integer from Standard;
-                     theTree: HArbitraryTree)
-        ---Purpose: Adds <theTree> to  <MyChildren>, at <Index>+1, and
-        -- all children from <Index>+1 pushed on the right.
-               --  Example: Before
-       --   me = ( i0 ( i1 i2 i3)) 
-       --   theTree = ( i4), Index = 2
-       -- After
-       --   me = ( i0 ( i1 i2 i4 i3))
-        --  Trigger: Raises OutOfRange if <Index> is greater than NbChildren
-       -- Raises IsNotRoot if <theTree> is not a root
-               -- Raises IsNullTree if <theTree> is Null
-        ---Level: Public
-       raises OutOfRange from Standard, 
-               IsNotRoot, 
-               IsNullTree;
-           
-    RemoveChild( me : mutable; Index: Integer from Standard)
-       ---Purpose: Removes from <MyChildren> the ArbitraryTree at range <Index>. 
-       --  Example: Before
-       --   me = ( i0 ( i1 i2 i3 i4)) and Index = 2
-       -- After
-       --   me = ( i0 ( i1 i3 i4))
-        --  Trigger: Raises OutOfRange if <Index> is greater than NbChildren
-        ---Level: Public
-       raises OutOfRange from Standard;
-       
-    RemoveAllChildren( me: mutable);
-       ---Purpose: Removes all my children.
-        ---Level: Public
-    
-    RemoveChildren( me: mutable; FromIndex, ToIndex : Integer from Standard)
-       ---Purpose: Removes from <MyChildren> all the ArbitraryTree 
-       -- located from range <FromIndex> to <ToIndex>.
-       --  Example: Before
-       --   me = ( i0 ( i1 i2 i3 i4)) 
-       --   FromIndex = 2 and ToIndex = 4
-       -- After
-       --   me = ( i0 ( i1))
-        --  Trigger: Raises OutOfRange if <FromIndex> or <ToIndex> is 
-        -- greater than NbChildren.
-        ---Level: Public
-       raises OutOfRange from Standard; 
-
-    SetParent( me : mutable; theTree : HArbitraryTree)
-       ---Purpose: Changes the value of MyParent.
-        ---Level: Internal
-       is private;
-
-
-    ShallowCopy(me) returns mutable like me 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-    ShallowDump (me; s: in out OStream) 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-fields
-
-    MyParent  : HArbitraryTree;
-    MyItem    : Item;
-    MyChildren: SeqArbitraryTree;
-end;
diff --git a/src/PCollection/PCollection_HArbitraryTree.gxx b/src/PCollection/PCollection_HArbitraryTree.gxx
deleted file mode 100644 (file)
index 2ab3fef..0000000
+++ /dev/null
@@ -1,320 +0,0 @@
-// Created on: 1992-08-05
-// Created by: Mireille MERCIEN
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_OutOfRange.hxx>
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-#include <PCollection_IsNotRoot.hxx> 
-#include <PCollection_IsNullTree.hxx> 
-#include <PCollection_IsContained.hxx>
-
-// ----------------------------------------------------------------------
-// ----------------------------------------------------------------------
-
-// -----------
-// constructor :
-// -----------
-PCollection_HArbitraryTree::PCollection_HArbitraryTree(const Item& T) 
-{
-  MyItem = T;
-  MyChildren = new PCollection_SeqArbitraryTree;
- } 
-
-// -----------------------------------------------
-// Children : Returns the list of children of me
-// -----------------------------------------------
-Handle(PCollection_SeqArbitraryTree) 
-       PCollection_HArbitraryTree::Children() const 
-{
-   return MyChildren;
-}
-
-// ----------------------
-// Child : returns a child 
-// ----------------------
-Handle(PCollection_HArbitraryTree) 
-    PCollection_HArbitraryTree::Child(const Standard_Integer Index) const
-{
-   return MyChildren->Value(Index);
-}  
-
-// ----------------------------------------------
-// Value : returns the value of the current tree
-// ----------------------------------------------
-Item PCollection_HArbitraryTree::Value() const
-{
-   return MyItem;
-}
-
-// ----------------------------------------------------
-// NbChildren : Number of children in the current tree 
-// ----------------------------------------------------
-Standard_Integer PCollection_HArbitraryTree::NbChildren() const
-{
-      return (MyChildren->Length());
-}
-
-// -------------------------------------------------------
-// IsLeaf : Returns True if the current tree has no child
-// -------------------------------------------------------
-Standard_Boolean PCollection_HArbitraryTree::IsLeaf() const
-{
-   return (MyChildren->IsEmpty());
-}
-
-// ----------------------
-// Parent
-// ----------------------
-Handle(PCollection_HArbitraryTree) PCollection_HArbitraryTree::Parent() const
-{
-   return MyParent;
-}
-
-// ----------------------
-// IsRoot
-// ---------------------
-Standard_Boolean PCollection_HArbitraryTree::IsRoot() const
-{
-   return (MyParent.IsNull());
-}
-// ---------------------------------------------
-// Root : Returns the root of the current tree
-// ---------------------------------------------
-Handle(PCollection_HArbitraryTree) PCollection_HArbitraryTree::Root() const
-{
-   Handle(PCollection_HArbitraryTree) AParent;
-   AParent = this;
-   while ( !AParent->IsRoot() )  AParent = AParent->Parent();
-   return AParent;
-}
-
-// ----------------------------------------------------------------
-   // LeftSibling : returns the left neighbour of the current tree
-// ----------------------------------------------------------------
-Handle(PCollection_HArbitraryTree) PCollection_HArbitraryTree::LeftSibling() const
-{
-   Handle(PCollection_HArbitraryTree) MySelf,TheParent,NullTree;
-   Handle(PCollection_SeqArbitraryTree) TheBrothers;
-   NullTree.Nullify();
-   MySelf = this;
-   if (MySelf->IsRoot()) return NullTree;
-   TheBrothers = (MySelf->Parent())->Children();
-   Standard_Integer TheIndex = TheBrothers->Location(1,MySelf);
-   if (TheIndex <= 1) 
-       return NullTree; 
-   else
-       return (TheBrothers->Value(TheIndex-1));  
-}   
-
-// ---------------------------------------------------------------
-// RightSibling : returns the right neighbour of the current tree
-// ---------------------------------------------------------------
-Handle(PCollection_HArbitraryTree) PCollection_HArbitraryTree::RightSibling() const
-{
-   Handle(PCollection_HArbitraryTree) MySelf,TheParent,NullTree;
-   Handle(PCollection_SeqArbitraryTree) TheBrothers;
-   NullTree.Nullify();
-   MySelf = this;
-    if (MySelf->IsRoot()) return NullTree;
-   TheBrothers = (MySelf->Parent())->Children();
-   Standard_Integer TheIndex = TheBrothers->Location(1,MySelf);
-   if (TheIndex == TheBrothers->Length()) 
-       return NullTree; 
-   else
-       return (TheBrothers->Value(TheIndex+1));  
-}   
-
-// --------------------------------------------------------------------
-// Contains : checks if the tree Atree is contained by the current one
-// --------------------------------------------------------------------
-Standard_Boolean PCollection_HArbitraryTree::Contains
-     (const Handle(PCollection_HArbitraryTree)& ATree) const
-{
-  if (ATree.IsNull()) PCollection_IsNullTree::Raise();
-  Handle(PCollection_HArbitraryTree) MySelf = this;
-  Standard_Boolean IsFound = Standard_False;
-  PCollection_ATPreOrderIterator Iter(MySelf); 
-  while (!IsFound && Iter.More())  {
-      if (Iter.Value() == ATree)  IsFound = Standard_True;
-      Iter.Next();
-    }
-  return IsFound;  
-}
-
-// -------------------------------------------------
-// SetValue : changes the value of the current tree
-// -------------------------------------------------
-void PCollection_HArbitraryTree::SetValue(const Item& T) 
-{
-   MyItem = T;
-}
-
-// ---------------------------------------------------------
-// SetParent : changes the parent value of the current tree
-// ---------------------------------------------------------
-void PCollection_HArbitraryTree::SetParent
-       (const Handle(PCollection_HArbitraryTree)& ATree) 
-{
-   MyParent = ATree;
-}
-
-// ---------------------------------------------------------------------
-// SwapChild : replace, in the current tree, the child at the range
-//             <Index> by the tree <ATree> and conversely
-// ---------------------------------------------------------------------
-void PCollection_HArbitraryTree::SwapChild
-       (const Standard_Integer Index,Handle(PCollection_HArbitraryTree)& ATree) 
-{
-   if (!ATree.IsNull() && !ATree->IsRoot()) PCollection_IsNotRoot::Raise(); 
-   Handle (PCollection_HArbitraryTree) TempTree = ATree;
-   Handle (PCollection_HArbitraryTree) NullTree;
-   NullTree.Nullify();
-// ... Update the returned tree
-   ATree = Child(Index);   
-   ATree->SetParent(NullTree);
-// ... Update the current tree
-   if (! TempTree.IsNull()) InsertChildAfter(Index,TempTree);
-   MyChildren->Remove(Index);   
-}
-
-// -----------------------------------------------------------------
-// SwapChildren : TradeOff between two subtrees in the current tree
-// -----------------------------------------------------------------
-void PCollection_HArbitraryTree::SwapChildren
-          ( const Handle(PCollection_HArbitraryTree)& Subtree1,
-            const Handle(PCollection_HArbitraryTree)& Subtree2    )  
-{  
-   if (Subtree1.IsNull()  || Subtree2.IsNull())
-                                     PCollection_IsNullTree::Raise();   
-   if (!Contains(Subtree1) || !Contains(Subtree2)) 
-                                     Standard_NoSuchObject::Raise();
-   if (Subtree1->Contains(Subtree2) || Subtree1->Contains(Subtree2))
-                                     PCollection_IsContained::Raise(); 
-   Handle(PCollection_HArbitraryTree) Parent1 = Subtree1->Parent(); 
-   Handle(PCollection_HArbitraryTree) Parent2 = Subtree2->Parent();
-   Handle(PCollection_SeqArbitraryTree) 
-                                    Children1 = Parent1->Children(); 
-   Handle(PCollection_SeqArbitraryTree)  
-                                    Children2 = Parent2->Children(); 
-
-// ... Searching the index of the subtrees. 
-   Standard_Integer Ind1 = Children1->Location(1,Subtree1);
-   Standard_Integer Ind2 = Children2->Location(1,Subtree2);
-// ... Insertion of Subtree2
-   Handle(PCollection_HArbitraryTree) NullTree;
-   NullTree.Nullify();
-   Subtree2->SetParent(NullTree);
-   Parent1->InsertChildAfter(Ind1,Subtree2);
-   Children1->Remove(Ind1);
-// ... Insertion of Subtree1
-   Subtree1->SetParent(NullTree);
-   Parent2->InsertChildAfter(Ind2,Subtree1);
-   Children2->Remove(Ind2);
-}
-
-// -----------------------------------------------------------------------
-// AppendChild : appends the tree <Atree> as last child of the current tree
-// -----------------------------------------------------------------------
-void PCollection_HArbitraryTree::AppendChild
-               (const Handle(PCollection_HArbitraryTree)& ATree)  
-{
-  if (ATree.IsNull()) PCollection_IsNullTree::Raise();
-  if (!ATree->IsRoot()) PCollection_IsNotRoot::Raise();
-
-  Handle (PCollection_HArbitraryTree) MySelf = this;
-  ATree->SetParent(MySelf);
-  MyChildren->Append(ATree);
-}
-
-// --------------------------------------------------------------------------
-// PrependChild : appends the tree <ATree> as first child of the current tree
-// --------------------------------------------------------------------------
-void PCollection_HArbitraryTree::PrependChild
-               (const Handle(PCollection_HArbitraryTree)& ATree)  
-{
-  if (ATree.IsNull()) PCollection_IsNullTree::Raise();
-  if (!ATree->IsRoot()) PCollection_IsNotRoot::Raise();
-
-  Handle (PCollection_HArbitraryTree) MySelf = this;
-  ATree->SetParent(MySelf);
-  MyChildren->Prepend(ATree);
-
-}
-
-// -----------------------------------------------------------------------
-// InsertChildBefore : adds the child <ATree> at the index <Index> in the 
-//                     current tree  
-// -----------------------------------------------------------------------
-void PCollection_HArbitraryTree::InsertChildBefore
-   (const Standard_Integer Index , 
-    const Handle(PCollection_HArbitraryTree)& ATree) 
-{
-  if (ATree.IsNull()) PCollection_IsNullTree::Raise();
-  if (!ATree->IsRoot()) PCollection_IsNotRoot::Raise();
-
-  Handle (PCollection_HArbitraryTree) MySelf = this;
-  ATree->SetParent(MySelf);
-  MyChildren->InsertBefore(Index,ATree);
-}
-
-// ------------------------------------------------------------------------
-// InsertChildAfter : adds the child <ATree> at the index <Index+1> in the
-//                    current tree
-// ------------------------------------------------------------------------
-void PCollection_HArbitraryTree::InsertChildAfter
-      (const Standard_Integer Index , 
-       const Handle(PCollection_HArbitraryTree)& ATree) 
-{
-  if (ATree.IsNull()) PCollection_IsNullTree::Raise();
-  if (!ATree->IsRoot()) PCollection_IsNotRoot::Raise();
-
-  Handle (PCollection_HArbitraryTree) MySelf = this;
-  ATree->SetParent(MySelf);
-  MyChildren->InsertAfter(Index,ATree);
-}
-
-// ---------------------------------------------------------------------
-// RemoveChild : removes the child at range <Index> in the current tree
-// ---------------------------------------------------------------------
-void PCollection_HArbitraryTree::RemoveChild(const Standard_Integer Index)  
-{
-  MyChildren->Remove(Index);
-}
-
-// -------------------------------------------------------------
-// RemoveAllChildren : removes all children of the current tree
-// -------------------------------------------------------------
-void PCollection_HArbitraryTree::RemoveAllChildren()  
-{
-   MyChildren->Clear();
-}
-
-// --------------------------------------------------------------------------
-// RemoveChildren : removes the children in range <FromIndex,ToIndex> in the
-//                  current tree 
-// --------------------------------------------------------------------------
-void PCollection_HArbitraryTree::RemoveChildren
-       (const Standard_Integer FromIndex , const Standard_Integer ToIndex)  
-{
-  MyChildren->Remove(FromIndex,ToIndex);
-}
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HDataMap.cdl b/src/PCollection/PCollection_HDataMap.cdl
deleted file mode 100644 (file)
index ee55e07..0000000
+++ /dev/null
@@ -1,234 +0,0 @@
--- Created on: 1992-02-19
--- Created by: Jean Pierre TIRAULT
--- Copyright (c) 1992-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
--- Revised:    Thu Jan  7 17:26:12 1993
--- By     :    Mireille MERCIEN
-
-
-generic class HDataMap from PCollection  (Key as Storable; 
-                                     Item as Storable;
-                                     FH as Hash(Key) )
-inherits Persistent
-
-       ---Purpose: A map is a Collection of bindings
-       -- between two objects. One is considered as
-       -- the key and a hash code value must be 
-       -- computed for it.
-
-
-raises  MultiplyDefined from Standard,
-        NoMoreObject    from Standard,
-        NoSuchObject    from Standard
-        
-
-
-  
-    class MapNode inherits PManaged
-       ---Purpose: This class is used in the implementation of Map class.
-     is
-     
-        Create( aKey : Key ; anItem : Item ; aNext : MapNode)
-           returns mutable MapNode from PCollection;
-
-       GetKey (me) returns any Key is static;
-        ---Level: Internal
-       ---Purpose: Returns myKey
-
-       Value(me) returns any Item is static;
-        ---Level: Internal
-       ---Purpose: Returns myItem.
-       
-       Next(me) returns mutable MapNode is static;
-        ---Level: Internal
-           ---Purpose: Returns myNext.
-
-       SetKey (me : mutable ; aKey : Key) is static;
-        ---Level: Internal
-       ---Purpose: Modifies myKey.
-
-       SetValue( me : mutable; anItem: Item) is static;
-            ---Level: Internal
-           ---Purpose: Modifies myItem.
-
-       SetNext( me : mutable; aNode: MapNode) is static;
-            ---Level: Internal
-           ---Purpose: Modifies myNext.
-
-       ShallowCopy(me) returns mutable like me 
-               is redefined;
-            ---Level: Internal
-            ---Purpose: ShallowCopy redefinition
-           ---C++: function call
-
-       ShallowDump (me; s: in out OStream) 
-               is redefined;
-            ---Level: Internal  
-           ---Purpose: ShallowDump redefinition
-           ---C++: function call
-
-    fields
-
-        myKey      : Key;
-       myItem     : Item;
-       myNext     : MapNode;
-
-    end;
-       
-    class Array instantiates HArray1 from PCollection(MapNode);
-       
-    class MapIterator
-
-    raises NoMoreObject from Standard, 
-           NoSuchObject from Standard
-    is
-       ---Purpose: This class provides to iterate on a Map from the
-       -- first bucket entry to the last one in the table;
-       -- Going through the associated list for each bucket entry.
-                    
-       Create( aMap: HDataMap)
-           ---Purpose: Creates an iterator on <aMap> .
-           returns MapIterator;
-
-       More( me)
-            ---Level: Public
-           ---Purpose: Returns True if there is still an element to be read.
-           returns Boolean from Standard;
-           
-       Next( me: in out) raises NoMoreObject from Standard;
-            ---Level: Public
-           ---Purpose: Goes to next element of <me>.
-    
-       Value( me)
-            ---Level: Public
-           returns any Item
-           raises NoSuchObject from Standard;
-           
-       GetKey( me)
-            ---Level: Public
-           returns Key
-           raises NoSuchObject from Standard;
-           
-    fields
-        Buckets     : Array;
-       NbBuck      : Integer;
-       Index       : Integer;
-       Node        : MapNode;
-        HasMore     : Boolean;
-    end;
-
-is     
-       Create(NbBuckets : Integer ; F : FH) returns mutable HDataMap;
-               ---Purpose: Creation of a map of NbBuckets entries.
-               -- the table is empty.
-                -- If NbBuckets eq. 0 an exception will be raised.
-                    
-       NbBuckets(me) returns Integer from Standard;
-                ---Level: Public
-               ---Purpose: Returns the number of entries in the table.
-
-       IsEmpty(me) returns Boolean from Standard;
-                ---Level: Public
-               ---Purpose:  Returns true if the table is empty.
-
-       Extent(me) returns Integer from Standard ;
-                ---Level: Public
-               ---Purpose:  Returns the number of elements in the table.
-               ---Example: if me is the hash table ((a x)(b y)(c z)) Extent
-               -- returns 3
-
-       IsBound(me; K : Key) returns Boolean;
-                ---Level: Public
-               ---Purpose: Returns True if an element is bounded to K
-
-       Find(me; K : Key) returns  any Item raises NoSuchObject;
-                ---Level: Public
-               ---Purpose: Returns the element bounded to K.
-               -- Raises an exception if the binding does not exist.
-               ---Example: before
-               --   me = ((a x)(b y)(c z)) , K = b
-               -- returns y
-
-       Clear(me:mutable);
-                ---Level: Public
-               ---Purpose: Removes all the element in the table.
-               ---Example: before
-               --   me = ((a x)(b y)(c z))
-               -- after
-               --   me = ()
-
-       Bind(me:mutable; K : Key; T : Item) 
-           raises MultiplyDefined;
-                ---Level: Public
-               ---Purpose: Creates a binding between a key K and an item T.
-               -- Raises an exception if the binding already exists.
-               ---Example: before
-               --   me = ((a x)(b y)) , K = c , T = z
-               -- after
-               --   me = ((a x)(b y)(c z))
-
-       Rebind(me:mutable; K : Key; T : Item) raises NoSuchObject;
-                ---Level: Public
-               ---Purpose: Replaces the object binded to the key K by T.
-               -- Raises an exception if the binding does not exist.
-               ---Example: before
-               --   me = ((a x)(b y)) , K = b , T = z
-               -- after
-               --   me = ((a x)(b z))
-
-       Unbind(me:mutable; K : Key) raises NoSuchObject;
-                ---Level: Public
-               ---Purpose:  Removes the binding keyed by K.
-               -- Raises an exception if the binding does not exist.
-               ---Example: before
-               --   me = ((a x)(b y)(c z)) , K = b
-               -- after
-               --   me = ((a x)(c z))
-       
-       ShallowCopy(me) returns mutable like me 
-               is redefined;
-                ---Level: Advanced
-               ---Purpose: ShallowCopy redefinition
-               ---C++: function call
-
-
-       ShallowDump (me; s: in out OStream) 
-               is redefined;
-                ---Level: Advanced
-               ---Purpose: ShallowDump redefinition
-               ---C++: function call
-
-
-        GetArray (me) returns Array is private;
-                ---Level: Internal
-               ---Purpose :Returns the field Buckets associated to the object.
-               ---C++: inline
-
-        GetFH (me) returns FH is private;
-                ---Level: Internal
-               ---Purpose :Returns the field Hash associated to the object.
-               ---C++: inline
-
-fields 
-       Buckets : Array;
-       Hash    : FH;
-
-friends class MapIterator from PCollection
-
-end HDataMap;
-
-
-
-
diff --git a/src/PCollection/PCollection_HDataMap.gxx b/src/PCollection/PCollection_HDataMap.gxx
deleted file mode 100644 (file)
index 26de390..0000000
+++ /dev/null
@@ -1,260 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_MultiplyDefined.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-// ----------------------------------------------------------------------
-// Map implementation:
-// Last Revision : Jan,8 1993 M. Mercien
-//                 The class SingleList is no more referenced in the 
-//                 implementation of Map.
-// ----------------------------------------------------------------------
-
-//----------------------------------------------------------------- 
-// Constructor 
-//----------------------------------------------------------------- 
-PCollection_HDataMap::PCollection_HDataMap(const Integer NbBuckets,
-                                 const FH& F)
-{
-   Buckets = new PCollection_Array( 1 , NbBuckets);
-   Hash = F;
-}
-
-
-// ------------------------ READING --------------------------------
-
-//----------------------------------------------------------------- 
-// NbBuckets : Return the number of buckets
-//----------------------------------------------------------------- 
-Integer PCollection_HDataMap::NbBuckets() const
-{
-   return Buckets->Length();
-}
-
-//----------------------------------------------------------------- 
-// IsEmpty : Return TRUE if the map is empty
-//----------------------------------------------------------------- 
-Boolean PCollection_HDataMap::IsEmpty() const 
-{
-   Handle(PCollection_MapNode) aNode;
-   Boolean Empty = True;
-   for (Integer i = 1 ; i <= Buckets->Length() ; i++) {
-      aNode = Buckets->Value(i);
-      if ( !aNode.IsNull() ) Empty = False;
-   }
-   return Empty;
-}
-
-//----------------------------------------------------------------- 
-// Extent : Returns the number of couples (item,key) contained in 
-//          the map.
-//----------------------------------------------------------------- 
-Integer PCollection_HDataMap::Extent() const 
-{
-   Integer Number = 0;
-   Handle(PCollection_MapNode) aNode;
-   for (Integer i = 1 ; i <= Buckets->Length() ; i++) {
-     aNode = Buckets->Value(i);
-     while ( !aNode.IsNull() ) {
-        Number++;
-        aNode = aNode->Next();
-     }
-   }
-   return Number;
-}
-
-//----------------------------------------------------------------- 
-// IsBound : Returns TRUE if an element is bounded by K
-//----------------------------------------------------------------- 
-Boolean PCollection_HDataMap::IsBound(const Key& K ) const 
-{
-   Integer Res;
-   Key TheKey;
-   Handle(PCollection_MapNode) aNode;
-   Res = Hash.HashCode (K,Buckets->Length());  
-   aNode = Buckets->Value(Res);
-   while ( !aNode.IsNull() ) {
-     TheKey = aNode->GetKey();
-     if ( Hash.Compare(TheKey,K) ) return True;
-     else aNode = aNode->Next();
-   }
-   return False;
-}
-
-//----------------------------------------------------------------- 
-// Find : Returns the element bounded by K
-//----------------------------------------------------------------- 
-Item PCollection_HDataMap::Find(const Key& K ) const 
-{
-   Integer Res;
-   Key TheKey;
-   Handle(PCollection_MapNode) aNode;
-   Res = Hash.HashCode (K,Buckets->Length());  
-   aNode = Buckets->Value(Res);
-   while ( ! aNode.IsNull() )  {
-     TheKey = aNode->GetKey();
-     if ( Hash.Compare(TheKey,K) ) return aNode->Value();
-     else aNode = aNode->Next();
-   }
-   NoSuchObject::Raise();
-}
-
-// ------------------------ WRITING --------------------------------
-
-//----------------------------------------------------------------- 
-// Clear : Remove all couples (item,key) from the map.
-//----------------------------------------------------------------- 
-void PCollection_HDataMap::Clear() 
-{
-   Handle(PCollection_MapNode) aNode1,aNode2;
-   for (Integer i = 1 ; i <= Buckets->Length() ; i++) {
-     aNode1 = Buckets->Value(i);
-     aNode2.Nullify();
-     Buckets->SetValue(i,aNode2);
-     while ( ! aNode1.IsNull() ) {
-       aNode2 = aNode1->Next();
-       aNode1.Delete();
-       aNode1 = aNode2;
-     }
-   }
-}
-
-//- ---------------------------------------------------------------- 
-// Bind : Add a new couple (Item,Key) in the map. The entry point in 
-//        the map corresponds to the result of Hashcode function (i.e
-//        HashCode (key)).
-//- ---------------------------------------------------------------- 
-void PCollection_HDataMap::Bind(const Key& K , const Item& T)
-{
-   Integer Res ;
-   Key TheKey;
-   Handle(PCollection_MapNode) aNode1,aNode2,pnul;
-   pnul.Nullify();
-   aNode1 = new PCollection_MapNode ( K , T , pnul) ;
-   Res = Hash.HashCode (K,Buckets->Length());         
-   aNode2 = Buckets->Value(Res);
-   if ( ! aNode2.IsNull()) {
-      while ( ! aNode2.IsNull() )  {
-         TheKey = aNode2->GetKey();
-         if ( Hash.Compare(TheKey,K) ) MultiplyDefined::Raise();
-         aNode2 = aNode2->Next();
-      }
-      aNode2 = Buckets->Value(Res);
-      aNode1->SetNext(aNode2);
-   }
-   Buckets->SetValue(Res,aNode1);
-}
-
-//----------------------------------------------------------------- 
-// Rebind : For an existant couple (Key,AnItem) in the map change
-//          le value of the item.
-//          If the couple does not exist raise an exception
-//----------------------------------------------------------------- 
-void PCollection_HDataMap::Rebind(const Key& K , const Item& T)
-{
-   Integer Res ;
-   Key TheKey;
-   Handle(PCollection_MapNode) aNode;
-   Res = Hash.HashCode (K,Buckets->Length());         
-   aNode = Buckets->Value(Res);
-   while ( ! aNode.IsNull() )  {
-      TheKey = aNode->GetKey();
-      if ( Hash.Compare(TheKey,K) ) {
-        aNode->SetValue(T);
-        return;
-      } 
-      else {
-        aNode = aNode->Next();
-      }
-   }
-   NoSuchObject::Raise();
-}
-
-//----------------------------------------------------------------- 
-// Unbind : Remove the couple keyed by K
-//          If the couple does not exist raise an exception
-//----------------------------------------------------------------- 
-void PCollection_HDataMap::Unbind(const Key& K) 
-{
-   Integer Res ;
-   Key TheKey;
-   Handle(PCollection_MapNode) aNode,pnul,previous,next;
-   Res = Hash.HashCode (K,Buckets->Length());  
-   aNode = Buckets->Value(Res);
-   pnul.Nullify();
-   previous.Nullify();
-   while ( ! aNode.IsNull() ) {
-      TheKey = aNode->GetKey();
-      if ( Hash.Compare(TheKey,K) ) {        
-        next = aNode->Next();    
-        if (previous.IsNull() && next.IsNull()) {     // liste de 1 elt
-           Buckets->SetValue(Res,pnul);
-           aNode.Delete();
-
-        } else if (previous.IsNull()) {               // 1er elt de liste
-           Buckets->SetValue(Res,next);
-           aNode.Delete();
-           next.Nullify();
-
-       } else if (next.IsNull()) {                  // dernier de liste      
-           previous->SetNext(pnul);
-           aNode.Delete();
-
-        } else {                                    // milieu de liste
-           previous->SetNext(next);
-           aNode.Delete();
-           next.Nullify();
-        }
-        return;
-      }
-      
-      else {                                      //  pas le bon noeud
-         previous = aNode;
-         aNode = aNode->Next();
-      }   
-   }
-   NoSuchObject::Raise();
-}
-
-//----------------------------------------------------------------- 
-// ShallowCopy : ShallowCopy redefinition
-//----------------------------------------------------------------- 
-Handle(Standard_Persistent) PCollection_HDataMap::ShallowCopy() const
-{
-   PCollection_HDataMap* TheCopy = new PCollection_HDataMap (*this);
-   TheCopy->Buckets = 
-      Handle(PCollection_Array)::DownCast(::ShallowCopy(Buckets));
-   return TheCopy;
-}
-
-//----------------------------------------------------------------- 
-// ShallowDump : ShallowDump redefinition
-//----------------------------------------------------------------- 
-void PCollection_HDataMap::ShallowDump(OStream& S) const
-{
-  S << "begin class Map "<< endl;
-  if (!IsEmpty()) 
-       Buckets->ShallowDump(S);
-  else   
-       S << "Empty Map." << endl;
-  S << "end of class Map." << endl;
-}
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HDataMap.lxx b/src/PCollection/PCollection_HDataMap.lxx
deleted file mode 100644 (file)
index 311105e..0000000
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// inline methods for HMap class from PCollection.
-// Written by JPT FEB,24 1992
-
-
-// --------------------------------------------------
-// Returns the field Buckets associated to the object
-// --------------------------------------------------
-inline Handle(PCollection_Array) PCollection_HDataMap::GetArray() const {
- return Buckets;
-}
-
-// --------------------------------------------------
-// Returns the field  FH associated to the object
-// --------------------------------------------------
-inline FH PCollection_HDataMap::GetFH() const {
- return Hash;
-}
-
-
diff --git a/src/PCollection/PCollection_HDirectedGraph.cdl b/src/PCollection/PCollection_HDirectedGraph.cdl
deleted file mode 100644 (file)
index 71a1780..0000000
+++ /dev/null
@@ -1,704 +0,0 @@
--- Created on: 1991-04-24
--- Created by: Denis PASCAL
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
--- Revised:     Mireille MERCIEN
-
-
-generic class HDirectedGraph from PCollection (
-               Item as Storable ; 
-               Attribute as Storable)
-
-     ---Purpose: Definition of a generic  directed graph for a type of
-     -- Item associated to a vertex, and  a type of Attribute
-     -- associated to an   Edge.    A Directed   Graph   is a
-     -- collection that includes a set of Vertices  and a set
-     -- of Edges.  A vertex, also called a  "Node", forms the
-     -- basic  structural element  of  the graph.  Each edge,
-     -- also called an "Arc" defines an oriented link between
-     -- two vertices.  In the scheme A->B, vertex A is called
-     -- the SOURCE  of the link, B  its DESTINATION, and B is
-     -- ADJACENT to A.  If there is no edge  which destinates
-     -- to a vertex, this vertex is a ROOT of the graph.   If
-     -- there is no edge which originates from a vertex, this
-     -- vertex is a LEAF of the graph.
-
-    ---Keywords: SOURCE vertex,  DESTINATION Vertex, ROOT vertex, LEAF
-    --  vertex, ADJACENT vertex. Depth-first search, breadth, first Search.
-
-    ---References: Software Components with ADA (The Benjamin/Cummings
-    --    Company, Inc.  1986).
-
-
-
-inherits Persistent 
-raises NoSuchObject from Standard,
-       NoMoreObject from Standard
-
-
-    class Edge inherits Persistent
-    
-       ---Purpose: Defines nested class Edge of a Directed Graph.
-       -- An Edge is an oriented link between  two vertices.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-
-       Create (Source,Destination : Vertex; Value : Attribute) 
-           ---Purpose: Creates an oriented link  between <source> and
-           -- <destination> with an associated attribute. To
-           -- be  used only   by  DirectedGraph  methods  to
-           -- create and add an edge to a given graph.
-       returns mutable Edge; 
-
-       GetAttribute (me) 
-            ---Level: Public
-           ---Purpose: Returns attribute associated to <me>.
-            returns Attribute;
-
-       SetAttribute (me : mutable; Value : Attribute)
-            ---Level: Internal
-           ---Purpose: To associate an attribute to <me>.
-       is private;
-
-       Source (me) 
-            ---Level: Public
-           ---Purpose: Returns the vertex which originates from <me>.
-            returns mutable Vertex;
-           
-       SetSource (me :mutable; V: Vertex) 
-            ---Level: Internal
-           ---Purpose: Sets the vertex which originates from <me>.
-        is private;
-
-       Destination (me) 
-            ---Level: Public
-           ---Purpose: Returns the vertex which destinates to <me>.
-            returns mutable Vertex;
-
-       SetDestination (me :mutable ; V: Vertex) 
-            ---Level: Internal
-           ---Purpose: Sets the vertex which destinates to <me>.
-            is private;
-
-       Reverse (me : mutable);
-            ---Level: Public
-           ---Purpose: Reverse  the orientation of   <me>.
-           -- The source vertex becomes the  destination vertex, and
-           -- the destination becomes the source.
-
-       IsLoop (me) returns Boolean from Standard;
-            ---Level: Public
-           ---Purpose: Returns True if the fields <MyDestination> and 
-           -- <Mysource> are equal.
-    fields
-       MyAttribute   : Attribute;
-       MySource      : Vertex;
-       MyDestination : Vertex;
-
-    friends class HDirectedGraph from PCollection,
-            class Vertex        from PCollection 
-    
-    end;
-
-    class SetOfEdge instantiates HSet from PCollection(Edge);
-       ---Purpose: Defines nested class SetOfEdge used  as  field of
-       -- Vertex and DirectedGraph.
-
-    class SetOfVertex instantiates HSet from PCollection(Vertex);
-       ---Purpose: Defines nested class SetOfVertex used as field of a
-       -- DirectedGraph.
-
-    class StackOfVertex instantiates HStack from PCollection(Vertex);
-       ---Purpose: Defines nested class StackOfVertex used  as  field of
-       -- DepthFirstIterator class.
-
-
-    class QueueOfVertex instantiates HQueue from PCollection(Vertex);
-       ---Purpose: Defines nested class QueueOfVertex used  as  field of
-       -- BreadthFirstIterator.
-
-    class FrontEdgesIterator   
-       ---Purpose: Defines nested class  FrontEdgesIterator, to  visit
-       -- every edge that originates from a given vertex.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-
-       Create (aVertex : Vertex) returns FrontEdgesIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other edges.
-        returns Boolean from Standard; 
-
-       Next (me : in out) raises NoMoreObject from Standard;  
-            ---Level: Public
-           ---Purpose: Set the iterator to the next Edge.
-
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns the edge value for the current
-           -- position of the iterator.
-        returns any Edge
-        raises NoSuchObject from Standard;
-
-       Clear (me : in out);
-            ---Level: Public
-           ---Purpose: To clear the iterator before having visiting all edges.
-
-    fields
-       MyEdgeIterator : SetIteratorOfSetOfEdge;
-        HasMore        : Boolean from Standard;    
-    end;
-       
-    class BackEdgesIterator 
-       ---Purpose: Defines  nested class BackEdgesIterator, to  visit
-       -- every edge that destinates to a given vertex.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-       Create (aVertex : Vertex) returns BackEdgesIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other edges.
-        returns Boolean from Standard;
-       
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next edge.
-       
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns   the  edge value   for   the  current
-           -- position of the iterator.
-        returns any Edge
-        raises NoSuchObject from Standard;     
-       
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To  clear the  iterator before having visiting all edges.
-
-    fields
-       MyEdgeIterator : SetIteratorOfSetOfEdge;
-       HasMore        : Boolean from Standard;
-    end;
-
-    class DepthFirstIterator
-       ---Purpose: Defines nested class  DepthFirstIterator, to  visit
-       -- every vertex that depends  of a given  one.  Depth
-       -- First Search  is functionnally the equivalent of a
-       -- preorder tree   traversal.  We start  at  a  given
-       -- Vertex  V  and   recursively  visit  all  adjacent
-       -- unvisited Vertices.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-    
-       Create (aVertex : Vertex) returns DepthFirstIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other vertices.
-        returns Boolean from Standard;
-
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next vertex.
-
-       Value (me)  
-            ---Level: Public
-           ---Purpose: Returns  the vertex  value  for  the   current
-           -- position of the iterator.
-       returns any Vertex
-        raises NoSuchObject from Standard;
-       
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To  clear the  iterator before having visiting
-            -- all vertices.
-
-    fields
-       Visited : SetOfVertex;
-       Ready   : StackOfVertex;
-       HasMore : Boolean from Standard;
-    end;
-
-    class BreadthFirstIterator
-       ---Purpose: Defines nested class BreadthFirstIterator, to visit
-       -- every vertex that depends of a given one. We start
-       -- at    a  given vertex  V,  visit  all its adjacent
-       -- vertices, and then recursively visit the unvisited
-       -- adjacent vertices of these previous ones.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-
-       Create (aVertex : Vertex) returns BreadthFirstIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other vertices.
-        returns Boolean from Standard;
-       
-               Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next vertex.
-
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns  the  vertex  value for  the   current
-           -- position of the iterator.
-        returns any Vertex
-        raises NoSuchObject from Standard;
-
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To  clear the  iterator before having visiting
-            -- all vertices.
-
-    fields
-       Visited : SetOfVertex;
-       Ready   : QueueOfVertex;
-       HasMore : Boolean from Standard;
-    end;
-
-    class AdjacentVerticesIterator 
-
-       ---Purpose: Defines nested class AdjacentVerticesIterator, to
-       -- visit  every  adjacent vertex    of a   given  one
-       -- (Destination vertices of its front edges).
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-       Create (aVertex : Vertex) returns AdjacentVerticesIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other vertices.
-        returns Boolean from Standard;
-
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next vertex.
-
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns the  vertex  value for the current
-           -- position of the iterator.
-        returns any Vertex
-        raises NoSuchObject from Standard;
-
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To clear the iterator before having visiting all vertices.
-
-    fields
-       MyEdgeIterator : SetIteratorOfSetOfEdge;
-       HasMore        : Boolean from Standard;
-    end;
-
------------------------ Class Vertex ----------------------------------
-
-    class Vertex inherits Persistent
-       ---Purpose: Defines nested class vertex of a DirectedGraph. The
-       -- Vertex is the basic element of a graph.
-  
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-
-       Create (Value : Item ; InGraph : HDirectedGraph) 
-           ---Purpose: Creates a vertex  with an  associated item. To
-           -- be  used  only  by   DirectedGraph methods  to
-           -- create and add a vertex to a given  graph.
-        returns mutable Vertex;
-
-       GetItem (me) 
-            ---Level: Public
-           ---Purpose: Returns item associated to <me>.
-            returns any Item;
-
-       SetItem (me : mutable; value : Item)
-            ---Level: Internal
-           ---Purpose: Associates an item to <me>.
-            is private;
-
-       GetGraph (me) 
-            ---Level: Public
-           ---Purpose: Returns the HDirectedGraph which owns <me>.
-            returns HDirectedGraph;
-
-       AddFrontEdge (me : mutable; anEdge : Edge) 
-            ---Level: Internal
-           ---Purpose: To add an edge that destinates to <me>. 
-           -- To be used only by editing methods of a DirectedGraph. 
-           -- Returns  False  if  the edge already exists.
-        returns Boolean from Standard
-       is private;
-
-       RemoveFrontEdge (me : mutable; anEdge : Edge)
-            ---Level: Internal
-           ---Purpose: To remove  an edge that  originates from <me>.
-           -- To be   used  only  by  editing  methods  of a DirectedGraph. 
-           -- An  exception is  raised  if <anEdge> doesn't belong to 
-           -- myFrontEdges field.
-       raises NoSuchObject from Standard
-       is private;
-    
-       NbFrontEdges (me) returns Integer;
-            ---Level: Public
-           ---Purpose: Returns the number of edges which originates from <me>.
-
-       GetFrontEdges (me) 
-            ---Level: Public
-           ---Purpose: Returns "myFrontEdges" Field for Iterator.
-       returns SetOfEdge 
-       is private;
-    
-       AddBackEdge (me : mutable; anEdge : Edge) 
-            ---Level: Internal
-           ---Purpose: To add an edge that destinates  to <me>. To be
-           -- used     only   by   editing    methods  of  a
-           -- DirectedGraph,  to    update     it      after
-           -- modifications.   Returns   False if the   edge already exists.
-       returns Boolean from Standard
-       is private;
-
-       RemoveBackEdge (me : mutable; anEdge : Edge)
-            ---Level: Internal
-           ---Purpose: To remove an edge  that destinates to <me>. To
-           -- be   used   only by   editing   methods   of a
-           -- DirectedGraph,      to     update    it  after
-           -- modifications.   An   exception  is raised  if
-           -- <anEdge> doesn't belong to myBackEdges field.
-       raises NoSuchObject from Standard
-       is private;
-
-       NbBackEdges (me) 
-            ---Level: Public
-           ---Purpose: Returns the number   of  edge which  destinates to <me>.
-           returns Integer from Standard;
-
-       GetBackEdges (me)
-            ---Level: Internal
-           ---Purpose: Returns "myBackEdges" field for Iterator.
-       returns SetOfEdge
-       is private;
-
-       IsRoot (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if NbBackEdges = 0.
-        returns Boolean from Standard;
-
-       IsLeaf (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if NbFrontEdges = 0.
-        returns Boolean from Standard;
-
-       IsDestination (me; aVertex : Vertex) 
-            ---Level: Public
-           ---Purpose: Returns   TRUE if   it  exists  an  edge which
-           -- originates     from <me>   and  destinates  to <aVertex>.
-        returns Boolean from Standard;
-
-       IsSource (me; aVertex : Vertex) 
-            ---Level: Public
-           ---Purpose: Returns  TRUE  if  it   exists an  edge  which
-           -- originates  from  <aVertex>  and destinates to <me>.
-        returns Boolean from Standard;
-       
-    fields
-       MyItem       : Item;
-       MyGraph      : HDirectedGraph;
-       MyFrontEdges : SetOfEdge;
-       MyBackEdges  : SetOfEdge;
-
-    friends class HDirectedGraph            from PCollection,
-            class Edge                     from PCollection,
-            class BackEdgesIterator        from PCollection,
-            class FrontEdgesIterator       from PCollection,
-            class DepthFirstIterator       from PCollection,
-            class BreadthFirstIterator     from PCollection,
-            class AdjacentVerticesIterator from PCollection                   
-    end;
-
-    class VerticesIterator  
-       ---Purpose: Defines nested  class  VerticesIterator,   to visit
-       -- every vertex of a given directed graph.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-       Create (aGraph : HDirectedGraph) returns VerticesIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns  TRUE  if  there are other vertices.
-        returns Boolean from Standard;
-
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next vertex.
-
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns the vertex  value  for   the current
-           -- position of the iterator.
-        returns any Vertex 
-        raises NoSuchObject from Standard;
-
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To clear the  iterator before having visiting
-            -- all vertices.
-
-    fields
-       MyVertexIterator : SetIteratorOfSetOfVertex;
-       HasMore          : Boolean from Standard;
-    end;
-
-    class RootsIterator 
-       ---Purpose: Defines  nested class RootsIterator, to visit every
-       -- "root" vertex of a directed graph.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-       Create (aGraph : HDirectedGraph) returns RootsIterator;
-
-       More (me)
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other vertices.
-        returns Boolean from Standard;
-
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next vertex.
-
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns  the  vertex  value  for the   current
-           -- position of the iterator.
-        returns any Vertex 
-        raises NoSuchObject from Standard;
-
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To  clear the  iterator before having visiting
-            -- all vertices.
-
-    fields
-       MyVertexIterator : SetIteratorOfSetOfVertex;
-       HasMore          : Boolean from Standard;
-    end;
-
-    class LeavesIterator
-       ---Purpose: Defines nested class LeavesIterator, to visit every
-       -- "leaf" vertex of a directed graph.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-       Create (aGraph : HDirectedGraph) returns LeavesIterator;
-
-       More (me) 
-            ---Level: Public
-           ---Purpose: Returns TRUE if  there are other vertices.
-        returns Boolean from Standard;
-
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Set the iterator to the next vertex.
-
-       Value (me) 
-            ---Level: Public
-           ---Purpose: Returns  the  vertex  value for   the  current
-           -- position of the iterator.
-        returns any Vertex 
-        raises NoSuchObject from Standard;
-       
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To  clear the  iterator before having visiting
-            -- all vertices.
-
-    fields
-       MyVertexIterator : SetIteratorOfSetOfVertex;
-       HasMore          : Boolean from Standard;
-    end;
-
-    class EdgesIterator
-       ---Purpose: Defines nested class  EdgesIterator, to visit every
-       -- edge of a directed graph.
-
-    raises NoMoreObject from Standard ,
-           NoSuchObject from Standard
-    is
-       Create (aGraph : HDirectedGraph) returns EdgesIterator;
-
-       More (me) returns Boolean from Standard;
-            ---Level: Public
-           ---Purpose: Returns TRUE if there are other edges.
-
-       Next (me : in out) raises NoMoreObject from Standard; 
-            ---Level: Public
-           ---Purpose: Sets the iterator to the next edge.
-
-       Value (me)  
-            ---Level: Public
-           ---Purpose: Returns  the  edge    value  for  the  current
-           -- position of the iterator.
-        returns any Edge
-        raises NoSuchObject from Standard;
-
-       Clear (me : in out);
-            ---Level: Public
-            ---Purpose: To  clear the  iterator before having visiting all edges.
-
-    fields
-       MyEdgeIterator : SetIteratorOfSetOfEdge;
-       HasMore        : Boolean from Standard;
-    end;
-
---------------------- class HDirectedGraph -----------------------------
-
-is
-
-    Create returns mutable HDirectedGraph;
-       ---Purpose: Creates an empty Directed Graph.
-
-    NumberOfVertices (me) returns Integer from Standard;
-        ---Level: Public
-
-    NumberOfEdges (me) returns Integer from Standard;
-        ---Level: Public
-
-    NumberOfLeaves (me) returns Integer from Standard;
-        ---Level: Public
-       ---Purpose: Returns the number   of "leaf" vertices  of  <me>.
-
-    NumberOfRoots (me) returns Integer from Standard;
-        ---Level: Public
-       ---Purpose: Returns  the number of  "root"  vertices  of <me>.
-
-    IsEmpty (me) returns Boolean from Standard;
-        ---Level: Public
-    
-    Clear (me : mutable);
-        ---Level: Public
-       ---Purpose: Removes all edges and vertices of <me>.
-    
-    IsMember (me; aVertex : Vertex) returns Boolean from Standard;
-        ---Level: Public
-
-    IsMember (me; anEdge : Edge) returns Boolean from Standard;    
-        ---Level: Public
-
-    Add (me : mutable; Value : Item)
-        ---Level: Public
-       ---Purpose: Creates and  Adds  a vertex,   with a given  value
-       -- <value>, to <me>. Of  course this new  Vertex is a
-       -- "root" and "leaf" vertex of <me> because it has no
-       -- connexion  with other  vertices of  the   directed graph.
-    returns mutable Vertex;
-
-    Remove (me : mutable; aVertex : mutable Vertex)
-        ---Level: Public
-       ---Purpose: Removes <aVertex> from <me>.  Removes also all the
-       -- edges of  <me>  which reference <aVertex>; Updates
-       -- Source and Destination  vertices of each  of these
-       -- edges  . Raises an exception  if  <aVertex> is not
-       -- member of <me>.
-    raises NoSuchObject from Standard;
-
-    Add (me : mutable; Source : mutable Vertex; 
-         Destination : mutable Vertex; Value : Attribute)
-        ---Level: Public
-       ---Purpose: Creates and   adds  an  edge   from    <source> to
-       -- <destination>, with   the  attribute  <value>,  to
-       -- <me>.  Updates Source and Destination  Vertices of
-       -- this new edge.  Raises an exception if <source> or
-       -- <destination> are not members of <me>.
-    returns mutable Edge
-    raises NoSuchObject from Standard;
-
-    Remove (me : mutable; AnEdge : mutable Edge)
-        ---Level: Public
-       ---Purpose: Removes  <anEdge>  from <me>.  And  Updates Source
-       -- and Destination  Vertices  of  <anEdge>. Raises an
-       -- exception if <Edge> is not member of <me>.
-    raises NoSuchObject from Standard;
-
-    GetVertices (me) 
-        ---Level: Internal
-       ---Purpose: Returns "myVertices" field for Iterator.
-    returns SetOfVertex 
-    is private;
-    
-    GetEdges (me) 
-        ---Level: Internal
-       ---Purpose: Returns "myEdges" field for Iterator.
-    returns SetOfEdge
-    is private;
-
-    ShallowCopy(me) returns mutable like me 
-       is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-    ShallowDump (me; s: in out OStream) 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-fields
-    MyVertices : SetOfVertex;
-    MyEdges    : SetOfEdge;
-
-    friends class VerticesIterator from PCollection,
-            class RootsIterator from PCollection,
-            class LeavesIterator from PCollection,
-            class EdgesIterator from PCollection    
-end;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HDirectedGraph.gxx b/src/PCollection/PCollection_HDirectedGraph.gxx
deleted file mode 100644 (file)
index 7dc45bb..0000000
+++ /dev/null
@@ -1,192 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised:     Mireille MERCIEN
-
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-//----------------------------------------------------------------------
-PCollection_HDirectedGraph::PCollection_HDirectedGraph () 
-{
-  MyVertices = new PCollection_SetOfVertex;
-  MyEdges = new PCollection_SetOfEdge;
-}
-
-//--------------------------------------------------------------------
-Integer PCollection_HDirectedGraph::NumberOfVertices () const 
-{
-  return MyVertices->Extent();
-}
-
-
-//--------------------------------------------------------------------
-Integer PCollection_HDirectedGraph::NumberOfEdges () const 
-{
-  return MyEdges->Extent();
-} 
-
-//--------------------------------------------------------------------
-Integer PCollection_HDirectedGraph::NumberOfLeaves () const 
-{
-  Integer nb = 0;
-  PCollection_SetIteratorOfSetOfVertex It (MyVertices);
-  while (It.More()) {
-    Handle(PCollection_Vertex) V = It.Value();
-    if (V->IsLeaf()) nb++;
-    It.Next();
-  }
-  return nb;
-}
-
-
-//--------------------------------------------------------------------
-Integer PCollection_HDirectedGraph::NumberOfRoots () const 
-{
-  Integer nb = 0;
-  PCollection_SetIteratorOfSetOfVertex It(MyVertices);
-  while (It.More()) {
-    Handle(PCollection_Vertex) V = It.Value();
-    if (V->IsRoot()) nb++;
-    It.Next();
-  }
-  return nb;
-}
-
-
-//--------------------------------------------------------------------
-Boolean PCollection_HDirectedGraph::IsEmpty () const 
-{
-  return (MyVertices->Extent() == 0);
-}
-
-
-//--------------------------------------------------------------------
-void PCollection_HDirectedGraph::Clear ()  
-{
-  MyVertices = new PCollection_SetOfVertex;
-  MyEdges = new PCollection_SetOfEdge;
-}
-
-
-//--------------------------------------------------------------------
-Boolean PCollection_HDirectedGraph::IsMember 
-                              (const Handle(PCollection_Vertex)& V) const 
-{
-  return MyVertices->Contains(V);
-}
-
-
-//--------------------------------------------------------------------
-Boolean PCollection_HDirectedGraph::IsMember 
-                              (const Handle(PCollection_Edge)& E) const 
-{
-  return MyEdges->Contains(E);
-}
-
-
-//--------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_HDirectedGraph::Add 
-                              (const Item& val) 
-{
-  Handle(PCollection_Vertex) V = new PCollection_Vertex (val,this);
-  MyVertices->Add(V);
-  return V;
-}
-
-
-//--------------------------------------------------------------------
-void PCollection_HDirectedGraph::Remove (const Handle(PCollection_Vertex)& V) 
-{
-  if (IsMember(V)) {
-     PCollection_BackEdgesIterator ItBack(V);
-     while (ItBack.More()) {
-        Handle(PCollection_Edge) BE = ItBack.Value();
-        if (BE->Source() != V) BE->Source()->RemoveFrontEdge(BE);
-        MyEdges->Remove(BE);
-        ItBack.Next();
-     }
-     PCollection_FrontEdgesIterator ItFront(V);
-     while (ItFront.More()) {
-       Handle(PCollection_Edge) FE = ItFront.Value();
-       if (FE->Destination() != V) FE->Destination()->RemoveBackEdge(FE);
-       if (MyEdges->Contains(FE)) MyEdges->Remove(FE);
-       ItFront.Next();
-     }
-     MyVertices->Remove(V);
-//   V->Nullify();  // test Handle nul sur Vertex retire
-   }
-   else  {
-    NoSuchObject::Raise();
-   }
-}
-
-
-//--------------------------------------------------------------------
-Handle(PCollection_Edge) PCollection_HDirectedGraph::Add 
-                    (const Handle(PCollection_Vertex)& source,
-                     const Handle(PCollection_Vertex)& destination,
-                     const Attribute& A) 
-{
-  if (IsMember(source) && IsMember(destination)) {
-    Handle(PCollection_Edge) E = new PCollection_Edge (source,destination,A);
-    source->AddFrontEdge (E);
-    destination->AddBackEdge(E);
-    MyEdges->Add (E);
-    return E;
-  }
-  else {
-    NoSuchObject::Raise();
-  }
-}
-
-//--------------------------------------------------------------------
-void PCollection_HDirectedGraph::Remove (const Handle(PCollection_Edge)& E) 
-{
-  if (IsMember(E)) {
-    (E->Source())->RemoveFrontEdge(E);
-    (E->Destination())->RemoveBackEdge(E);
-    MyEdges->Remove(E);
-//    E->Nullify();  // test Handle nul sur Edge retire
-  }
-  else {
-    NoSuchObject::Raise();
-  }
-}
-
-
-//--------------------------------------------------------------------
-Handle(PCollection_SetOfVertex) PCollection_HDirectedGraph::GetVertices() const 
-{
-  return MyVertices;
-}
-
-
-//--------------------------------------------------------------------
-Handle(PCollection_SetOfEdge) PCollection_HDirectedGraph::GetEdges() const 
-{
-  return MyEdges;
-}
-  
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HDoubleMap.cdl b/src/PCollection/PCollection_HDoubleMap.cdl
deleted file mode 100644 (file)
index 6df2271..0000000
+++ /dev/null
@@ -1,209 +0,0 @@
--- Copyright (c) 1992-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
----Version: 
-
---  Version    Date         Purpose
---              10/12/92     Creation   
-
-
-generic class HDoubleMap from PCollection ( Key as Storable ;
-                                          Item as Storable ;
-                                          KeyHash as Hash(Key) ;
-                                          ItemHash as Hash(Item) )
-
----Purpose: A double map is a Collection of bindings between two objects.
--- It can be retrieved either by its Key or its Item;a hash code
--- value must be computed for both.
-
-inherits Persistent from Standard
-
-raises
-
-    MultiplyDefined from Standard,
-    NoMoreObject    from Standard,
-    NoSuchObject    from Standard
-
-
-class DoubleMapNode from PCollection inherits PManaged from PMMgt
----Purpose: Class used in the implementation of the DoubleMap class. It stores
--- Key and Item and two references to DoubleMapNode, one used to make Hashed 
--- list for Key , the other to make Hashed list for Item.
-
-is
-
-    Create( aKey : Key ; anItem : Item ; nextKey : DoubleMapNode ; 
-       nextItem : DoubleMapNode ) returns mutable DoubleMapNode;
-    ---Purpose: Creates a DoubleMapNode.
-
-    SetNextKey ( me : mutable ; aNode : DoubleMapNode ) is static;
-    ---Level: Internal
-    ---Purpose: Sets the next node of Key hashed list. 
-
-    SetNextItem ( me : mutable ; aNode : DoubleMapNode ) is static;
-    ---Level: Internal
-    ---Purpose: Sets the next node of Item hashed list. 
-    
-    GetKey ( me ) returns any Key is static;
-    ---Level: Internal
-    ---Purpose: Returns the key.
-
-    GetItem ( me ) returns any Item is static;
-    ---Level: Internal
-    ---Purpose: Returns the item.
-
-    NextKey ( me ) returns any DoubleMapNode is static;
-    ---Level: Internal
-    ---Purpose: Returns the next node of Key hashed list.
-
-    NextItem ( me ) returns any DoubleMapNode is static;
-    ---Level: Internal
-    ---Purpose: Returns the next node of Item hashed list.
-
-fields
-
-    myKey      : Key;
-    myItem     : Item;
-    myNextKey  : DoubleMapNode;
-    myNextItem : DoubleMapNode;
-    
-end DoubleMapNode;
-
-class ArrayDoubleMap instantiates HArray1 from PCollection (DoubleMapNode);
-
-
-class DoubleMapIterator
-
----Purpose: This class provides services to iterate on all bindings of
--- a DoubleMap.
-
-raises
-    
-    NoMoreObject from Standard,
-    NoSuchObject from Standard
-    
-is
-
-    Create ( aDoubleMap : HDoubleMap from PCollection) 
-                               returns DoubleMapIterator;
-    ---Purpose: Creates an iterator of <aDoubleMap>.
-
-    More ( me ) returns Boolean;
-    ---Level: Public
-    ---Purpose: Returns True if there are others couples (Item,Key).
-
-    Next ( me : in out )
-    ---Level: Public
-    ---Purpose: Sets the iterator to the next couple (Item,Key).
-    raises NoMoreObject from Standard;
-
-    KeyValue ( me ) returns Key
-    ---Level: Public
-    ---Purpose: Returns the Key value corresponding to the current position 
-    -- of the iterator.
-    raises NoSuchObject from Standard;
-
-    ItemValue ( me ) returns Item
-    ---Level: Public
-    ---Purpose: Returns the Item value corresponding to the current position 
-    -- of the iterator.
-    raises NoSuchObject from Standard;
-
-fields
-
-    myBuckets      : ArrayDoubleMap;
-    myCurrentIndex : Integer;
-    myCurrentNode  : DoubleMapNode;
-    
-end DoubleMapIterator;
-    
-is
-
-    Create ( NbBuckets : Integer; fhKey : KeyHash; fhItem : ItemHash )
-       returns mutable HDoubleMap;
-    ---Purpose: Creates a double map of <NbBuckets> entries.
-       
-    NbBuckets ( me ) returns Integer;
-    ---Level: Public
-    ---Purpose: Returns the number of entries in the double map <me>.
-    
-    Extent ( me ) returns Integer;
-    ---Level: Public
-    ---Purpose: Returns the number of couples (<Key>,<Item>) stored in <me>.
-    
-    Bind ( me : mutable ; aKey : Key; anItem : Item )
-    ---Level: Public
-    ---Purpose: Adds the pair (<aKey>,<anItem>) to <me>.
-    ---Trigger: Raises an exception if the binding already exists.
-    raises MultiplyDefined from Standard;
-    
-    FindItem ( me ; aKey : Key ) returns any Item
-    ---Level: Public
-    ---Purpose: Returns the item bounded by <aKey>.
-    ---Trigger: Raises an exception if the binding does not exist.
-    raises NoSuchObject from Standard;
-    
-    FindKey ( me ; anItem : Item ) returns any Key
-    ---Level: Public
-    ---Purpose: Returns the key bounded by <anItem>.
-    raises NoSuchObject from Standard;
-    ---Trigger: Raises if the binding does not exist.
-    
-    UnbindKey ( me : mutable ; aKey : Key )
-    ---Level: Public
-    ---Purpose: Unbinds the couple keyed by <aKey>.
-    raises NoSuchObject from Standard;
-    ---Trigger: Raises if the binding does not exist.
-    
-    UnbindItem ( me : mutable ; anItem : Item )
-    ---Level: Public
-    ---Purpose: Unbinds the couple keyed by <anItem>.
-    raises NoSuchObject from Standard;
-    ---Trigger: Raises if the binding does not exist.
-    
-    Clear ( me : mutable );
-    ---Level: Public
-    ---Purpose: Clears the double map.
-    
-    IsBoundByKey ( me ; aKey : Key ) returns Boolean;
-    ---Level: Public
-    ---Purpose: Returns True if an element is bound by <aKey>.
-    
-    IsBoundByItem ( me ; anItem : Item ) returns Boolean;
-    ---Level: Public
-    ---Purpose: Returns True if an element is bound by <anItem>.
-
-    IsEmpty ( me ) returns Boolean;
-    ---Level: Public
-    ---Purpose: Returns True if the DoubleMap <me> is empty.
-
-    GetArrayKey ( me ) returns ArrayDoubleMap is static private;
-    ---Level: Internal
-    ---Purpose: Returns the ArrayDoubleMap for Key.
-
-fields
-
-    myNumber    : Integer;  -- Number of couples
-    myArrayKey  : ArrayDoubleMap;   
-    myArrayItem : ArrayDoubleMap;   
-    myKeyHash   : KeyHash;
-    myItemHash  : ItemHash;
-    
-friends
-
-    class DoubleMapIterator from PCollection
-    
-end HDoubleMap;
-
-
diff --git a/src/PCollection/PCollection_HDoubleMap.gxx b/src/PCollection/PCollection_HDoubleMap.gxx
deleted file mode 100644 (file)
index 1e26f3d..0000000
+++ /dev/null
@@ -1,323 +0,0 @@
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//-Version: 
-
-//  Version    Date         Purpose
-//              14/12/92     Creation   
-
-//-Language     C++2.0
-
-//-Declarations
-#include <Standard_MultiplyDefined.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-//=======================================================================
-// Function : HDoubleMap
-//=======================================================================
-
-PCollection_HDoubleMap::PCollection_HDoubleMap
-  (
-   const Standard_Integer NbBuckets ,
-   const KeyHash &fhKey,
-   const ItemHash &fhItem )
-{
-
-  myArrayKey = new PCollection_ArrayDoubleMap(1,NbBuckets);  
-  myArrayItem = new PCollection_ArrayDoubleMap(1,NbBuckets);
-  myKeyHash = fhKey;
-  myItemHash = fhItem;
-  myNumber = 0;
-
-}
-
-//=======================================================================
-// Function : NbBuckets
-//=======================================================================
-
-Standard_Integer PCollection_HDoubleMap::NbBuckets() const
-{
-  return myArrayKey->Length();
-}
-
-//=======================================================================
-// Function : Extent
-//=======================================================================
-
-Standard_Integer PCollection_HDoubleMap::Extent() const
-{
-  return myNumber;
-}
-
-//=======================================================================
-// Function : Bind
-//=======================================================================
-
-void PCollection_HDoubleMap::Bind (const Key &aKey , const Item &anItem)
-{
-  Standard_Integer ResHashKey,ResHashItem;
-  Handle(PCollection_DoubleMapNode) theNewNode;
-
-  if ( IsBoundByKey(aKey) || IsBoundByItem(anItem) ) 
-    Standard_MultiplyDefined::Raise();
-  else {
-    ResHashKey = myKeyHash.HashCode(aKey,myArrayKey->Length());
-    ResHashItem = myItemHash.HashCode(anItem,myArrayItem->Length());
-    theNewNode =
-      new PCollection_DoubleMapNode(aKey,anItem,
-                                    myArrayKey->Value(ResHashKey),
-                                    myArrayItem->Value(ResHashItem));
-    myArrayKey->SetValue(ResHashKey,theNewNode); 
-    myArrayItem->SetValue(ResHashItem,theNewNode);
-    myNumber++;
-  }
-}
-
-//=======================================================================
-// Function : FindItem
-//=======================================================================
-
-Item PCollection_HDoubleMap::FindItem ( const Key &aKey ) const
-{
-  Standard_Integer ResHashKey;
-  Handle(PCollection_DoubleMapNode) theKeyNode;
-
-  ResHashKey = myKeyHash.HashCode(aKey,myArrayKey->Length());
-  theKeyNode = myArrayKey->Value(ResHashKey);
-  while ( ! theKeyNode.IsNull() ) {
-    if ( myKeyHash.Compare(theKeyNode->GetKey(),aKey) ) 
-      return theKeyNode->GetItem();
-    else theKeyNode = theKeyNode->NextKey();
-  }
-  Standard_NoSuchObject::Raise();
-}
-
-//=======================================================================
-// Function : FindKey
-//=======================================================================
-
-Key PCollection_HDoubleMap::FindKey ( const Item &anItem ) const
-{
-  Standard_Integer ResHashItem;
-  Handle(PCollection_DoubleMapNode) theItemNode;
-
-  ResHashItem = myItemHash.HashCode(anItem,myArrayItem->Length());
-  theItemNode = myArrayItem->Value(ResHashItem);
-  while ( ! theItemNode.IsNull() ) {
-    if ( myItemHash.Compare(theItemNode->GetItem(),anItem) ) 
-      return theItemNode->GetKey();
-    else theItemNode = theItemNode->NextItem();
-  }
-  Standard_NoSuchObject::Raise();
-}
-
-//=======================================================================
-// Function : UnbindKey
-//=======================================================================
-
-void PCollection_HDoubleMap::UnbindKey ( const Key &aKey )
-{
-  Standard_Integer ResHashKey,ResHashItem;
-  Handle(PCollection_DoubleMapNode) 
-    currentKeyNode,previousKeyNode,previousItemNode,currentItemNode,nullNode;
-  Standard_Boolean NoKey = Standard_True;
-  Standard_Boolean NoItem = Standard_True;
-
-  ResHashKey = myKeyHash.HashCode(aKey,myArrayKey->Length());
-  currentKeyNode = myArrayKey->Value(ResHashKey);
-  while ( NoKey && !currentKeyNode.IsNull() ) {
-    if ( myKeyHash.Compare(currentKeyNode->GetKey(),aKey) ) 
-      NoKey = Standard_False;
-    else {
-      previousKeyNode = currentKeyNode;
-      currentKeyNode = currentKeyNode->NextKey();
-    }
-  }
-  
-  if ( NoKey ) Standard_NoSuchObject::Raise();
-  else {
-    ResHashItem = 
-      myItemHash.HashCode(currentKeyNode->GetItem(),myArrayItem->Length());
-    currentItemNode = myArrayItem->Value(ResHashItem);
-    while ( NoItem && !currentItemNode.IsNull() ) {
-      if ( currentItemNode == currentKeyNode ) NoItem = Standard_False;
-      else {
-       previousItemNode = currentItemNode;
-       currentItemNode = currentItemNode->NextItem();
-      }
-    }
-    if ( NoItem ) Standard_NoSuchObject::Raise();
-    else {
-      if ( previousKeyNode.IsNull() ) 
-       myArrayKey->SetValue(ResHashKey,currentKeyNode->NextKey());
-      else
-       previousKeyNode->SetNextKey(currentKeyNode->NextKey());
-
-      if ( previousItemNode.IsNull() )
-       myArrayItem->SetValue(ResHashItem,currentItemNode->NextItem());
-      else
-       previousItemNode->SetNextItem(currentItemNode->NextItem());
-
-      myNumber--;
-      currentKeyNode->SetNextKey(nullNode);
-      currentKeyNode->SetNextItem(nullNode);
-      currentKeyNode.Delete();
-    }
-  }
-
-}
-
-//=======================================================================
-// Function : UnbindItem
-//=======================================================================
-
-void PCollection_HDoubleMap::UnbindItem ( const Item &anItem ) 
-{
-  Standard_Integer ResHashKey,ResHashItem;
-  Handle(PCollection_DoubleMapNode) 
-    currentKeyNode,previousKeyNode,previousItemNode,currentItemNode,nullNode;
-  Standard_Boolean NoKey = Standard_True;
-  Standard_Boolean NoItem = Standard_True;
-
-  ResHashItem = myItemHash.HashCode(anItem,myArrayItem->Length());
-  currentItemNode = myArrayItem->Value(ResHashItem);
-  while ( NoItem && !currentItemNode.IsNull() ) {
-    if ( myItemHash.Compare(currentItemNode->GetItem(),anItem) ) 
-      NoItem = Standard_False;
-    else {
-      previousItemNode = currentItemNode;
-      currentItemNode = currentItemNode->NextItem();
-    }
-  }
-  
-  if ( NoItem ) Standard_NoSuchObject::Raise();
-  else {
-    ResHashKey = 
-      myKeyHash.HashCode(currentItemNode->GetKey(),myArrayKey->Length());
-    currentKeyNode = myArrayKey->Value(ResHashKey);
-    while ( NoKey && !currentKeyNode.IsNull() ) {
-      if ( currentKeyNode == currentItemNode ) NoKey = Standard_False;
-      else {
-       previousKeyNode = currentKeyNode;
-       currentKeyNode = currentKeyNode->NextKey();
-      }
-    }
-    if ( NoKey ) Standard_NoSuchObject::Raise();
-    else {
-      if ( previousItemNode.IsNull() )
-       myArrayItem->SetValue(ResHashItem,currentItemNode->NextItem());
-      else
-       previousItemNode->SetNextItem(currentItemNode->NextItem());
-
-      if ( previousKeyNode.IsNull() ) 
-       myArrayKey->SetValue(ResHashKey,currentKeyNode->NextKey());
-      else
-       previousKeyNode->SetNextKey(currentKeyNode->NextKey());
-
-      myNumber--;
-      currentItemNode->SetNextItem(nullNode);
-      currentItemNode->SetNextKey(nullNode);
-      currentItemNode.Delete();
-    }
-  }
-
-}
-
-//=======================================================================
-// Function : Clear
-//=======================================================================
-
-void PCollection_HDoubleMap::Clear () 
-{
-  Handle(PCollection_DoubleMapNode) nullNode,theNode,delNode;
-  Standard_Integer I;
-
-  myNumber = 0;
-
-  for ( I = 1 ; I <= myArrayItem->Length() ; I++ ) {
-    theNode = myArrayItem->Value(I);
-    myArrayKey->SetValue(I,nullNode);
-    myArrayItem->SetValue(I,nullNode);
-    while ( !theNode.IsNull() ) {
-      delNode = theNode;
-      theNode = theNode->NextItem();
-      delNode->SetNextKey(nullNode);
-      delNode->SetNextItem(nullNode);
-      delNode.Delete();
-    }
-  }
-}
-
-//=======================================================================
-// Function : IsBoundByKey
-//=======================================================================
-
-Standard_Boolean PCollection_HDoubleMap::IsBoundByKey ( const Key &aKey ) const 
-{
-  Standard_Integer ResHashKey;
-  Handle(PCollection_DoubleMapNode) theKeyNode;
-
-  ResHashKey = myKeyHash.HashCode(aKey,myArrayKey->Length());
-  theKeyNode = myArrayKey->Value(ResHashKey);
-  while ( ! theKeyNode.IsNull() ) {
-    if ( myKeyHash.Compare(theKeyNode->GetKey(),aKey) ) 
-      return Standard_True;
-    else theKeyNode = theKeyNode->NextKey();
-  }
-  return Standard_False;
-}
-
-//=======================================================================
-// Function : IsBoundByItem
-//=======================================================================
-
-Standard_Boolean PCollection_HDoubleMap::IsBoundByItem(const Item &anItem) const 
-{
-  Standard_Integer ResHashItem;
-  Handle(PCollection_DoubleMapNode) theItemNode;
-
-  ResHashItem = myItemHash.HashCode(anItem,myArrayItem->Length());
-  theItemNode = myArrayItem->Value(ResHashItem);
-  while ( ! theItemNode.IsNull() ) {
-    if ( myItemHash.Compare(theItemNode->GetItem(),anItem) ) 
-      return Standard_True;
-    else theItemNode = theItemNode->NextItem();
-  }
-  return Standard_False;
-}
-
-//=======================================================================
-// Function : IsEmpty
-//=======================================================================
-
-Standard_Boolean PCollection_HDoubleMap::IsEmpty () const 
-{
-  Standard_Boolean Empty = Standard_True;
-
-  for ( Standard_Integer I = 1 ; I <= myArrayKey->Length() && Empty ; I++ )
-    if ( ! myArrayKey->Value(I).IsNull() ) Empty = Standard_False;
-
-  return Empty;
-}
-
-//=======================================================================
-// Function : GetArrayKey
-//=======================================================================
-
-Handle(PCollection_ArrayDoubleMap) PCollection_HDoubleMap::
-                                               GetArrayKey () const 
-{
-  return myArrayKey;
-}
-
diff --git a/src/PCollection/PCollection_HIndexedDataMap.cdl b/src/PCollection/PCollection_HIndexedDataMap.cdl
deleted file mode 100644 (file)
index 672f48f..0000000
+++ /dev/null
@@ -1,217 +0,0 @@
--- Copyright (c) 1992-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
----Version: 
-
---  Version    Date         Purpose
---              18/12/92     Creation   
-
-generic class HIndexedDataMap from PCollection ( Key      as Storable;
-                                           Item     as Storable;
-                                           KeyHash  as Hash(Key)
-                                        )
-           
----Purpose: The HIndexedDataMap is a hashed set of objects of Type Key, called 
--- Keys. Keys can be inserted in the Map but not removed. The Map 
--- keeps the number of keys called NbKeys. Each time a Key is
--- inserted the Map tests if this Key is already in the Map. If 
--- it is, nothing is done. If not, NbKeys is incremented and it's 
--- value is bound to the Key and called the Index.
--- 
--- The Map provides methods to inquire the Index of a Key and to 
--- retrieve a Key from an Index in the range 1..NbKeys.
--- 
--- Another Datum of the type Item can be stored with the Key. The 
--- Item can be retrieved from the Key and from the Index of the
--- Key. The Item stored with a Key can be modified.
-
-inherits Persistent from Standard
-
-raises
-
-    OutOfRange from Standard
-    
-
-class IndexedDataMapNode from PCollection inherits PManaged from PMMgt
-
----Purpose: This class is used in the implementation of the IndexedDataMap class. 
--- It stores three elements : a Key, an Item and an Integer Index. 
--- It  also stores two references to IndexedDataMapNode objects, 
--- IndexedDataMapNode are used to make lists in the Hashed IndexedDataMap.
-
-is
-
-    Create(aKey : Key; Index : Integer; anItem : Item; NextKey,NextIndex
-       : IndexedDataMapNode )returns mutable IndexedDataMapNode;
-    ---Purpose: Creates a IndexedDataMapNode;
-
-    Set(me : mutable; aKey : Key; Index : Integer; anItem : Item; 
-           NextK,NextI : IndexedDataMapNode) is static;
-    ---Level: Internal
-    ---Purpose: Sets the values of <me>.
-
-    SetItem ( me : mutable; anItem : Item) is static;
-    ---Level: Internal
-    ---Purpose: Sets the item.
-    
-    SetNextKey ( me : mutable ; aNode : IndexedDataMapNode ) is static;
-    ---Level: Internal
-    ---Purpose: Sets the next node of Key hashed list.
-
-    SetNextIndex ( me : mutable ; aNode : IndexedDataMapNode ) is static;
-    ---Level: Internal
-    ---Purpose: Sets the next node of Key hashed list.
-
-    GetKey ( me ) returns any Key is static;
-    ---Level: Internal
-    ---Purpose: Returns the key.
-    
-    Index ( me ) returns Integer is static;
-    ---Level: Internal
-    ---Purpose: Returns the index.
-    
-    GetItem ( me ) returns any Item is static;
-    ---Level: Internal
-    ---Purpose: Returns the item.
-    
-    IndexAndItem(me; Index : out Integer; theItem : out any Item) is static;
-    ---Level: Internal
-    ---Purpose: Returns index and item.
-    
-    KeyAndItem(me; theKey : out any Key; theItem : out any Item) is static;
-    ---Level: Internal
-    ---Purpose: Returns key and item.
-    
-    NextKey ( me ) returns any IndexedDataMapNode is static;
-    ---Level: Internal
-    ---Purpose: Returns the next node of Key hashed list.
-
-    NextIndex ( me ) returns any IndexedDataMapNode is static;
-    ---Level: Internal
-    ---Purpose: Returns the next node of Index hashed list.
-
-fields
-
-    myKey       : Key;
-    myIndex     : Integer;
-    myItem      : Item;
-    myNextKey   : IndexedDataMapNode;
-    myNextIndex : IndexedDataMapNode;
-
-end IndexedDataMapNode;
-    
-class ArrayIndexedDataMap instantiates 
-                       HArray1 from PCollection (IndexedDataMapNode);
-    
-is
-
-    Create ( NbBuckets : Integer; fhKey : KeyHash ) returns mutable HIndexedDataMap;
-    ---Purpose: Creates an empty HIndexedDataMap, NbBuckets is an estimation of the
-    -- number of Keys that will be stored in the Map. It is not 
-    -- limited, but a too small number may reduce performance.
-
-    NbBuckets ( me ) returns Integer;
-    ---Level: Public
-    ---Purpose: Returns the number of entries in the indexed map.
-
-    NbKeys(me) returns Integer;
-    ---Level: Public
-    ---Purpose: Returns the number of Keys stored in the Map.
-    
-    Bind(me : mutable ; aKey : Key; anItem : Item; OverWrite : Boolean ) 
-       returns Integer;
-    ---Level: Public
-    ---Purpose: Adds a new Key and returns the Index. 
-    -- If the Key is new in the Map the Item is bound with the Key. 
-    -- If the Key is already present the Item replaces the existing
-    -- Item if Overwrite is True.
-    
-    FindIndex ( me ; aKey : Key ) returns Integer;
-    ---Level: Public
-    ---Purpose: Returns the Index of the Key in the Map. If the Key is not 
-    -- stored the returned Index is 0.
-    
-    FindKey ( me ; Index : Integer ) returns any Key
-    ---Level: Public
-    ---Purpose: Returns the Key stored with the Index, Index must be in the 
-    -- range 1..NbKeys.
-    raises OutOfRange from Standard;
-    
-    FindItemFromKey ( me ; aKey : Key ) returns any Item
-    ---Level: Public
-    ---Purpose: Returns the Item stored with the Key <aKey>.
-    ---Trigger: An exception is raised if the key <aKey> is not stored in the Map.
-    raises OutOfRange from Standard;
-    
-    FindItemFromIndex ( me ; Index : Integer ) returns any Item
-    ---Level: Public
-    ---Purpose: Returns the Item stored with the index <Index>. This  is 
-    -- similar to but faster than K = GetKey(Index); GetItem(K,I)
-    ---Trigger: An exception is raised if <Index> is not in the range 1..NbKeys.
-    raises OutOfRange from Standard;
-    
-    FindIndexAndItem(me; aKey : Key; Index : out Integer; theItem : out Item)
-    ---Level: Public
-    ---Purpose: Returns the index and the item stored with the Key <aKey>.
-    ---Trigger: An exception is raised if the key <aKey> is not stored in the Map.
-    raises OutOfRange from Standard;
-    
-    FindKeyAndItem(me; Index : Integer; theKey : out Key; theItem : out Item)
-    ---Level: Public
-    ---Purpose: Returns the key and the item stored with the index <Index>.
-    ---Trigger: An exception is raised if <Index> is not in the range 1..NbKeys.
-    raises OutOfRange from Standard;
-    
-    SetItemToKey(me : mutable; aKey : Key; anItem : Item)
-    ---Level: Public
-    ---Purpose: Modifies the item stored with the key <aKey>.
-    ---Trigger: An exception is raised if the key <aKey> is not stored in the Map.
-    raises OutOfRange from Standard;
-    
-    SetItemToIndex(me : mutable; Index : Integer; anItem : Item)
-    ---Level: Public
-    ---Purpose: Modifies the item stored with the index <Index>.
-    ---Trigger: An exception is raised if <Index> is not in the range 1..NbKeys.
-    raises OutOfRange from Standard;
-
-    Clear ( me : mutable );
-    ---Level: Public
-    ---Purpose: Clears the Map content.
-    
-    IsBound ( me ; aKey : Key) returns Boolean;
-    ---Level: Public
-    ---Purpose: Returns True if an element is bound by <aKey>.
-    
-    LocateKey(me; aKey : Key) returns any IndexedDataMapNode
-    ---Level: Internal
-    ---Purpose: Returns the node containing <aKey>.
-    is static private;
-    
-    LocateIndex(me; Index : Integer) returns any IndexedDataMapNode
-    ---Level: Internal
-    ---Purpose: Returns the node containing <Index>.
-    is static private;
-    
-fields
-
-    myNumber       : Integer;
-    myKeyHash      : KeyHash;
-    myArrayKey     : ArrayIndexedDataMap;
-    myArrayIndices : ArrayIndexedDataMap;
-    
-end HIndexedDataMap;
-
-
-
-
diff --git a/src/PCollection/PCollection_HIndexedDataMap.gxx b/src/PCollection/PCollection_HIndexedDataMap.gxx
deleted file mode 100644 (file)
index 1ef53e9..0000000
+++ /dev/null
@@ -1,311 +0,0 @@
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//-Version: 
-
-//  Version    Date         Purpose
-//              14/12/92     Creation   
-
-//-Language     C++2.0
-
-//-Declarations
-#include <Standard_OutOfRange.hxx>
-
-//=======================================================================
-// Function : PCollection_HIndexedDataMap
-// Purpose  : 
-//=======================================================================
-
-PCollection_HIndexedDataMap::PCollection_HIndexedDataMap
-  (const Standard_Integer NbBuckets, const KeyHash &fhKey) 
-{
-  myNumber = 0;
-  myArrayKey = new PCollection_ArrayIndexedDataMap(1,NbBuckets);
-  myArrayIndices = new PCollection_ArrayIndexedDataMap(0,NbBuckets-1);
-  myKeyHash = fhKey;
-}
-
-//=======================================================================
-// Function : NbBuckets
-// Purpose  : 
-//=======================================================================
-
-Standard_Integer PCollection_HIndexedDataMap::NbBuckets() const
-{
-  return myArrayKey->Length();
-}
-
-//=======================================================================
-// Function : NbKeys
-// Purpose  : 
-//=======================================================================
-
-Standard_Integer PCollection_HIndexedDataMap::NbKeys() const
-{
-  return myNumber;
-}
-
-//=======================================================================
-// Function : Bind
-// Purpose  : 
-//=======================================================================
-
-Standard_Integer PCollection_HIndexedDataMap::Bind(const Key& aKey,
-                                  const Item& anItem,
-                                  const Standard_Boolean OverWrite)
-{
-  Standard_Integer theSize = myArrayKey->Length();
-
-  Standard_Integer hcode = myKeyHash.HashCode(aKey,theSize);
-  Handle(PCollection_IndexedDataMapNode) theNode = myArrayKey->Value(hcode);
-  while (! theNode.IsNull()) {
-    if ( myKeyHash.Compare(theNode->GetKey(),aKey)) {
-      // if the Key already exists, update the item and  return the index
-      if (OverWrite) {
-       theNode->SetItem(anItem);
-      }
-      return theNode->Index();
-    }
-   else {
-      theNode = theNode->NextKey();
-    }
-  }
-  
-  // the Key was not Found, create a new Elem
-  myNumber++;
-  Standard_Integer hint = myNumber % theSize;
-  Handle(PCollection_IndexedDataMapNode) theNewNode = 
-   new PCollection_IndexedDataMapNode(aKey, myNumber, anItem,
-                                   myArrayKey->Value(hcode),
-                                   myArrayIndices->Value(hint));
-  myArrayKey->SetValue(hcode,theNewNode);
-  myArrayIndices->SetValue(hint,theNewNode);
-
-  return myNumber;
-}
-
-//=======================================================================
-// Function : FindIndex
-// Purpose  : returns the Index of the Key, 0 if the Key is not stored
-//=======================================================================
-
-Standard_Integer PCollection_HIndexedDataMap::FindIndex(const Key& aKey) const
-{
-  Standard_Integer ResHash;
-  Handle(PCollection_IndexedDataMapNode) theKeyNode;
-
-  // search the Key in the map
-  ResHash = myKeyHash.HashCode(aKey,myArrayKey->Length());
-  theKeyNode = myArrayKey->Value(ResHash);
-  while (! theKeyNode.IsNull()) {
-    if ( myKeyHash.Compare(theKeyNode->GetKey(),aKey))
-      // if the Key already exists stop the search
-      return theKeyNode->Index();
-
-    else
-      // go to next element
-      theKeyNode = theKeyNode->NextKey();
-  }
-  // not found, return 0
-  return 0;
-}
-
-//=======================================================================
-// Function : FindKey
-// Purpose  : 
-//=======================================================================
-
-Key PCollection_HIndexedDataMap::FindKey(const Standard_Integer Index) const
-{
-  // search the index
-  Handle(PCollection_IndexedDataMapNode) theNode = LocateIndex(Index);
-  // get the Key
-  return theNode->GetKey();
-}
-
-//=======================================================================
-// Function : FindItemFromKey
-// Purpose  : return the Item stored with the  Key
-//=======================================================================
-
-Item PCollection_HIndexedDataMap::FindItemFromKey(const Key& aKey) const
-{
-  // find the Key
-  Handle(PCollection_IndexedDataMapNode) theNode = LocateKey(aKey);
-
-  // get the Item
-  return theNode->GetItem();
-}
-
-//=======================================================================
-// Function : FindItemFromIndex
-// Purpose  : Find an Item from the index
-//=======================================================================
-
-Item PCollection_HIndexedDataMap::FindItemFromIndex
-  (const Standard_Integer Index) const
-{
-  // search the index
-  Handle(PCollection_IndexedDataMapNode) theNode = LocateIndex(Index);
-  // get the Item
-  return theNode->GetItem();
-}
-
-//=======================================================================
-// Function : FindIndexAndItem
-// Purpose  : find the index and the Item for a key
-//=======================================================================
-
-void PCollection_HIndexedDataMap::FindIndexAndItem(const Key& aKey,
-                                             Standard_Integer& Index,
-                                             Item& theItem) const
-{
-  // find the Key
-  Handle(PCollection_IndexedDataMapNode) theNode = LocateKey(aKey);
-
-  // get Index and Item
-  theNode->IndexAndItem(Index,theItem);
-}
-
-//=======================================================================
-// Function : FindKeyAndItem
-// Purpose  : find the Key and the Item for an Index
-//=======================================================================
-
-void PCollection_HIndexedDataMap::FindKeyAndItem(const Standard_Integer Index,
-                                           Key& theKey, 
-                                           Item& theItem) const
-{
-  // find the index
-  Handle(PCollection_IndexedDataMapNode) TheNode = LocateIndex(Index);
-
-  // get Key and Item
-  TheNode->KeyAndItem(theKey,theItem);
-}
-
-//=======================================================================
-// Function : SetItemToKey
-// Purpose  : change the Item stored with a Key
-//=======================================================================
-
-void PCollection_HIndexedDataMap::SetItemToKey(const Key& aKey,
-                                         const Item& anItem)
-{
-  // find the Key
-  Handle(PCollection_IndexedDataMapNode) TheNode = LocateKey(aKey);
-
-  // set the Item
-  TheNode->SetItem(anItem);
-}
-
-//=======================================================================
-// Function : SetItemToIndex
-// Purpose  : change the Item stored with an Index
-//=======================================================================
-
-void PCollection_HIndexedDataMap::SetItemToIndex(const Standard_Integer Index,
-                                           const Item& anItem)
-{
-  // find the Key
-  Handle(PCollection_IndexedDataMapNode) TheNode = LocateIndex(Index);
-
-  // set the Item
-  TheNode->SetItem(anItem);
-}
-
-//=======================================================================
-// Function : Clear
-// Purpose  : 
-//=======================================================================
-
-void PCollection_HIndexedDataMap::Clear()
-{
-  Handle(PCollection_IndexedDataMapNode) nullNode,theNode,delNode;
-  Standard_Integer I;
-
-  myNumber = 0;
-
-  for ( I = 0 ; I < myArrayKey->Length() ; I++ ) {
-    theNode = myArrayKey->Value(I+1);
-    myArrayKey->SetValue(I+1,nullNode);
-    myArrayIndices->SetValue(I,nullNode);
-    while ( !theNode.IsNull() ) {
-      delNode = theNode;
-      theNode = theNode->NextKey();
-      delNode->SetNextKey(nullNode);
-      delNode->SetNextIndex(nullNode);
-      delNode.Delete();
-    }
-  }
-}
-
-//=======================================================================
-// Function : IsBound
-// Purpose  : Standard_True if the Map  contains  the Key
-//=======================================================================
-
-Standard_Boolean PCollection_HIndexedDataMap::IsBound(const Key& aKey) const
-{
-  return (FindIndex(aKey) != 0);
-}
-
-//=======================================================================
-// Function : LocateKey
-// Purpose  : find the Map Element containing a Shape, Null if none
-//=======================================================================
-
-Handle(PCollection_IndexedDataMapNode) 
-     PCollection_HIndexedDataMap::LocateKey(const Key& aKey) const
-{
-  Standard_Integer ResHash = myKeyHash.HashCode(aKey,myArrayKey->Length());
-  // search the Key in the map
-  Handle(PCollection_IndexedDataMapNode) theNode = myArrayKey->Value(ResHash);
-  while (! theNode.IsNull()) {
-    if ( myKeyHash.Compare(aKey,theNode->GetKey()))
-      // if the Key already exists stop the search
-      return theNode;
-    else
-      // go to next element
-      theNode = theNode->NextKey();
-  }
-
-  // raises Standard_OutOfRange
-  Standard_OutOfRange::Raise("HIndexedDataMap : Key not in Map");
-  return theNode;
-}
-
-//=======================================================================
-// Function : LocateIndex
-// Purpose  : find the Map Element containing an Index, check bounds
-//=======================================================================
-
-Handle(PCollection_IndexedDataMapNode) PCollection_HIndexedDataMap::LocateIndex
-       (const Standard_Integer Index) const
-{
-  // check bounds
-  if ((Index < 1)||(Index > myNumber))
-  Standard_OutOfRange::Raise("HIndexedDataMap : Bad Index");
-  // search the Index in the map
-  Handle(PCollection_IndexedDataMapNode) theNode = 
-    myArrayIndices->Value(Index % myArrayIndices->Length());
-  // the Index  SHOULD be in the list, so no NULL checking
-  while (theNode->Index() != Index)
-    theNode = theNode->NextIndex();
-
-  // return the element
-  return theNode;
-}
-
-
-
diff --git a/src/PCollection/PCollection_HQueue.cdl b/src/PCollection/PCollection_HQueue.cdl
deleted file mode 100644 (file)
index fc9e90b..0000000
+++ /dev/null
@@ -1,158 +0,0 @@
--- Created on: 1993-02-10
--- Created by: Mireille MERCIEN
--- Copyright (c) 1993-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-generic class HQueue from PCollection (Item as Storable)
-inherits Persistent
-
-     ---Purpose: A queue is a sequence of items in which items 
-     -- are added at one end (called the back of the
-     -- queue) and removed at the other end (called
-     -- the front)
-     -- The Queue is empty if there are no elements.
-
-raises   NoSuchObject from Standard
-
-
-    class QueueNode instantiates HSingleList from PCollection(Item);
-
-    class QueueIterator from PCollection 
-                                          
-        ---Purpose: Iterator of the class Queue.
-
-    raises NoMoreObject from Standard,
-           NoSuchObject from Standard
-    is     
-       Create(Q : HQueue from PCollection) 
-       returns QueueIterator from PCollection;
-        ---Purpose: Creates an iterator on the queue Q.
-        -- Sets the iterator at the beginning of the Queue Q.
-
-       More(me) returns Boolean from Standard;
-        ---Level: Public
-        ---Purpose: Returns True if there are other items.
-
-       Next(me: in out) raises NoMoreObject from Standard;
-        ---Level: Public
-       ---Purpose: Sets the iterator to the next item.
-           
-       Value(me) returns any Item raises NoSuchObject from Standard;
-        ---Level: Public
-       ---Purpose: Returns the item value corresponding to 
-       -- the current position of the iterator.
-
-    fields
-        TheIterator : QueueNode;
-    end;
-
-
-is     
-     Create returns mutable HQueue from PCollection;
-       ---Purpose: Creates an empty queue.
-
-     Length(me) returns Integer from Standard;
-        ---Level: Public
-       ---Purpose: Returns the number of items in the queue.
-       ---Example: before
-       --   me = (A B C) 
-       -- returns 3
-
-     IsEmpty(me) returns Boolean from Standard;
-        ---Level: Public
-       ---Purpose: Returns True if the queue contains no element.
-
-     Front(me) returns any Item raises NoSuchObject from Standard; 
-        ---Level: Public
-       ---Purpose: Returns the item at the front of the queue.
-       -- Raises an exception if the queue is empty.
-        ---Example: before
-       --   me = (A B C) 
-        -- after
-       --   me = (A B C)
-               -- returns 
-       --   A
-     
-     FFront(me) returns QueueNode; 
-        ---Level: Public
-       ---Purpose: Returns the field TheFront(the front of the queue).
-
-     FBack(me) returns QueueNode; 
-        ---Level: Public
-       ---Purpose: Returns the field Theback(the back of the queue).
-
-     Clear(me : mutable);
-        ---Level: Public
-       ---Purpose: Removes all the elements from the queue
-       ---Example: before
-       --   me = (A B C) 
-        -- after
-        --   me = ()
-
-     Push(me : mutable; T : Item);
-        ---Level: Public
-       ---Purpose: Inserts an item at the back of the queue.
-       ---Example: before
-       --   me = (A B) , T = C
-        -- after
-       --   me = (A B C)
-
-     Pop(me : mutable) raises NoSuchObject from Standard;
-        ---Level: Public
-       ---Purpose: Removes an item from the front of the queue.
-       -- Raises an exception if the queue is empty
-       ---Example: before
-       --   me = (A B C)
-        -- after
-       --   me = (B C)
-       -- returns 
-       --   A
-     ChangeFront(me:mutable ; T : Item) raises NoSuchObject from Standard;
-        ---Level: Public
-       ---Purpose: Replaces the front element of the queue with T.
-       -- Raises an exception if the queue is empty.
-       ---Example: before
-       --   me = (A B C) , T = D
-        -- after
-       --   me = (D B C)
-
-     ShallowCopy(me) 
-        returns mutable like me 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-     ShallowDump (me; s: in out OStream) 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-    Destroy(me : mutable);
-    ---C++: alias ~
-    
-fields
-     TheFront   : QueueNode;
-     TheBack    : QueueNode;
-     TheLength  : Integer from Standard;  
-end; 
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HQueue.gxx b/src/PCollection/PCollection_HQueue.gxx
deleted file mode 100644 (file)
index d063e02..0000000
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NotImplemented.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// ------------
-// constructor
-// -----------
-
-PCollection_HQueue::PCollection_HQueue() 
-{
-    TheLength = 0;
-    TheFront  = new PCollection_QueueNode;
-    TheBack   = TheFront;
-}
-
-// -----------------------------
-// IsEmpty : is the queue empty ? 
-// -----------------------------
-Standard_Boolean PCollection_HQueue::IsEmpty() const {
-    return TheLength == 0;
-} 
-
-// --------------------------------------
-// Front : item at the front of the Queue 
-// --------------------------------------
-Item PCollection_HQueue::Front() const 
-{
-    if (TheFront->IsEmpty()) Standard_NoSuchObject::Raise();
-    return TheFront->Value();
-}
-
-// --------------------------------------
-// Clear : remove all items in the Queue 
-// --------------------------------------
-void PCollection_HQueue::Clear()
-{   
-   Handle(PCollection_QueueNode) temp; 
-   while (TheLength != 0) {    
-      temp = TheFront;
-      TheFront = TheFront->Tail();
-      if (TheLength == 1) TheBack = TheFront;
-      temp.Delete();
-      --TheLength;
-   }  
-}
-
-// ------------------------------------
-// Push : insert an item at the back
-// ------------------------------------
-void PCollection_HQueue::Push(const Item& T)
-{   
-    Handle(PCollection_QueueNode) L;
-    L = new PCollection_QueueNode;
-    if (TheLength == 0) 
-     {
-        L->ChangeForwardPointer(TheFront);
-        TheBack = L;
-        TheFront = TheBack;
-     }
-    else
-     { 
-        L->ChangeForwardPointer(TheBack->Tail()); 
-        TheBack->ChangeForwardPointer(L);
-        TheBack = L;
-      };
-    TheBack->SetValue(T);
-    TheLength = TheLength + 1;          
-  }
-
-// ------------------------------------
-// Pop : remove an item from the front
-// ------------------------------------
-void PCollection_HQueue::Pop()
-{   
-    if (TheFront->IsEmpty()) Standard_NoSuchObject::Raise();
-    Handle(PCollection_QueueNode) temp = TheFront;
-    TheFront = TheFront->Tail();
-    temp.Delete();
-    TheLength = TheLength - 1;
-    if (TheLength == 0) TheBack = TheFront;
-}
-
-// ------------------------------------
-// ChangeFront : replace the front by T
-// ------------------------------------
-void PCollection_HQueue::ChangeFront(const Item& T)
-{   
-    if (TheFront->IsEmpty()) Standard_NoSuchObject::Raise();
-    TheFront->SetValue(T);       
-}
-
-// ------------------------------------
-// ShallowCopy
-// ------------------------------------
-Handle(Standard_Persistent) PCollection_HQueue::ShallowCopy() const
-{
-  Handle(PCollection_HQueue) TheCopy;
-  Handle(PCollection_QueueNode) TheList;
-
-  TheCopy = new PCollection_HQueue;
-  TheList = TheFront;
-
-
-  for (Standard_Integer I = 1; I <= TheLength; I++){
-    TheCopy->Push(TheList->Value());
-    TheList = TheList->Tail();
-  }
-
-  return TheCopy;
-  
-}
-
-// ------------------------------------
-// ShallowDump
-// ------------------------------------
-void PCollection_HQueue::ShallowDump(Standard_OStream& S) const
-{
-  S << "begin class Queue "<< endl;
-  S << "Length of Queue : "<< TheLength << endl;
-  TheFront->ShallowDump(cout);
-  S << "end of class Queue." << endl;
-}
-
-
-
-// -----------------------------
-// Length : numbers of items 
-// -----------------------------
-Standard_Integer PCollection_HQueue::Length() const {
-    return TheLength;
-} 
-
-// -----------------------------
-// FFront : front of the queue  
-// -----------------------------
-Handle(PCollection_QueueNode) PCollection_HQueue::FFront() const {
-    return TheFront;
-} 
-
-// -----------------------------
-// FBack : the back of the queue  
-// -----------------------------
-Handle(PCollection_QueueNode) PCollection_HQueue::FBack() const {
-    return TheBack;
-} 
-
-void PCollection_HQueue::Destroy()
-{
-#ifdef CSFDB
-  Clear();
-#endif
-}
diff --git a/src/PCollection/PCollection_HSet.cdl b/src/PCollection/PCollection_HSet.cdl
deleted file mode 100644 (file)
index 42c601c..0000000
+++ /dev/null
@@ -1,171 +0,0 @@
--- Created on: 1991-09-02
--- Created by: Mireille MERCIEN
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-generic class HSet from PCollection (Item as Storable) 
-inherits Persistent
-
-     ---Purpose: A set is an unordered collection of items.
-     -- We can not have duplicated items in a given set.
-    
-raises   NoSuchObject from Standard
-
-
-    class SetNode instantiates HSingleList from PCollection(Item); 
-
-    class SetIterator from PCollection                                       
-        ---Purpose: Iterator of the Set class.
-
-    raises NoMoreObject from Standard,
-           NoSuchObject from Standard
-    is     
-       Create(S : HSet from PCollection) 
-        returns SetIterator from PCollection;
-        ---Purpose: Creates an iterator on the set S.
-        -- Set the iterator at the beginning of the set S.
-
-       More(me) returns Boolean from Standard;
-        ---Level: Public
-        ---Purpose: Returns True if there are other items.
-
-       Next(me: in out) raises NoMoreObject from Standard;
-        ---Level: Public
-       ---Purpose: Sets the iterator to the next item.
-               
-       Value(me) returns any Item raises NoSuchObject from Standard;
-        ---Level: Public
-       ---Purpose: Returns the item value corresponding to 
-       -- the current position of the iterator.
-
-    fields
-        TheIterator : SetNode;
-    end;
-
-
-is
-
-     Create returns mutable HSet from PCollection;
-        ---Purpose: Creation of an empty set.
-
-     Extent(me) returns Integer from Standard;
-        ---Level: Public
-        ---Purpose: Number of items in the set me
-        ---Example: if S is the set {a,b,c,d,e} 
-        -- Extent returns 5
-
-     Last(me) returns SetNode;
-        ---Level: Public
-        ---Purpose: Returns the field TheLast .
-        -- (the last item enterred in the set)
-
-     IsEmpty(me) returns Boolean from Standard;
-        ---Level: Public
-        ---Purpose: Returns True if the set me is empty.
-
-     Clear(me : mutable);
-        ---Level: Public
-       ---Purpose: Removes all the items of the set me.
-        ---Example: before
-        --   me = {a,b,c,d}
-        -- after
-        --   me = {}
-
-     Add(me : mutable; T : Item) returns Boolean from Standard;
-        ---Level: Public
-       ---Purpose: Adds an item T in the set me if it does not already exist.
-       -- Returns False if the item T already exists, True otherwise. 
-        ---Example: before
-        --   me = {a,b,c,d}, T = y
-        -- after
-        --   me = {a,b,c,d,y}
-
-     Remove(me : mutable; T : Item) raises NoSuchObject from Standard;
-        ---Level: Public
-        ---Purpose: Removes the item T in the set me
-        -- Raises an exception if the item is not in the set.
-        ---Example: before
-        --   me = {a,b,c,d}, T = a
-        -- after
-        --   me = {b,c,d}
-        -- returns ()
-     Union(me; B : HSet from PCollection) returns mutable HSet from PCollection;
-        ---Level: Public
-        ---Purpose: Creation of a set containing all the items 
-        -- of the set me and all the items of the set B which 
-        -- are not in me.
-        ---Example: before
-        --   me = {a,b,c}, B = {d,a,f}
-        -- after
-        --   me = {a,b,c}, B = {d,a,f}
-        -- returns
-        -- {a,b,c,d,f}
-
-     Intersection(me; B : HSet from PCollection) returns mutable HSet from PCollection;
-        ---Level: Public
-        ---Purpose: Creation of a set containing all the 
-        -- items which are both in the set <me> and in the set B.
-        ---Example: before
-        --   me = {a,b,c}, B = {d,a,f}
-        -- after
-        --   me = {a,b,c}, B = {d,a,f}
-        -- returns
-        --   {a}
-
-     Difference(me; B: HSet from PCollection) returns mutable HSet from PCollection;
-        ---Level: Public
-        ---Purpose: Creation of a set containing the items 
-        -- which are in the set me and not in the set B.
-        ---Example: before
-        --   me = {a,b,c}, B = {d,a,f}
-        -- after
-        --   me = {a,b,c}, B = {d,a,f}
-        -- returns
-        --   {b,c}
-
-     Contains(me; T : Item) returns Boolean from Standard;
-        ---Level: Public
-        ---Purpose: Returns True if an item is in the set me.
-
-     IsASubset(me; S : HSet from PCollection) returns Boolean from Standard;
-        ---Level: Public
-        ---Purpose: Returns True if a set is contained in the set me.
-        -- The two sets can be identical.
-
-     IsAProperSubset(me; S : HSet from PCollection) returns Boolean from 
-        Standard;
-        ---Level: Public
-        ---Purpose: Returns True if a set is contained in the set me.
-        -- The two sets cannot be identical.
-
-     ShallowCopy(me) 
-        returns mutable like me 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-     ShallowDump (me; s: in out OStream) 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-
-fields
-     TheExtent   : Integer from Standard;
-     TheLast     : SetNode;
-end;
diff --git a/src/PCollection/PCollection_HSet.gxx b/src/PCollection/PCollection_HSet.gxx
deleted file mode 100644 (file)
index cef6ea4..0000000
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NotImplemented.hxx>
-
-// ------------
-// constructor
-// -----------
-
-PCollection_HSet::PCollection_HSet() 
-{
-    TheExtent   = 0;
-    TheLast     = new PCollection_SetNode;
-}
-
-// -----------------------------
-// IsEmpty : is the Set empty ? 
-// -----------------------------
-Standard_Boolean PCollection_HSet::IsEmpty() const 
-{
-    return TheLast->IsEmpty();
-} 
-
-// ----------------
-// Contains an item 
-// ----------------
-Standard_Boolean PCollection_HSet::Contains(const Item& T) const
-{
-    Standard_Boolean Ilela;
-    Handle(PCollection_SetNode) TheCurrent;
-    TheCurrent = TheLast; 
-    Ilela      = Standard_False;
-    while (!Ilela && !TheCurrent->IsEmpty())
-      { 
-       if (TheCurrent->Value() == T) 
-          Ilela      = Standard_True;
-       else
-          TheCurrent = TheCurrent->Tail();       
-      };     
-    return Ilela;
-}    
-
-// ---------------------------------
-// The Set S IsASubset of the set me
-// ---------------------------------
-Standard_Boolean PCollection_HSet::IsASubset(const Handle(PCollection_HSet)& S) const 
-{
-    Standard_Boolean Ilela,Ilsonla;
-    Handle(PCollection_SetNode) TheCurrent1,TheCurrent2;
-    TheCurrent1 = TheLast;
-    TheCurrent2 = S->Last(); 
-    Ilela       = Standard_False;
-    Ilsonla     = Standard_True;
-    while (Ilsonla && !TheCurrent2->IsEmpty())
-    { 
-      while (!Ilela && !TheCurrent1->IsEmpty())
-      { 
-       if (TheCurrent1->Value() == TheCurrent2->Value()) 
-          Ilela = Standard_True;
-       else
-          TheCurrent1 = TheCurrent1->Tail();       
-      };     
-    if (!Ilela)
-       Ilsonla = Standard_False;
-    else
-      {
-       TheCurrent2 = TheCurrent2->Tail();
-       TheCurrent1 = TheLast;
-      };
-    };    
-    return Ilsonla;
-
-}
-
-// ----------------------------------------
-// The Set S IsAProperSubset of the set me
-// ----------------------------------------
-Standard_Boolean PCollection_HSet::IsAProperSubset(const Handle(PCollection_HSet)& S) const 
-{
-    Standard_Boolean Ilela,Ilsonla;
-    Handle(PCollection_SetNode) TheCurrent1,TheCurrent2;
-    TheCurrent1 = TheLast;
-    TheCurrent2 = S->Last(); 
-    Ilela       = Standard_False;
-    Ilsonla     = Standard_True;
-    if (S->Extent() >= TheExtent) Ilsonla = Standard_False; 
-    while (Ilsonla && !TheCurrent2->IsEmpty())
-    { 
-      while (!Ilela && !TheCurrent1->IsEmpty())
-      { 
-       if (TheCurrent1->Value() == TheCurrent2->Value()) 
-          Ilela      = Standard_True;
-       else
-          TheCurrent1 = TheCurrent1->Tail();       
-      };     
-     if (!Ilela)
-        Ilsonla = Standard_False;
-     else
-       {
-        TheCurrent2 = TheCurrent2->Tail();
-        TheCurrent1 = TheLast;
-       };
-    };    
-    return Ilsonla;
-
-} 
-
-// ------------------------------------
-// Clear : remove all items
-// ------------------------------------
-void PCollection_HSet::Clear() 
-{   
-   Handle(PCollection_SetNode) temp; 
-   while (TheExtent != 0) {
-      temp = TheLast;
-      TheLast = TheLast->Tail();
-#ifndef CSFDB 
-      temp.Delete();
-#endif
-      --TheExtent;
-   }  
-}
-
-// -------------------------------------------
-// Add : insert an item 
-// returns Standard_True if the item has been inserted, 
-// Standard_False otherwise
-// ------------------------------------------- 
-Standard_Boolean PCollection_HSet::Add(const Item& T)
-{   
-    Standard_Boolean Dejala;
-    Handle(PCollection_SetNode) TheCurrent;
-    TheCurrent = TheLast; 
-    Dejala = Standard_False;
-    while (!Dejala && !TheCurrent->IsEmpty())
-      { if (TheCurrent->Value() == T) Dejala = Standard_True;
-        TheCurrent = TheCurrent->Tail();       
-      };     
-    if (!Dejala)
-      {
-       TheLast = TheLast->Construct(T);
-       TheExtent = TheExtent + 1;
-      };     
-    return !Dejala;
-}
-
-// ------------------------
-// Remove : remove an item 
-// from the set me.
-// Raises Standard_NoSuchObject
-// ------------------------
-void PCollection_HSet::Remove(const Item& T)
-{   
-   Standard_Boolean Nepala;
-   Handle(PCollection_SetNode) TheCurrent,ThePrevious;
-   TheCurrent  = TheLast; 
-   ThePrevious = TheLast;
-   Nepala      = Standard_True;
-   while (Nepala && !TheCurrent->IsEmpty()) { 
-      if (TheCurrent->Value() == T) 
-        Nepala      = Standard_False;
-      else {
-        ThePrevious = TheCurrent;
-        TheCurrent  = TheCurrent->Tail();
-      }       
-   }     
-   if (Nepala)
-     Standard_NoSuchObject::Raise();     
-   else {
-     if (TheCurrent == ThePrevious)
-       TheLast = TheLast->Tail();
-     else 
-       ThePrevious->ChangeForwardPointer(TheCurrent->Tail());
-     TheExtent = TheExtent - 1;
-#ifndef CSFDB
-     TheCurrent.Delete();
-#endif
-   }
-}
-
-// ------------------------------------
-// Union with the set S
-// returns a set containing all the 
-// items of the set me and all the items 
-// of the set B which are not in me
-// ------------------------------------
-Handle(PCollection_HSet) PCollection_HSet::Union(const Handle(PCollection_HSet)& S) 
-const 
-{   
-    Standard_Boolean Insere;
-    Handle(PCollection_SetNode) TheCurrent;
-    Handle(PCollection_HSet) Lunion;
-    Lunion = new PCollection_HSet;
-// copier this dans Lunion 
-    TheCurrent = TheLast;
-    while (!TheCurrent->IsEmpty())
-      { 
-       Insere = Lunion->Add(TheCurrent->Value());
-       TheCurrent = TheCurrent->Tail();
-      };
-// Inserer dans Lunion les items de S    
-    TheCurrent = S->Last();
-    while (!TheCurrent->IsEmpty())
-      { 
-       Insere = Lunion->Add(TheCurrent->Value());
-       TheCurrent = TheCurrent->Tail();
-      };
-    return Lunion;
-}
-
-// -----------------------------
-// Intersection with the set S 
-// -----------------------------
-Handle(PCollection_HSet) PCollection_HSet::
-                          Intersection(const Handle(PCollection_HSet)& S)  
-const
-{
-    Item Litem;
-    Standard_Boolean Insere;
-    Handle(PCollection_SetNode) TheCurrent1,TheCurrent2;
-    Handle(PCollection_HSet) Linter;
-    Linter = new PCollection_HSet;
-    TheCurrent1 = TheLast;
-    while (!TheCurrent1->IsEmpty())
-      { 
-       Litem = TheCurrent1->Value();
-       TheCurrent2 = S->Last();
-       while (!TheCurrent2->IsEmpty())
-        {
-          if (TheCurrent2->Value() == Litem) 
-             Insere = Linter->Add(Litem);
-          TheCurrent2 = TheCurrent2->Tail();           
-        };
-       TheCurrent1 = TheCurrent1->Tail();  
-      };
-    return Linter;
-}    
-
-
-// -----------------------------
-// Difference with the set S 
-// returns a set containing the 
-// items which are in the set me
-// and not in the set B 
-// -----------------------------
-Handle(PCollection_HSet) PCollection_HSet::
-                         Difference(const Handle(PCollection_HSet)& S) 
-const
-{    
-    Item Litem;
-    Standard_Boolean Insere,Ilela;
-    Handle(PCollection_SetNode) TheCurrent1,TheCurrent2;
-    Handle(PCollection_HSet) Ladif;
-    Ladif = new PCollection_HSet;
-    TheCurrent1 = TheLast;
-    while (!TheCurrent1->IsEmpty())
-      { 
-       Litem = TheCurrent1->Value();
-       TheCurrent2 = S->Last();
-       Ilela = Standard_False;
-       while (!TheCurrent2->IsEmpty() && !Ilela)
-        {
-          if (TheCurrent2->Value() == Litem)
-             Ilela = Standard_True;
-          else
-             TheCurrent2 = TheCurrent2->Tail();
-        };
-       if (!Ilela)
-       Insere = Ladif->Add(Litem);           
-       TheCurrent1 = TheCurrent1->Tail();  
-      };
-    return Ladif;
-}
-
-
-//---------------------------------------------------------------------
-// ShallowCopy
-//---------------------------------------------------------------------
-Handle(Standard_Persistent) PCollection_HSet::ShallowCopy() const
-{
-
-  PCollection_HSet* TheCopy = new PCollection_HSet (*this);
-  TheCopy->TheLast = 
-      Handle(PCollection_SetNode)::DownCast(::ShallowCopy(TheLast));
-  return TheCopy;
-
-}
-
-//---------------------------------------------------------------------
-// ShallowDump
-//---------------------------------------------------------------------
-void PCollection_HSet::ShallowDump(Standard_OStream& S) const
-{
-
-  S << "begin class Set "<<endl;
-  S << "extent of Set : "<< TheExtent << endl;
-  TheLast->ShallowDump(S);
-  S << "end of class Set." << endl;
-
-}
-
-
-
-
-
-// -----------------------------
-// Extent : numbers of items 
-// -----------------------------
-Standard_Integer PCollection_HSet::Extent() const {
-    return TheExtent;
-} 
-
-// -----------------------------
-// Last : last enterred item  
-// -----------------------------
-Handle(PCollection_SetNode) PCollection_HSet::Last() const {
-    return TheLast;
-} 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HStack.cdl b/src/PCollection/PCollection_HStack.cdl
deleted file mode 100644 (file)
index 46f1fd0..0000000
+++ /dev/null
@@ -1,151 +0,0 @@
--- Created on: 1991-09-02
--- Created by: Mireille MERCIEN
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-generic class HStack from PCollection (Item as Storable) 
-inherits Persistent
-
-    ---Purpose: A stack is a list of items in which items are
-    -- added and removed from the same end, called the 
-    -- top of the stack.
-
-raises   NoSuchObject from Standard
-
-
-    class StackNode instantiates HSingleList from PCollection(Item);
-
-    class StackIterator from PCollection 
-                                          
-        ---Purpose: Iterator of the Stack class.
-
-    raises NoMoreObject from Standard,
-           NoSuchObject from Standard
-    is     
-       Create(S : HStack from PCollection) 
-       returns StackIterator from PCollection;
-        ---Purpose: Creates an iterator on the stack S.
-        -- Set the iterator at the beginning of the stack S.
-
-       More(me) returns Boolean from Standard;
-        ---Level: Public
-        ---Purpose: Returns True if there are other items.
-
-       Next(me: in out) raises NoMoreObject from Standard;
-        ---Level: Public
-       ---Purpose: Sets the iterator to the next item.
-           
-       Value(me) returns any Item raises NoSuchObject from Standard;
-        ---Level: Public
-       ---Purpose: Returns the item value corresponding to 
-       -- the current position of the iterator.
-
-    fields
-        TheIterator : StackNode;
-    end;
-
-
-is
-     Create returns mutable HStack from PCollection;
-       ---Purpose: Creates an empty stack.
-
-     Depth(me) returns Integer from Standard;
-       ---Level: Public
-       ---Purpose: Returns the number of items in the stack.
-       ---Example: if me = (A B C) 
-       -- returns 3
-
-     IsEmpty(me) returns Boolean from Standard;
-       ---Level: Public
-       ---Purpose: Returns True if the stack contains no item.
-
-     Top(me) returns any Item 
-       ---Level: Public
-       ---Purpose: Returns the item on the top of the stack.
-       -- Raises an exception if the stack is empty.
-       ---Example: before
-       --   me = (A B C) 
-       -- after
-       --   me = (A B C)
-       -- returns 
-       --   C
-      raises NoSuchObject from Standard;
-
-     FTop(me) returns StackNode; 
-       ---Level: Public
-       ---Purpose: Returns the field TheTop (the top of the stack).
-
-     Push(me : mutable; T : Item);
-       ---Level: Public
-       ---Purpose: Inserts an item on the top of the stack.
-       ---Example: before
-       --   me = (A B) , T = C
-       -- after
-       --   me = (A B C)
-
-     Pop(me : mutable) raises NoSuchObject from Standard;
-       ---Level: Public
-       ---Purpose: Removes an item from the top of the stack.
-       -- Raises an exception if the stack is empty.
-       ---Example: before
-       --   me = (A B C) 
-       -- after    
-       --   me = (A B)
-       -- returns
-       --   C
-
-     Clear(me : mutable);
-       ---Level: Public
-       ---Purpose: Removes all the items from the stack.
-       ---Example: before
-       --   me = (A B C) 
-       -- after
-       --   me = ()
-     ChangeTop(me:mutable; T : Item) raises NoSuchObject from Standard;
-       ---Level: Public
-       ---Purpose: Replaces the top of the stack with T.
-       -- Raises an exception if the stack is empty.
-       ---Example: before
-       --   me = (A B C) , T = D
-       -- after
-       --   me = (A B D)
-
-
-     ShallowCopy(me) 
-        returns mutable like me 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-     ShallowDump (me; s: in out OStream) 
-        is redefined;
-        ---Level: Advanced
-       ---C++: function call
-
-
-
-fields
-     TheTop   : StackNode;
-     TheDepth : Integer from Standard;
-     
-end; 
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_HStack.gxx b/src/PCollection/PCollection_HStack.gxx
deleted file mode 100644 (file)
index 85b446e..0000000
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NotImplemented.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// ------------
-// constructor
-// -----------
-
-PCollection_HStack::PCollection_HStack() 
-{
-    TheDepth = 0;
-    TheTop = new PCollection_StackNode;
-}
-
-// ------------------------------------
-// Push : insert an item on the top
-// ------------------------------------
-void PCollection_HStack::Push(const Item& T)
-{   
-    TheTop = TheTop->Construct(T);
-    TheDepth = TheDepth + 1;
-          
-  }
-
-// ------------------------------------
-// Pop : remove an item from the top
-// ------------------------------------
-void PCollection_HStack::Pop()
-{   
-    if (TheTop->IsEmpty()) Standard_NoSuchObject::Raise();
-    Handle(PCollection_StackNode) temp = TheTop;
-    TheTop = TheTop->Tail();
-    temp.Delete();
-    TheDepth = TheDepth - 1;
-}
-
-
-// -----------------------------
-// IsEmpty : is the stack empty ? 
-// -----------------------------
-Standard_Boolean PCollection_HStack::IsEmpty() const 
-{
-    return TheTop->IsEmpty();
-} 
-
-// ------------------------------------
-// Clear : remove all items
-// ------------------------------------
-void PCollection_HStack::Clear() 
-{   
-   Handle(PCollection_StackNode) temp; 
-   while (TheDepth != 0) {    
-      temp = TheTop;
-      TheTop = TheTop->Tail();
-      temp.Delete();
-      --TheDepth;
-   }  
-}
-
-// ------------------------------------
-// ChangeTop : replace the top by T
-// ------------------------------------
-void PCollection_HStack::ChangeTop(const Item& T)
-{   
-    if (TheTop->IsEmpty()) Standard_NoSuchObject::Raise();
-    TheTop->SetValue(T);       
-}
-
-// -----------------------------
-// Top : item on the Top 
-// -----------------------------
-Item PCollection_HStack::Top() const 
-{
-    if (TheTop->IsEmpty()) Standard_NoSuchObject::Raise();
-    return TheTop->Value();
-} 
-
-
-// ------------------------------------
-// ShallowCopy redefinition
-// ------------------------------------
-Handle(Standard_Persistent) PCollection_HStack::ShallowCopy() const
-{
-  PCollection_HStack* TheCopy = new PCollection_HStack (*this);
-  TheCopy->TheTop = 
-    Handle(PCollection_StackNode)::DownCast(::ShallowCopy(TheTop));
-  return TheCopy;
-}
-
-// ------------------------------------
-// ShallowDump redefinition
-// ------------------------------------
-void PCollection_HStack::ShallowDump(Standard_OStream& S) const
-{
-  S << "begin class Stack "<< endl;
-  S << "Length of Stack : "<< TheDepth << endl;
-  TheTop->ShallowDump(S);
-  S << "end of class Stack." << endl;
-}
-
-
-
-// -----------------------------
-// Depth : numbers of items 
-// -----------------------------
-Standard_Integer PCollection_HStack::Depth() const {
-    return TheDepth;
-} 
-
-// -----------------------------
-// FTop : Top of the Stack  
-// -----------------------------
-Handle(PCollection_StackNode) PCollection_HStack::FTop() const {
-    return TheTop;
-} 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_IndexedDataMapNode.gxx b/src/PCollection/PCollection_IndexedDataMapNode.gxx
deleted file mode 100644 (file)
index 8d4d979..0000000
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//-Version: 
-
-//  Version    Date         Purpose
-//              14/12/92     Creation   
-
-//-Language     C++2.0
-
-//=======================================================================
-// Function : PCollection_IndexedDataMapNode
-// Purpose  : 
-//=======================================================================
-
-PCollection_IndexedDataMapNode::PCollection_IndexedDataMapNode
-  (
-   const Key& aKey,
-   const Standard_Integer Index,
-   const Item& anItem,
-   const Handle(PCollection_IndexedDataMapNode)& NextKey,
-   const Handle(PCollection_IndexedDataMapNode)& NextIndex) :
-
-  myKey(aKey), myIndex(Index), myItem(anItem), 
-  myNextKey(NextKey), myNextIndex(NextIndex)
-{
-}
-
-//=======================================================================
-// Function : Set
-// Purpose  : 
-//=======================================================================
-
-void PCollection_IndexedDataMapNode::Set
-  (
-   const Key& aKey,
-   const Standard_Integer Index,
-   const Item& anItem,
-   const Handle(PCollection_IndexedDataMapNode)& NextK,
-   const Handle(PCollection_IndexedDataMapNode)& NextI)
-
-{
-  myKey       = aKey;
-  myIndex     = Index;
-  myItem      = anItem;
-  myNextKey   = NextK;
-  myNextIndex = NextI;
-}
-
-//=======================================================================
-// Function : GetKey
-// Purpose  : 
-//=======================================================================
-
-Key PCollection_IndexedDataMapNode::GetKey() const
-{
-  return myKey;
-}
-
-
-//=======================================================================
-// Function : Index
-// Purpose  : 
-//=======================================================================
-
-Standard_Integer PCollection_IndexedDataMapNode::Index() const
-{
-  return myIndex;
-}
-
-
-//=======================================================================
-// Function : GetItem
-// Purpose  : 
-//=======================================================================
-
-Item PCollection_IndexedDataMapNode::GetItem() const
-{
-  return myItem;
-}
-
-//=======================================================================
-// Function : KeyAndItem
-// Purpose  : get two fields
-//=======================================================================
-
-void PCollection_IndexedDataMapNode::KeyAndItem(Key& theKey, Item& theItem) const
-{
-  theKey     = myKey;
-  theItem    = myItem;
-}
-
-//=======================================================================
-// Function : IndexAndItem
-// Purpose  : get two fields
-//=======================================================================
-
-void PCollection_IndexedDataMapNode::IndexAndItem(Standard_Integer& Index, 
-                                               Item& theItem) const
-{
-  Index    = myIndex;
-  theItem  = myItem;
-}
-
-
-//=======================================================================
-// Function : NextKey
-// Purpose  : 
-//=======================================================================
-
-Handle(PCollection_IndexedDataMapNode) 
-     PCollection_IndexedDataMapNode::NextKey() const
-{
-  return myNextKey;
-}
-
-//=======================================================================
-// Function : NextIndex
-// Purpose  : 
-//=======================================================================
-
-Handle(PCollection_IndexedDataMapNode) 
-     PCollection_IndexedDataMapNode::NextIndex() const
-{
-  return myNextIndex;
-}
-
-//=======================================================================
-// Function : SetItem
-// Purpose  : 
-//=======================================================================
-
-void PCollection_IndexedDataMapNode::SetItem(const Item& anItem)
-{
-  myItem = anItem;
-}
-
-//=======================================================================
-// Function : SetNextKey
-// Purpose  : 
-//=======================================================================
-
-void PCollection_IndexedDataMapNode::
-  SetNextKey(const Handle(PCollection_IndexedDataMapNode)& aNode)
-{
-  myNextKey = aNode;
-}
-
-//=======================================================================
-// Function : SetNextIndex
-// Purpose  : 
-//=======================================================================
-
-void PCollection_IndexedDataMapNode::
-  SetNextIndex(const Handle(PCollection_IndexedDataMapNode)& aNode)
-{
-  myNextIndex = aNode;
-}
-
diff --git a/src/PCollection/PCollection_LeavesIterator.gxx b/src/PCollection/PCollection_LeavesIterator.gxx
deleted file mode 100644 (file)
index a417aab..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_LeavesIterator::PCollection_LeavesIterator 
-     (const Handle(PCollection_HDirectedGraph)& G):MyVertexIterator(G->GetVertices()) 
-{
-  HasMore = False;
-  while ((MyVertexIterator.More()) && (!HasMore)) {
-    if (MyVertexIterator.Value()->IsLeaf()) 
-       HasMore = True;
-    else
-       MyVertexIterator.Next();
-  } 
-}
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_LeavesIterator::More () const 
-{
-  return HasMore;
-}
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_LeavesIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  HasMore = False;
-  MyVertexIterator.Next();
-  while (MyVertexIterator.More() && !HasMore) {
-    if (MyVertexIterator.Value()->IsLeaf()) 
-      HasMore = True;
-    else 
-      MyVertexIterator.Next();
-  }
-} 
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_LeavesIterator::Value () const 
-{
-  if (!HasMore) Standard_NoSuchObject::Raise(); 
-  return MyVertexIterator.Value();
-}
-
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_LeavesIterator::Clear () 
-{
-// Nullify sur les champs
-  HasMore = False;
-}
-
diff --git a/src/PCollection/PCollection_MapIterator.gxx b/src/PCollection/PCollection_MapIterator.gxx
deleted file mode 100644 (file)
index 9b2bbad..0000000
+++ /dev/null
@@ -1,102 +0,0 @@
-// Created on: 1992-10-09
-// Created by: Mireille MERCIEN
-// Copyright (c) 1992-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_OutOfRange.hxx>
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// ----------------------------------------------------------------------
-// ----------------------------------------------------------------------
-
-//----------------------------------------------------------------
-// Create
-//----------------------------------------------------------------
-PCollection_MapIterator::PCollection_MapIterator
-                       (const Handle(PCollection_HDataMap)& AMap) 
-{
-  if (AMap->IsEmpty()) {
-    Index = 0;
-    Node.Nullify();
-    Buckets.Nullify();
-    HasMore = False;
-  } 
-  else {
-//  stop at the first element of the first "no empty" bucket entry
-    HasMore = True;
-    Buckets = AMap->GetArray();
-    NbBuck = AMap->NbBuckets();
-    Boolean Found = False;
-    Index = 1 ;
-    while ( Index <= NbBuck && !Found ) {
-      Node = Buckets->Value(Index);
-      if (Node.IsNull())    
-        Index++;
-      else 
-        Found = True;
-    }           
-    if (!Found) HasMore = False;
-  }
-}
-
-//----------------------------------------------------------------
-// More
-//----------------------------------------------------------------
-Standard_Boolean PCollection_MapIterator::More() const
-{
-   return HasMore; 
-}
-
-
-//----------------------------------------------------------------
-// Value
-//----------------------------------------------------------------
-Item PCollection_MapIterator::Value() const
-{
-  if (Node.IsNull()) Standard_NoSuchObject::Raise();
-  return (Node->Value());
-}
-
-//----------------------------------------------------------------
-// GetKey
-//----------------------------------------------------------------
-Key PCollection_MapIterator::GetKey() const
-{
-  if (Node.IsNull()) Standard_NoSuchObject::Raise();
-  return (Node->GetKey());
-}
-
-//----------------------------------------------------------------
-// Next
-//----------------------------------------------------------------
-void PCollection_MapIterator::Next()
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  Node = Node->Next();
-  if (Node.IsNull()) {
-     Boolean Found = False;
-     Index++;
-     while ( Index <= NbBuck && !Found ) {
-       Node = Buckets->Value(Index);
-       if (Node.IsNull()) 
-         Index++;
-       else
-         Found = True;
-     }           
-     if (!Found) HasMore = False;
-   }
-}
-
-
diff --git a/src/PCollection/PCollection_MapNode.gxx b/src/PCollection/PCollection_MapNode.gxx
deleted file mode 100644 (file)
index cf78bd0..0000000
+++ /dev/null
@@ -1,109 +0,0 @@
-// Created on: 1993-01-11
-// Created by: Mireille MERCIEN
-// Copyright (c) 1993-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//----------------------------------------------------------------- 
-// Constructor 
-//----------------------------------------------------------------- 
-PCollection_MapNode::PCollection_MapNode(const Key& aKey,
-                         const Item& anItem,
-                         const Handle(PCollection_MapNode)& aNext)
-{
-   myKey  = aKey;
-   myItem = anItem;
-   myNext = aNext;
-}
-
-//----------------------------------------------------------------- 
-// GetKey
-//----------------------------------------------------------------- 
-Key PCollection_MapNode::GetKey() const 
-{
-   return myKey;
-} 
-
-//----------------------------------------------------------------- 
-// Value
-//----------------------------------------------------------------- 
-Item PCollection_MapNode::Value() const 
-{
-   return myItem;
-} 
-
-//----------------------------------------------------------------- 
-// Next
-//----------------------------------------------------------------- 
-Handle(PCollection_MapNode) PCollection_MapNode::Next() const 
-{
-   return myNext;
-} 
-
-
-//----------------------------------------------------------------- 
-// SetKey
-//----------------------------------------------------------------- 
-void PCollection_MapNode::SetKey(const Key& aKey)  
-{
-   myKey = aKey;
-} 
-
-
-//----------------------------------------------------------------- 
-// SetValue
-//----------------------------------------------------------------- 
-void PCollection_MapNode::SetValue(const Item& anItem) 
-{
-   myItem = anItem;
-} 
-
-//----------------------------------------------------------------- 
-// SetNext
-//----------------------------------------------------------------- 
-void PCollection_MapNode::SetNext
-                       (const Handle(PCollection_MapNode)& aNext)
-{
-   myNext = aNext;
-} 
-
-//----------------------------------------------------------------- 
-// ShallowCopy : ShallowCopy redefinition
-//----------------------------------------------------------------- 
-Handle(Standard_Persistent) PCollection_MapNode::ShallowCopy() const
-{
-   Handle(PCollection_MapNode) TheCopy;
-   TheCopy = new PCollection_MapNode(myKey,myItem,myNext);
-   return TheCopy;
-}
-
-//----------------------------------------------------------------- 
-// ShallowDump : ShallowDump redefinition
-//----------------------------------------------------------------- 
-void PCollection_MapNode::ShallowDump(Standard_OStream& S) const
-{
-  S << "begin class MapNode "<< endl;
-  Handle(PCollection_MapNode) anode;
-  anode = this;
-  ::ShallowDump(anode->GetKey(),S);
-  ::ShallowDump(anode->Value(),S);
-  if (!myNext.IsNull()) myNext->ShallowDump(S);
-  S << "end of class MapNode." << endl;
-}
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_QueueIterator.gxx b/src/PCollection/PCollection_QueueIterator.gxx
deleted file mode 100644 (file)
index 194a803..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// --------------------------------
-// constructor of QueueIterator
-// --------------------------------
-
-PCollection_QueueIterator::PCollection_QueueIterator
-          (const Handle(PCollection_HQueue)& S) 
-{
-     TheIterator = S->FFront();
-}
-
-// -----------------------------------
-// More : returns Standard_True if there 
-// are other items
-// -----------------------------------
-Standard_Boolean PCollection_QueueIterator::More() const
-{
-       return ( ! TheIterator->IsEmpty() );
-}
-
-// -----------------------------------------
-// Next : set the iterator to the next item
-// -----------------------------------------
-void PCollection_QueueIterator::Next()
-{
-    if (TheIterator->IsEmpty())  Standard_NoMoreObject::Raise();  
-    TheIterator = TheIterator->Tail();
-}
-
-// ---------------------------------------
-// Value : returns the current item value 
-// of the iterator
-// ---------------------------------------
-Item PCollection_QueueIterator::Value() const
-{
-    if (TheIterator->IsEmpty()) Standard_NoSuchObject::Raise();
-    return TheIterator->Value();
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_RootsIterator.gxx b/src/PCollection/PCollection_RootsIterator.gxx
deleted file mode 100644 (file)
index 5c74a2f..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_RootsIterator::PCollection_RootsIterator 
-     (const Handle(PCollection_HDirectedGraph)& G):MyVertexIterator(G->GetVertices()) 
-{
-  HasMore = False;
-  while ((MyVertexIterator.More()) && (!HasMore)) {
-    if (MyVertexIterator.Value()->IsRoot()) 
-       HasMore = True;
-    else
-       MyVertexIterator.Next();
-  } 
-}
-
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_RootsIterator::More () const 
-{
-  return HasMore;
-}
-
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_RootsIterator::Next () 
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  HasMore = False;
-  MyVertexIterator.Next();
-  while ((MyVertexIterator.More()) && (!HasMore)) {
-    if (MyVertexIterator.Value()->IsRoot()) 
-      HasMore = True;
-    else 
-      MyVertexIterator.Next();
-  } 
-} 
-
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_RootsIterator::Value () const 
-{
-  if (!HasMore) Standard_NoSuchObject::Raise();
-  return MyVertexIterator.Value();
-}
-
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_RootsIterator::Clear () 
-{
-// Nullify sur les champs
-  HasMore = False;
-}
-
diff --git a/src/PCollection/PCollection_SetIterator.gxx b/src/PCollection/PCollection_SetIterator.gxx
deleted file mode 100644 (file)
index 825d822..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// --------------------------------
-// constructor of SetIterator
-// --------------------------------
-PCollection_SetIterator::PCollection_SetIterator
-          (const Handle(PCollection_HSet)& S) 
-{
-     TheIterator = S->Last();
-}
-
-// -----------------------------------
-// More : returns Standard_True if there 
-// are other items
-// -----------------------------------
-Standard_Boolean PCollection_SetIterator::More() const
-{
-       return   ! ( TheIterator->IsEmpty() ) ;
-}
-
-// -----------------------------------------
-// Next : set the iterator to the next item
-// -----------------------------------------
-void PCollection_SetIterator::Next()
-{
-    if (TheIterator->IsEmpty())  Standard_NoMoreObject::Raise();  
-    TheIterator = TheIterator->Tail();
-}
-
-// ---------------------------------------
-// Value : returns the current item value 
-// of the iterator
-// ---------------------------------------
-Item PCollection_SetIterator::Value() const
-{
-    if (TheIterator->IsEmpty())  Standard_NoSuchObject::Raise();  
-    return TheIterator->Value();
-}
diff --git a/src/PCollection/PCollection_StackIterator.gxx b/src/PCollection/PCollection_StackIterator.gxx
deleted file mode 100644 (file)
index 1acd551..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-// --------------------------------
-// constructor of StackIterator
-// --------------------------------
-
-PCollection_StackIterator::PCollection_StackIterator
-          (const Handle(PCollection_HStack)& S) 
-{
-     TheIterator = S->FTop();
-}
-
-// -----------------------------------
-// More : returns Standard_True if there 
-// are other items
-// -----------------------------------
-Standard_Boolean PCollection_StackIterator::More() const
-{
-       return (! TheIterator->IsEmpty());
-}
-
-// -----------------------------------------
-// Next : Set the iterator to the next item
-// -----------------------------------------
-void PCollection_StackIterator::Next()
-{
-    if (TheIterator->IsEmpty())  Standard_NoMoreObject::Raise();  
-    TheIterator = TheIterator->Tail();
-}
-
-// ---------------------------------------
-// Value : returns the current item value 
-// of the iterator
-// ---------------------------------------
-Item PCollection_StackIterator::Value() const
-{
-    if (TheIterator->IsEmpty()) Standard_NoSuchObject::Raise();
-    return TheIterator->Value();
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/src/PCollection/PCollection_Vertex.gxx b/src/PCollection/PCollection_Vertex.gxx
deleted file mode 100644 (file)
index 17bf0d7..0000000
+++ /dev/null
@@ -1,193 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoSuchObject.hxx>
-#include <Standard_NoMoreObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_Vertex::
-     PCollection_Vertex (const Item& Value,
-                        const Handle(PCollection_HDirectedGraph)& InGraph) 
-{
-  MyItem       = Value;
-  MyGraph      = InGraph;
-  MyFrontEdges = new PCollection_SetOfEdge;
-  MyBackEdges  = new PCollection_SetOfEdge;
-}
-
-//---------------------------------------------------------------------------
-// GetItem
-//---------------------------------------------------------------------------
-Item PCollection_Vertex::GetItem () const 
-{
-  return MyItem;
-}
-
-//---------------------------------------------------------------------------
-// SetItem
-//---------------------------------------------------------------------------
-void PCollection_Vertex::SetItem (const Item& Value) 
-{
-  MyItem = Value;
-}
-
-//---------------------------------------------------------------------------
-// GetGraph
-//---------------------------------------------------------------------------
-Handle(PCollection_HDirectedGraph) PCollection_Vertex::GetGraph () const 
-{
-  return MyGraph;
-}
-
-//---------------------------------------------------------------------------
-// AddFrontEdge
-//---------------------------------------------------------------------------
-Boolean PCollection_Vertex::AddFrontEdge (const Handle(PCollection_Edge)& E) 
-{
-  if (MyFrontEdges->Contains(E)) {
-    return False;
-  }
-  else {
-    MyFrontEdges->Add(E);
-    return True;
-  }
-}
-
-//---------------------------------------------------------------------------
-// RemoveFrontEdge
-//---------------------------------------------------------------------------
-void PCollection_Vertex::RemoveFrontEdge (const Handle(PCollection_Edge)& E) 
-{
-  if (MyFrontEdges->Contains(E)) {
-    MyFrontEdges->Remove(E);
-  }
-  else {
-    Standard_NoSuchObject::Raise();
-  }
-}
-       
-//---------------------------------------------------------------------------
-// NbFrontEdges
-//---------------------------------------------------------------------------
-Integer PCollection_Vertex::NbFrontEdges () const 
-{
-  return MyFrontEdges->Extent();
-}
-
-//---------------------------------------------------------------------------
-// GetFrontEdges
-//---------------------------------------------------------------------------
-Handle(PCollection_SetOfEdge) PCollection_Vertex::GetFrontEdges () const 
-{
-  return MyFrontEdges;
-}
-
-//---------------------------------------------------------------------------
-// AddBackEdge
-//---------------------------------------------------------------------------
-Boolean PCollection_Vertex::AddBackEdge (const Handle(PCollection_Edge)& E) 
-{
-  if (MyBackEdges->Contains(E)) {
-    return False;
-  }
-  else {
-    MyBackEdges->Add(E);
-    return True;
-  }
-}
-
-//---------------------------------------------------------------------------
-// RemoveBackEdge
-//---------------------------------------------------------------------------
-void PCollection_Vertex::RemoveBackEdge (const Handle(PCollection_Edge)& E) 
-{
-  if (MyBackEdges->Contains(E)) {
-    MyBackEdges->Remove(E);
-  }
-  else {
-     Standard_NoSuchObject::Raise();
-  }
-}
-
-//---------------------------------------------------------------------------
-// NbBackEdges
-//---------------------------------------------------------------------------
-Integer PCollection_Vertex::NbBackEdges () const 
-{
-  return MyBackEdges->Extent();
-}
-
-//---------------------------------------------------------------------------
-// GetBackEdges
-//---------------------------------------------------------------------------
-Handle(PCollection_SetOfEdge) PCollection_Vertex::GetBackEdges () const 
-{
-  return MyBackEdges;
-}
-
-//---------------------------------------------------------------------------
-// IsRoot
-//---------------------------------------------------------------------------
-Boolean PCollection_Vertex::IsRoot () const 
-{
-  return (NbBackEdges() == 0);
-}   
-
-//---------------------------------------------------------------------------
-// IsLeaf
-//---------------------------------------------------------------------------
-Boolean PCollection_Vertex::IsLeaf () const 
-{
-  return (NbFrontEdges() == 0);
-}
-
-//---------------------------------------------------------------------------
-// IsDestination
-//---------------------------------------------------------------------------
-Boolean PCollection_Vertex::
-    IsDestination (const Handle(PCollection_Vertex)& V) const 
-{
-  PCollection_SetIteratorOfSetOfEdge It(MyBackEdges);
-  while (It.More()) {
-    Handle(PCollection_Edge) E = It.Value();
-    if (E->Source() == V) return True;
-    It.Next();
-  }
-  return False;
-}
-
-//---------------------------------------------------------------------------
-// IsSource
-//---------------------------------------------------------------------------
-Boolean PCollection_Vertex::
-         IsSource (const Handle(PCollection_Vertex)& V) const 
-{
-  PCollection_SetIteratorOfSetOfEdge It(MyFrontEdges);
-  while (It.More()) {
-    Handle(PCollection_Edge) E = It.Value();
-    if ( E->Destination() == V) return True;
-    It.Next();
-  }
-  return False;
-}
-
diff --git a/src/PCollection/PCollection_VerticesIterator.gxx b/src/PCollection/PCollection_VerticesIterator.gxx
deleted file mode 100644 (file)
index 65e48e5..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-// Created on: 1991-05-29
-// Created by: Denis PASCAL
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             <dp>
-// Revised by:  Mireille MERCIEN
-//              Sep,7 1992
-
-#include <Standard_NoMoreObject.hxx>
-#include <Standard_NoSuchObject.hxx>
-
-
-//---------------------------------------------------------------------------
-// Constructor
-//---------------------------------------------------------------------------
-PCollection_VerticesIterator::PCollection_VerticesIterator 
-     (const Handle(PCollection_HDirectedGraph)& G):MyVertexIterator(G->GetVertices()) 
-{
-  HasMore = MyVertexIterator.More();
-}
-
-
-//---------------------------------------------------------------------------
-// More
-//---------------------------------------------------------------------------
-Boolean PCollection_VerticesIterator::More () const 
-{
-  return HasMore;
-}
-
-//---------------------------------------------------------------------------
-// Next
-//---------------------------------------------------------------------------
-void PCollection_VerticesIterator::Next ()  
-{
-  if (!HasMore) Standard_NoMoreObject::Raise();
-  MyVertexIterator.Next();
-  HasMore = MyVertexIterator.More();
-}
-
-
-//---------------------------------------------------------------------------
-// Value
-//---------------------------------------------------------------------------
-Handle(PCollection_Vertex) PCollection_VerticesIterator::Value () const 
-{
-  if (!HasMore) Standard_NoSuchObject::Raise();
-  return MyVertexIterator.Value();
-}
-
-
-//---------------------------------------------------------------------------
-// Clear
-//---------------------------------------------------------------------------
-void PCollection_VerticesIterator::Clear () 
-{
-  HasMore = False;
-}
-
-
-
-
-
-
-
-
-
index bb5b92d..f9cd00c 100755 (executable)
@@ -1,4 +1,3 @@
 TCollection_Compare.gxx
-TCollection_AVLNode.hxx
 TCollection_CMPLRS.edl
 TCollection_WOKSteps.edl
index d5c3e3a..c3069ff 100644 (file)
@@ -130,10 +130,6 @@ is
        
     class CompareOfReal;
     
-    class AVLBaseNode;
-    pointer AVLBaseNodePtr to AVLBaseNode from TCollection;
-    generic class AVLSearchTree,AVLNode,AVLList,AVLIterator;
-    
 
     NextPrimeForMap(I : Integer) returns Integer;
        ---Purpose: Returns a  prime number greater than  <I> suitable
diff --git a/src/TCollection/TCollection_AVLBaseNode.cdl b/src/TCollection/TCollection_AVLBaseNode.cdl
deleted file mode 100644 (file)
index 87fba03..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
--- Created on: 1998-01-21
--- Created by: Kernel
--- Copyright (c) 1998-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
-class AVLBaseNode from TCollection
-    inherits TShared from MMgt
-    uses AVLBaseNodePtr from TCollection,
-        Side from TCollection
-    is
-       Create(L,R : AVLBaseNodePtr from TCollection) returns mutable AVLBaseNode from TCollection;
-       ---C++: inline
-
-       SetChild(me : mutable; theNode : AVLBaseNodePtr from TCollection; theSide : Side from TCollection);
-       ---C++: inline
-
-       Height(myclass; ANode : AVLBaseNodePtr from TCollection) returns Integer;
-       RecursiveExtent(myclass;  ANode : AVLBaseNodePtr from TCollection) returns Integer;
-       RecursiveTotalExtent(myclass;  ANode : AVLBaseNodePtr from TCollection) returns Integer;
-
-       Right(me) returns AVLBaseNodePtr from TCollection;
-       ---C++: inline
-       ---C++: return &
-
-       Left(me) returns AVLBaseNodePtr from TCollection;
-       ---C++: inline
-       ---C++: return &
-
-       Count(me) returns Integer;
-       ---C++: inline
-       ---C++: return &
-
-    fields
-      myLeft : AVLBaseNodePtr from TCollection is protected;
-      myRight : AVLBaseNodePtr from TCollection is protected;
-      myCount : Integer from Standard is protected;      
-    end;
-    
diff --git a/src/TCollection/TCollection_AVLBaseNode.cxx b/src/TCollection/TCollection_AVLBaseNode.cxx
deleted file mode 100644 (file)
index 8bd8387..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <TCollection_AVLBaseNode.ixx>
-
-Standard_Integer TCollection_AVLBaseNode::Height(const TCollection_AVLBaseNodePtr& ANode)
-     // Length of the longest child
-{
-  if (!ANode) return 0;
-  else return (1 + Max(Height(ANode->myLeft),Height(ANode->myRight)));
-}
-
-
-Standard_Integer TCollection_AVLBaseNode::RecursiveExtent(const TCollection_AVLBaseNodePtr &  ANode) 
-     // Number of different items in the current tree
-{
-  if ( ! ANode ) return 0;
-  else return  (1 +  RecursiveExtent(ANode->myLeft)   
-               +  RecursiveExtent(ANode->myRight)  );
-}
-
-Standard_Integer TCollection_AVLBaseNode::RecursiveTotalExtent(const TCollection_AVLBaseNodePtr&  ANode) 
-{
-  // Number of different items in the current tree according to
-  // the multiplicity
-  if ( ! ANode  ) return 0;
-  else return ( RecursiveTotalExtent(ANode->myLeft) + RecursiveTotalExtent(ANode->myRight) + ANode->myCount);
-}
-
-
diff --git a/src/TCollection/TCollection_AVLBaseNode.lxx b/src/TCollection/TCollection_AVLBaseNode.lxx
deleted file mode 100644 (file)
index 52db1ae..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-inline TCollection_AVLBaseNode::TCollection_AVLBaseNode(const TCollection_AVLBaseNodePtr& L, const TCollection_AVLBaseNodePtr& R) 
-: myLeft(L),myRight(R),myCount(1)
-{
-}
-
-inline void TCollection_AVLBaseNode::SetChild(const TCollection_AVLBaseNodePtr& theNode, const TCollection_Side theSide) 
-     // According to the side changes a child by another
-{
-  if (theSide == TCollection_Left) {myLeft = theNode;}
-  else {myRight = theNode;}
-}
-
-inline TCollection_AVLBaseNodePtr& TCollection_AVLBaseNode::Right() const
-{
-  return (TCollection_AVLBaseNodePtr&)myRight;
-}
-
-inline TCollection_AVLBaseNodePtr& TCollection_AVLBaseNode::Left() const
-{
-  return (TCollection_AVLBaseNodePtr&)myLeft;
-}
-
-inline Standard_Integer& TCollection_AVLBaseNode::Count() const
-{
-  return (Standard_Integer&)myCount;
-}
-
diff --git a/src/TCollection/TCollection_AVLIterator.gxx b/src/TCollection/TCollection_AVLIterator.gxx
deleted file mode 100644 (file)
index 8433944..0000000
+++ /dev/null
@@ -1,105 +0,0 @@
-// Created on: 1991-05-23
-// Created by: Jean-Pierre TIRAULT
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             Transient implementation
-
-#include <Standard_Address.hxx>           
-
-// Global variable
-static Standard_Address LastNode;                
-// Global variable
-
-
-void TCollection_AVLIterator::InOrderTraversal (const Standard_Address A)  {
-  if (A) {
-    InOrderTraversal (((TCollection_AVLNode*)A)->Left());
-    TCollection_AVLList* S     = new TCollection_AVLList;
-    S->Value()       = ((TCollection_AVLNode*)A)->Value();
-    if (!FirstNode) { 
-      FirstNode = (Standard_Address*)S; 
-      LastNode = FirstNode; 
-    }
-    else { 
-      ((TCollection_AVLList*)LastNode)->Next() = S;
-      LastNode = (Standard_Address)S; 
-    }
-    InOrderTraversal (((TCollection_AVLNode*)A)->Right());
-  }
-}   
-
-
-
-
-//-----------------------------------------------------------------------------
-TCollection_AVLIterator::
-              TCollection_AVLIterator ( const TCollection_AVLSearchTree& aTree) 
-{
-  LastNode  = FirstNode = NULL;
-  Standard_Address Root = (Standard_Address) aTree.GetRoot();     // Current node = root of tree
-  if (!Root) {
-    HasMore = Standard_False;
-  }
-  else {
-    HasMore = Standard_True;
-    InOrderTraversal(Root);
-  }
-}
-//-----------------------------------------------------------------------------
-TCollection_AVLIterator::TCollection_AVLIterator ( const TCollection_AVLSearchTree&   aTree, const Item&   anItem) 
-{
-  LastNode  = FirstNode = NULL;
-  Standard_Address  Root;
-  
-  if (aTree.Find(anItem,Root)) {
-    HasMore = Standard_True;
-    InOrderTraversal(Root);
-  }
-  else {   
-    HasMore = Standard_False;
-  }
-}
-
-//-----------------------------------------------------------------------------
-void TCollection_AVLIterator::Clear () 
-{
-  LastNode     = NULL ;
-  TCollection_AVLList* S   = (TCollection_AVLList*)FirstNode;
-  TCollection_AVLList* P;
-  while (S) {     // Memory management
-    P = S;
-    S = (TCollection_AVLList*)S->Next();
-    delete P;
-  }
-  FirstNode    = NULL ;
-  HasMore      = Standard_False;
-}
-
-//-----------------------------------------------------------------------------
-const Item& TCollection_AVLIterator::Value () const 
-{
-  Standard_NoSuchObject_Raise_if(!HasMore,"TCollection_AVLIterator - No more object");
-  return ((TCollection_AVLList*)FirstNode)->Value();
-}
-
-//-----------------------------------------------------------------------------
-void TCollection_AVLIterator::Next () 
-{
-  Standard_NoSuchObject_Raise_if(!HasMore,"TCollection_AVLIterator - No more object");
-  TCollection_AVLList* S = (TCollection_AVLList*)FirstNode;
-  FirstNode  = ((TCollection_AVLList*)FirstNode)->Next();
-  HasMore    = (FirstNode != NULL);
-  delete S;
-}
diff --git a/src/TCollection/TCollection_AVLIterator.lxx b/src/TCollection/TCollection_AVLIterator.lxx
deleted file mode 100644 (file)
index 3a4152e..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Standard_NoSuchObject.hxx>    
-
-inline Standard_Boolean TCollection_AVLIterator::More () const {
-  return HasMore;
-}
diff --git a/src/TCollection/TCollection_AVLList.gxx b/src/TCollection/TCollection_AVLList.gxx
deleted file mode 100644 (file)
index 61de802..0000000
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
diff --git a/src/TCollection/TCollection_AVLList.lxx b/src/TCollection/TCollection_AVLList.lxx
deleted file mode 100644 (file)
index f8ca969..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-inline TCollection_AVLList::TCollection_AVLList() 
-: myNext(0L)
-{
-}
-
-inline Item & TCollection_AVLList::Value() const
-{
-  return (Item&)myValue;
-}
-
-inline Standard_Address & TCollection_AVLList::Next() const
-{
-  return (Standard_Address&)myNext;
-}
-
diff --git a/src/TCollection/TCollection_AVLNode.gxx b/src/TCollection/TCollection_AVLNode.gxx
deleted file mode 100644 (file)
index 0edad26..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-void TCollection_AVLNode::RecursiveCopy (const TCollection_AVLBaseNodePtr& ANode,const TCollection_AVLBaseNodePtr& copy)
-{
-  if (ANode) {
-    ((TCollection_AVLNode*)copy)->Value() = ((TCollection_AVLNode*)ANode)->Value();
-    if (ANode->Left()) {
-      copy->Left()  = new TCollection_AVLNode(((TCollection_AVLNode*)copy)->Value(),(TCollection_AVLBaseNodePtr)0L,(TCollection_AVLBaseNodePtr)0L);
-      TCollection_AVLNode::RecursiveCopy(ANode->Left(),copy->Left());
-    }
-    if (ANode->Right()) {
-      copy->Right()  = new TCollection_AVLNode(((TCollection_AVLNode*)copy)->Value(),(TCollection_AVLBaseNodePtr)0L,(TCollection_AVLBaseNodePtr)0L);
-      TCollection_AVLNode::RecursiveCopy(ANode->Right(),copy->Right());
-    }
-  }
-}
-
-// ----------------------------------------------------------------------
-TCollection_AVLBaseNodePtr TCollection_AVLNode::Copy(const TCollection_AVLBaseNodePtr& ANode)
-{
-  TCollection_AVLNode *copy = NULL;
-  if (ANode) {
-    copy = new TCollection_AVLNode(((TCollection_AVLNode*)ANode)->Value(),(TCollection_AVLBaseNodePtr)0L,(TCollection_AVLBaseNodePtr)0L);
-    TCollection_AVLNode::RecursiveCopy (ANode,copy);
-  }
-  return copy;
-}
-
diff --git a/src/TCollection/TCollection_AVLNode.hxx b/src/TCollection/TCollection_AVLNode.hxx
deleted file mode 100644 (file)
index e3397c9..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// ----------------------------------------------------------------------
-// Internal C++ class that provides tool to manipulate a tree node.
-// ----------------------------------------------------------------------
-
-//void ShallowDump(const Item&, Standard_OStream& );
-
-class AVLNode{
-  public :
-
-  Item      Value;
-  AVLNode*  Left ;
-  AVLNode*  Right;
-  Standard_Integer   Count;
-
-  friend class AVLList;       // For iterator 
-};
diff --git a/src/TCollection/TCollection_AVLNode.lxx b/src/TCollection/TCollection_AVLNode.lxx
deleted file mode 100644 (file)
index 73de79d..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-inline Item& TCollection_AVLNode::Value() const
-{
-  return (Item&)myValue;
-}
-
-inline TCollection_AVLNode::TCollection_AVLNode(const Item& I,const TCollection_AVLBaseNodePtr& r,const TCollection_AVLBaseNodePtr& l)
-: TCollection_AVLBaseNode(r,l)
-{
-  myValue = I;
-}
diff --git a/src/TCollection/TCollection_AVLSearchTree.cdl b/src/TCollection/TCollection_AVLSearchTree.cdl
deleted file mode 100644 (file)
index 3380ab9..0000000
+++ /dev/null
@@ -1,412 +0,0 @@
--- Created on: 1991-05-21
--- Created by: Annick PANCHER
--- Copyright (c) 1991-1999 Matra Datavision
--- Copyright (c) 1999-2014 OPEN CASCADE SAS
---
--- This file is part of Open CASCADE Technology software library.
---
--- This library is free software; you can redistribute it and/or modify it under
--- the terms of the GNU Lesser General Public License version 2.1 as published
--- by the Free Software Foundation, with special exception defined in the file
--- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
--- distribution for complete text of the license and disclaimer of any warranty.
---
--- Alternatively, this file may be used under the terms of Open CASCADE
--- commercial license or contractual agreement.
-
--- Revised:    Mireille MERCIEN
---             J.P. TIRAULT
---             Feb,19 1993 
---             Adaptation of this persistent structure to a transient 
---             structure.
---             J.P. TIRAULT -- R.BARRETO
---             Aug,11 1993
---             Update of method AVLSearchTree::Find. This method returns
---             a boolean status according to the method finds the Item or not.
---             Update of method AVLIterator::Value. This method returns an 
---             Item.
-
-
-generic class AVLSearchTree from TCollection (
-               Item as any;
-               Comparator as Compare(Item))
-
-
-       ---Purpose: Defines a binary search tree, e.g.  an ordered and
-       -- balanced binary tree.  An AVLSearchTree is created
-       -- with  a   kind of   Item and  a   Comparator. It's
-       -- composed with Nodes. One item is contained only by
-       -- one  Node, and a 'count' stores  the number of its
-       -- occurences.           
-               -- The  only  public  operations on an AVLSearchTree,
-               -- except reading ( the number of its Nodes, its Root
-               -- or the  Node containing  an item) are to insert or
-               -- remove an item, plus, of course, to find an item.           
-        -- Then,  it's possible to  ask to  a Node its value,
-        -- the number of  occurences  of this value, and  its
-        -- right and left children. Other methods of Node are
-        -- private  and  called   by the private   methods of
-        -- AVLSearchTree which  manage the  Find method,  and
-        -- Insert and    Remove  operations,  always ensuring
-        -- order and balance.           
-       -- 1. ORDER  :  
-       -- If the tree  contains  three elements A,B,C, which
-       -- are ordered,  regarding  to a comparator  Comp, as
-       -- following:
-       -- A  <  B < C
-       -- Then TheRoot of the tree will contain B, with A as
-       -- LeftChild and C as RightChild. 
-       -- Each element on  the left of a  node A are 'lower'
-       -- than A  in respect  with the used  comparator, and
-       -- each element on its right are greater.           
-       -- 2. BALANCE : The height of two children of  a Node
-       -- will never   have a difference  of  more  than one
-       -- level. An AVLSearch Tree is ALWAYS balanced.
-       --  Keywords: binary tree, ordered, balanced
-       --  Warning: To use  an AVLSearchTree,  since it's  ordered and
-       -- balanced each time an item is inserted or removed,
-       -- may be a bad   choice if there  are more  changing
-       -- operations  than    searching       requests,  for
-       -- performances criterias.   It can  be judicious  to
-       -- use it when  there  are   many  items to   consult
-       -- frequently.  
-               --  References: Classix,    Reusable  C++  Components(  Empathy
-               -- incorporated, 1990).         
-               -- Algorithms      are          attributed      to
-               -- G.M.Adel'son-Vel'skii and E.M.Landis, 1962.
-
-uses   Side
-raises NoSuchObject from Standard,
-       NoMoreObject from Standard
-
-
-
-    class AVLList from TCollection
-    inherits TShared from MMgt
-    is
-       Create returns mutable AVLList from TCollection;
-       ---C++: inline
-       
-       Value(me) returns Item;
-       ---C++: inline
-       ---C++: return &
-
-       Next(me) returns Address;
-       ---C++: inline
-       ---C++: return &
-
-    fields
-      myValue : Item;
-      myNext  : Address from Standard;
-    end;
-
-    class AVLNode from TCollection
-    inherits AVLBaseNode from TCollection
-    uses  AVLBaseNodePtr from TCollection
-    is
-       Create(I : Item; r,l : AVLBaseNodePtr from TCollection) returns   AVLNode from TCollection;
-       ---C++: inline
-       Copy(myclass;  ANode : AVLBaseNodePtr from TCollection) returns AVLBaseNodePtr from TCollection;        
-       RecursiveCopy(myclass;   ANode,aCopy : AVLBaseNodePtr from TCollection);
-
-       Value(me) returns Item;
-       ---C++: inline
-       ---C++: return &
-
-    fields
-       myValue : Item;
-       
-      friends class AVLList from TCollection
-    end;
-    
-    class AVLIterator
-
-    raises NoMoreObject from Standard, NoSuchObject from Standard
-    is
-       ---Purpose: This class provides to iterate on an AVLSearchTree.
-       -- The type of traversal is the in-order traversal.
-       -- Example : If the AVLTree is the following:
-       --                            5
-       --                      2           7
-       --                    1   3      6     8
-       --                    
-       --            The result is:
-       --             1 2 3 5 6 7 8
-       --             
-       -- During the exploration of the tree no updating of the
-       -- tree must be done.
-       -- 
-
-        Create( aTree: AVLSearchTree)
-           ---Purpose: Creates an iterator on <aTree> from the root of the
-           -- AVLSearchtree.
-           returns AVLIterator;
-
-        Create( aTree: AVLSearchTree; theItem : Item)
-           ---Purpose: Creates an iterator on <aTree> from the node that 
-           -- contains the Item (It is not necessary the root of the tree).
-           returns AVLIterator;
-
-       More( me ) 
-            ---Level: Public
-           ---Purpose: Returns True if there is still an element to be read
-           ---C++: inline
-           returns Boolean from Standard is static;
-           
-       Next( me: in out) raises NoMoreObject from Standard;
-            ---Level: Public
-           ---Purpose: Goes to next element of <me>
-    
-       Value( me)
-           returns Item
-           raises NoSuchObject from Standard;
-            ---Level: Public
-           ---C++: return const &
-          
-        Clear (me: in out) is static ;
-            ---Level: Public
-           ---Purpose: Empties my structure, so that if next call on <me>,
-           -- it will raise an exception NoMoreObject
-
-        InOrderTraversal (me : in out ; A : Address) is static private;
-            ---Level: Internal
-           ---Purpose: Internal method.
-
-fields
-    FirstNode  : Address;
-    HasMore    : Boolean;
-end;
-
-
------------------------------- AVLSearchTree --------------------------------
-is
-
-    Create( aComparator: Comparator)
-       ---Purpose: creates an empty tree (root points to NULL)
-       returns AVLSearchTree;
-    
-    
-    IsEmpty( me)
-        ---Level: Public
-       ---Purpose: Returns true if the tree is empty.
-       ---Category: Reading
-       ---C++: inline
-       returns Boolean from Standard
-        is static;
-       
-
-    Extent( me)
-        ---Level: Public
-       ---Purpose: Returns  number of  different   items contained by <me>
-       ---Category: Reading
-       returns Integer from Standard
-        is static;
-
-    TotalExtent( me)
-        ---Level: Public
-       ---Purpose: Returns total number  of  items (considers account
-       -- of each Node)
-       ---Category: Reading
-       returns Integer from Standard
-        is static;    
-       
-    Find( me; theItem: Item)
-        ---Level: Public
-       ---Purpose: Returns the Node containing <theItem>
-       ---Category: Reading
-       returns Boolean
-        is static;    
-
-    Find( me; theItem: Item; theOrig: in out Item)
-        ---Level: Public
-       ---Purpose: Returns the Node containing <theItem>
-       ---Category: Reading
-       returns Boolean
-        is static;    
-               
-    
-    GetRoot( me)
-       returns Address
-        is static;    
-        ---Level: Public
-       ---Purpose: Returns the Root of the tree <me>.
-       ---Category: Reading
-       ---C++: inline
-
-    GetComparator( me)
-       returns Comparator
-        is static;    
-        ---Level: Public
-       ---Purpose: Returns the Comparator of the tree <me>.
-       ---Category: Reading
-       ---C++: inline
-
-    Insert( me : in out ; theItem: Item)
-        is static;    
-        ---Level: Public
-       ---Purpose: Inserts <theItem>  at  the  right place;  if  it's
-       -- already in <me>, only changes its <count>.
-       -- Before 
-       --   me = ( i5( i3( i1)) -i7) and theItem = i2
-       -- After
-       --   me = ( i5( i2( i1 -i3)) -i7))
-       -- ( i means LeftChild, -i means RightChild)
-       ---Category: Writing
-
-    InsertOnce(me : in out ; theItem: Item)
-        ---Level: Public
-       ---Purpose: Inserts <theItem> at the right place,  but only if
-       -- it isn't already in <me>; Returns False if already there.
-       -- Before 
-       --   me = ( i5( i3( i1)) -i7) and theItem = i3
-       -- After
-       --   me = ( i5( i3( i1)) -i7) and return False
-       ---Category: Writing
-       returns Boolean from Standard
-        is static;    
-
-    Remove( me : in out; theItem : Item)
-        ---Level: Public
-       ---Purpose: Removes  from <me> the  Node containing <theItem>,
-       --          if its count=1,  or reduces its  count if count>1;
-       --          in    this   aim,  calls   the   recursive  method
-       --          RecursiveRemove, with <forAll>=False;
-       --          Before 
-       --            me = ( i5( i3( i1)) -i7) and theItem = i7
-       --          After
-       --            me = ( i3( i1 -i5))        if count(i7)=1
-       --          Or
-       --            me = ( i5( i3( i1)) -i7)   if count(i7)>1
-       ---Category: Writing
-       raises NoSuchObject from Standard
-        is static;    
-    
-    RemoveAll( me : in out; theItem: Item)
-        ---Level: Public
-       ---Purpose: removes  from <me>  the Node containing <theItem>;
-       --          in   this  aim,  calls   the   recursive    method
-       --          RecursiveRemove, with <forAll>=True;
-       --          Before 
-       --            me = ( i5( i3( i1)) -i7) and theItem = i7
-       --          After
-       --            me = ( i3( i1 -i5))        
-       ---Category: Writing
-       raises NoSuchObject from Standard
-        is static;    
-
-    Merge (me; another:AVLSearchTree)
-        ---Level: Public
-       ---Purpose: creates a third one from <me> and <another>
-       ---Category: Writing
-       returns AVLSearchTree
-        is static;    
-       
-
-    
-    SetRoot(me : in out ; theNode: Address)
-        ---Level: Internal
-       is static private;
-       ---C++: inline
-
-    RotateLeft( me ; theNode : in out Address)
-        ---Level: Internal
-       ---Purpose: Right child A of <theNode> becomes the parent, and
-       -- <theNode> becomes its left  child; left child of A
-       -- becomes  the  right  child of  <theNode>.     This
-       -- rotation will  permit to  balance   <me>  after  a
-       -- pertubating action ( insert or remove) on it.
-       is static private;
-
-    RotateRight( me ; theNode : in out Address)
-        ---Level: Internal
-       ---Purpose: left child A of <theNode> becomes  the parent, and
-       -- <theNode> becomes its right  child; right child of
-       -- A  becomes  the left  child    of <theNode>.  This
-       -- rotation  will permit to   balance  <me>  after  a
-       -- pertubating action ( insert or remove) on it.
-       is static private;
-
-    LeftBalance( me; theNode : in out Address)
-        ---Level: Internal
-       ---Purpose: called after inserting or removing an item, if the
-       -- left branch of <theNode> is too long
-       is static private;
-
-    RightBalance( me ; theNode : in out Address)
-        ---Level: Internal
-       ---Purpose: Called after inserting or removing an item, if the
-       -- right branch of <theNode> is too long.
-       is static private;
-
-    InsertBalance( me ; theNode  : in out Address; 
-                       theFather: Address;
-                       theSide  : Side)
-        ---Level: Internal
-       ---Purpose: Balances <me> after inserting an item.
-       returns Boolean from Standard
-       is static private;
-
-    RemoveBalance( me ; theNode  : in out Address; 
-                       theFather: Address;
-                       theSide  : Side)
-        ---Level: Internal
-       ---Purpose: Balances <me> after removing an item.
-               returns Boolean from Standard
-       is static private;
-
-    RecursiveInsert( me ; theNode  : in out Address;
-                        theFather: Address;
-                        theSide  : Side; 
-                         theItem  : Item;
-                        forOnce  : in out Boolean from Standard)
-        ---Level: Internal
-       ---Purpose: Recursive method to  insert a new  Node OR to find
-       -- the existing one containing <theItem> and increase
-       -- its count.
-               -- Returns True  when a new Node has  been created to
-               -- know  it needs to  be  balanced, and then  returns
-               -- False again.
-       returns Boolean from Standard
-       is static private;
-
-    Find ( me ; theItem : Item ; theNode : in out Address) 
-    returns Boolean is static private;
-        ---Level: Internal
-        ---Purpose: Returns the Node associated to the Item.
-
-    RecursiveRemove( me ; theNode  : in out Address;
-                        theFather: Address;
-                        theSide  : Side; 
-                        theItem  : Item; 
-                        forAll   : Boolean from Standard)
-        ---Level: Internal
-       ---Purpose: Recursive   method to   find  the Node  containing
-       -- <theItem>.  In case it's <theNode>,  removes it if
-       -- <forAll> is True, or reduces its count if <forAll>
-       -- is False.
-       -- Returns True when theItem has been found
-       returns Boolean from Standard
-        is static private;
-
-       
-        ShallowCopy(me) returns AVLSearchTree;
-        ---Level: Advanced
-       ---C++: function call
-
-
-
-
-fields
-
-    TheRoot       : Address from Standard;
-    TheComparator : Comparator;
-
-
-friends
-    class AVLIterator from TCollection
-
-end;
-
-
-
diff --git a/src/TCollection/TCollection_AVLSearchTree.gxx b/src/TCollection/TCollection_AVLSearchTree.gxx
deleted file mode 100644 (file)
index ec69474..0000000
+++ /dev/null
@@ -1,579 +0,0 @@
-// Created on: 1991-05-23
-// Created by: Jean-Pierre TIRAULT
-// Copyright (c) 1991-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//             Transient implementation
-
-#define TCollection_AVLSearchTreeTrace 0
-// K_TRACE_A_METHOD used also in Engine.cxx, Engine_Signature.cxx,
-// Engine_Argument.cxx, Engine_MyClassCompareOfSignature.cxx and
-// TCollection_AVLSearchTree.gxx (! pour Kernel)
-#define K_TRACE_A_METHOD 0
-#if K_TRACE_A_METHOD
-extern K_Trace_a_Method ;
-#endif
-
-#include <Standard_NoSuchObject.hxx>      
-#include <Standard_Address.hxx>           
-#include <TCollection_Side.hxx>           
-#if TCollection_AVLSearchTreeTrace
-#include <Engine_Signature.hxx>
-#endif
-
-
-//-----------------------------------------------------------------------------
-// Create : creates an empty AVLSearchTCollection_AVLSearchTree
-//-----------------------------------------------------------------------------
-TCollection_AVLSearchTree::
-    TCollection_AVLSearchTree(const Comparator& AComparator) : TheRoot(NULL)
-{
-  TheComparator = AComparator;
-}
-
-
-//----------------------------------------------------------------------------
-Standard_Integer TCollection_AVLSearchTree::Extent () const
-{
-  return TCollection_AVLNode::RecursiveExtent((TCollection_AVLNode*) TheRoot);
-}
-
-
-//----------------------------------------------------------------------------
-Standard_Integer TCollection_AVLSearchTree::TotalExtent () const
-{
-  return TCollection_AVLNode::RecursiveTotalExtent((TCollection_AVLNode*)TheRoot);
-}
-
-//----------------------------------------------------------------------------
-// Find the Node where an item is located
-//----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::Find(const Item& TheItem) const
-{
-  TCollection_AVLNode* aNode = (TCollection_AVLNode*) TheRoot;
-#if TCollection_AVLSearchTreeTrace
-  cout << " ++++++++++++++++++ SEARCH1 +++++++++++++++++++++++++++++" << endl ;
-  cout << "BEGINNING OF SEARCH OF " << TheItem->PForMapOfMethods()->Name()
-       << " in " << hex << TheRoot << dec << endl ;
-#endif
-  while (aNode) {
-    if ( TheComparator.IsLower(TheItem, aNode->Value()) ) {
-      aNode = (TCollection_AVLNode*)aNode->Left();
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsLower : Left : " << hex
-             << aNode << dec << endl ;
-#endif
-    }
-    else if ( TheComparator.IsGreater(TheItem, aNode->Value()) ) {
-      aNode = (TCollection_AVLNode*)aNode->Right();
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsGreater : Right : " << hex
-             << aNode << dec << endl ;
-#endif
-    }
-    else {
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsEqual : " << hex << aNode
-             << dec << endl ;
-#endif
-      break;
-    }
-  }
-  if ( aNode ) {
-#if TCollection_AVLSearchTreeTrace
-    cout << "FOUND " << aNode->Value()->PForMapOfMethods()->Name() << endl ;
-#endif
-    return Standard_True;
-  }
-#if TCollection_AVLSearchTreeTrace
-  cout << " NOT FOUND" << endl ;
-#endif
-  return Standard_False;
-
-}
-
-//----------------------------------------------------------------------------
-// Find the Node where an item is located and returns the node associated
-//----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::Find(const Item&    TheItem,
-                                             Standard_Address& TheNode) const
-{
-  TCollection_AVLNode* aNode = (TCollection_AVLNode*) TheRoot;
-#if TCollection_AVLSearchTreeTrace
-  cout << " ++++++++++++++++++ SEARCH2 +++++++++++++++++++++++++++++" << endl ;
-  cout << "BEGINNING OF SEARCH OF " << TheItem->PForMapOfMethods()->Name()
-       << " in " << hex << TheRoot << dec << endl ;
-#endif
-  while (aNode) {
-    if ( TheComparator.IsLower(TheItem, aNode->Value()) ) {  
-      aNode = (TCollection_AVLNode*)aNode->Left();
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsLower : Left : " << hex
-             << aNode << dec << endl ;
-#endif
-    }
-    else if ( TheComparator.IsGreater(TheItem, aNode->Value()) ) {
-      aNode = (TCollection_AVLNode*)aNode->Right();
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsGreater : Right : " << hex
-             << aNode << dec << endl ;
-#endif
-    }
-    else {
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsEqual : " << hex << aNode
-             << dec << endl ;
-#endif
-      break;
-    }
-  }
-  if ( aNode ) {
-    TheNode = (Standard_Address) aNode;
-#if TCollection_AVLSearchTreeTrace
-    cout << "FOUND " << aNode->Value()->PForMapOfMethods()->Name() << endl ;
-#endif
-    return Standard_True;
-  }
-#if TCollection_AVLSearchTreeTrace
-  cout << " NOT FOUND" << endl ;
-#endif
-    return Standard_False;
-
-}
-
-//----------------------------------------------------------------------------
-// Find the Node where an item is located
-//----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::Find(const Item& TheItem,
-                                             Item& TheOrig) const
-{
-  TCollection_AVLNode* aNode = (TCollection_AVLNode*) TheRoot;
-#if TCollection_AVLSearchTreeTrace
-  cout << " ++++++++++++++++++ SEARCH3 +++++++++++++++++++++++++++++" << endl ;
-  cout << "BEGINNING OF SEARCH OF " << TheItem->PForMapOfMethods()->Name()
-       << " in " << hex << TheRoot << dec << endl ;
-#endif
-  while (aNode) {
-    if ( TheComparator.IsLower(TheItem, aNode->Value()) ) {
-      aNode = (TCollection_AVLNode*)aNode->Left();
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsLower : Left : " << hex
-             << aNode << dec << endl ;
-#endif
-    }
-    else if ( TheComparator.IsGreater(TheItem, aNode->Value()) ) {
-      aNode = (TCollection_AVLNode*)aNode->Right();
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsGreater : Right : " << hex
-             << aNode << dec << endl ;
-#endif
-    }
-    else {
-#if K_TRACE_A_METHOD
-      if ( K_Trace_a_Method )
-        cout << "TCollection_AVLSearchTree::Find IsEqual : " << hex << aNode
-             << dec << endl ;
-#endif
-      break;
-    }
-  }
-  if ( aNode ) {
-    TheOrig = aNode->Value();
-#if TCollection_AVLSearchTreeTrace
-    cout << "FOUND " << aNode->Value()->PForMapOfMethods()->Name() << endl ;
-#endif
-    return Standard_True;
-  }
-#if TCollection_AVLSearchTreeTrace
-  cout << " NOT FOUND" << endl ;
-#endif
-  return Standard_False;
-
-}
-
-//----------------------------------------------------------------------------
-// RotateRight
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::RotateRight(Standard_Address& TheNode) const 
-{
-// the left child becomes the parent...
-  TCollection_AVLNode* Temp               = (TCollection_AVLNode*)((TCollection_AVLNode *)TheNode)->Left();
-  ((TCollection_AVLNode *)TheNode)->Left()  = Temp->Right();
-  Temp->Right()                 = (TCollection_AVLNode *)TheNode;
-  TheNode                     = (Standard_Address)Temp;
-}
-
-//-----------------------------------------------------------------------------
-// RotateLeft
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::
-                      RotateLeft(Standard_Address& TheNode) const 
-{
-// the right child becomes the parent...
-  TCollection_AVLNode* Temp               = (TCollection_AVLNode*)((TCollection_AVLNode *)TheNode)->Right();
-  ((TCollection_AVLNode *)TheNode)->Right() = Temp->Left();
-  Temp->Left()                  = (TCollection_AVLNode *)TheNode;
-  TheNode                     = (Standard_Address)Temp;
-}
-
-//-----------------------------------------------------------------------------
-// LeftBalance
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::LeftBalance(Standard_Address& Root) const 
-{
-  TCollection_AVLNode* TheNode = (TCollection_AVLNode*)((TCollection_AVLNode*)Root)->Left();
-  if( TCollection_AVLNode::Height(TheNode->Left()) >= TCollection_AVLNode::Height(TheNode->Right()) )  {
-    RotateRight(Root);
-    return;
-  }
-  Standard_Address Ptr = TheNode;
-  RotateLeft(Ptr);
-  TheNode     = (TCollection_AVLNode*)Ptr;
-  ((TCollection_AVLNode*)Root)->Left() = TheNode;
-  RotateRight(Root);
-}
-
-//----------------------------------------------------------------------------
-// RightBalance
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::RightBalance(Standard_Address& Root) const 
-{
-  TCollection_AVLNode* TheNode = (TCollection_AVLNode*)((TCollection_AVLNode *)Root)->Right();
-  if( TCollection_AVLNode::Height(TheNode->Right()) >= TCollection_AVLNode::Height(TheNode->Left())) {
-    RotateLeft(Root);
-    return;
-  }
-  Standard_Address Ptr = TheNode;
-  RotateRight(Ptr);
-  TheNode     = (TCollection_AVLNode*)Ptr;
-  ((TCollection_AVLNode*)Root)->Right() = TheNode;
-  RotateLeft(Root);
-}
-
-//-----------------------------------------------------------------------------
-// InsertBalance
-//-----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::InsertBalance(Standard_Address& Child,
-                                           const Standard_Address Father,
-                                          const TCollection_Side     theSide) const 
-{
-// Balance after insertion
-  switch (TCollection_AVLNode::Height(((TCollection_AVLNode*)Child)->Left()) - 
-          TCollection_AVLNode::Height(((TCollection_AVLNode*)Child)->Right())) {
-        case 2  : LeftBalance(Child);
-                  if ( Father ) 
-                     ((TCollection_AVLNode*)Father)->SetChild((TCollection_AVLNode*)Child, theSide);
-                  return Standard_False;
-        case -2 : RightBalance(Child);
-                  if ( Father ) 
-                     ((TCollection_AVLNode*)Father)->SetChild((TCollection_AVLNode*)Child, theSide);
-                  return Standard_False;
-        case 0  : return Standard_False;
-        default : return Standard_True;
-  }
-}
-
-//----------------------------------------------------------------------------
-// RemoveBalance
-//-----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::
-                           RemoveBalance(Standard_Address& Child, 
-                                   const Standard_Address Father,
-                                  const TCollection_Side    theSide) const 
-{
-// Balance after Remove           
-  switch (TCollection_AVLNode::Height(((TCollection_AVLNode*)Child)->Left()) - 
-          TCollection_AVLNode::Height(((TCollection_AVLNode*)Child)->Right())) {
-         case 2  : LeftBalance(Child);
-                   if (Father) 
-                      ((TCollection_AVLNode*)Father)->SetChild((TCollection_AVLNode*)Child, theSide);
-                  return Standard_True;
-         case -2 : RightBalance(Child);
-                   if ( Father ) 
-                      ((TCollection_AVLNode*)Father)->SetChild((TCollection_AVLNode*)Child, theSide);
-                  return Standard_True;
-        default : return Standard_True;
-         }
-}
-
-//---------------------------------------------------------------------------
-// RecursiveInsert
-//-----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::
-                           RecursiveInsert(
-                               Standard_Address& Child,
-                                    const  Standard_Address  Father,
-                                   const  TCollection_Side     theSide,
-                                    const  Item&    theItem,
-                                           Standard_Boolean& forOnce) const 
-{
-
-  TCollection_AVLNode* Temp;
-// DEC C++ need
-  Standard_Address MyTemp;
-// end of DEC C++ need
-  Standard_Boolean  Result = Standard_False;
-  Standard_Integer  Number;
-
-  //-- Firstly find where the item should be insert 
-
-  if(TheComparator.IsLower(theItem, ((TCollection_AVLNode*)Child)->Value() ) ) 
-  //---------------
-  //-- If the item is lower than the root go to left child
-
-    {
-    Temp = (TCollection_AVLNode*)((TCollection_AVLNode*)Child)->Left();
-    //-- If it's a leaf insert it
-    if ( ! Temp ) {
-      ((TCollection_AVLNode*)Child)->Left() = new TCollection_AVLNode(theItem,(TCollection_AVLNode*)0L,(TCollection_AVLNode*)0L);
-      return Standard_True;
-    }
-    //-- else recursive insert...
-    MyTemp = (Standard_Address)Temp;
-    Result = RecursiveInsert( MyTemp, Child, TCollection_Left,
-                               theItem, forOnce);
-    //-- and rebuild the tree, if no problem.
-    if(Result) return InsertBalance(Child, Father, theSide) ;
-    else return Standard_False;
-    }
-
-  else if (TheComparator.IsGreater(theItem, ((TCollection_AVLNode*)Child)->Value())) 
-  //---------------
-  //-- If the item is greater than the root go to right child
-
-    {
-    Temp = (TCollection_AVLNode*)((TCollection_AVLNode*)Child)->Right();
-    //-- If it's a leaf insert it
-    if ( ! Temp ) {
-      ((TCollection_AVLNode*)Child)->Right() = new TCollection_AVLNode(theItem,(TCollection_AVLNode*)0L,(TCollection_AVLNode*)0L); 
-      return Standard_True;
-    }
-    //-- else recursive insert...
-
-    MyTemp = (Standard_Address)Temp;
-    Result = RecursiveInsert( MyTemp, Child, TCollection_Right, 
-                               theItem, forOnce);
-    //-- and rebuild the tree, if no problem.
-    if(Result) return InsertBalance(Child, Father, theSide);
-    else  return Standard_False;
-    }
-
-  else 
-    {
-  //--------------
-  //--  Item is already there; add 1 to its count
-    if (forOnce) {
-      forOnce = Standard_False;
-    }
-    else {
-      Number = ((TCollection_AVLNode*)Child)->Count();
-      ((TCollection_AVLNode*)Child)->Count() = ++Number;
-    }
-    return Standard_False;
-  }
-}
-
-//-----------------------------------------------------------------------------
-// RecursiveRemove
-//-----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::RecursiveRemove(
-                                       Standard_Address& Child, 
-                                 const Standard_Address  Father, 
-                                const TCollection_Side     theSide,
-                                 const Item&    TheItem,
-                                const Standard_Boolean  ForAll) const 
-{
-  Standard_Boolean Result;
-
-  if ( ! Child ) Standard_NoSuchObject::Raise();// if Child points to something
-
-  TCollection_AVLNode* TheLeft  = (TCollection_AVLNode*)((TCollection_AVLNode*)Child)->Left(); // left children
-  TCollection_AVLNode* TheRight = (TCollection_AVLNode*)((TCollection_AVLNode*)Child)->Right();// right children
-// DEC C++ need
-   Standard_Address MyTheLeft;
-   Standard_Address MyTheRight;
-//
-  if (TheComparator.IsLower(TheItem,((TCollection_AVLNode*)Child)->Value())) 
-  {                                            // TheItem < Value
-    MyTheLeft = (Standard_Address)TheLeft;
-    Result = RecursiveRemove(      MyTheLeft, // left child becomes root
-                                      Child  , // child becomes father
-                             TCollection_Left, // go to left
-                            TheItem         , // same Item
-                             ForAll);
-  }
-  else if (TheComparator.IsGreater(TheItem,(((TCollection_AVLNode*)Child)->Value()))) 
-  {                                            // TheItem > Value
-    MyTheRight = (Standard_Address)TheRight;
-    Result = RecursiveRemove(       MyTheRight,// right child becomes root 
-                                         Child,// child becomes father 
-                             TCollection_Right,// go to right 
-                             TheItem          ,// same Item 
-                             ForAll);
-  }
-  else 
-  {                        
-     //-- The Item has been found
-     ((TCollection_AVLNode*)Child)->Count()--;
-     //-- Is it necessary to remove it ?
-     if (!ForAll && ((TCollection_AVLNode*)Child)->Count() > 0) return Standard_True;
-     //-- In this case we must remove it and rebuild the subtree.
-     if ( TheLeft && TheRight ) 
-      {
-      //-- The subtree has 2 children
-      TCollection_AVLNode* T;
-      TCollection_AVLNode* Temp = TheRight; // From the right child go to 
-      while ( Temp ) {          // the left leaf
-        T    = Temp;
-        Temp = (TCollection_AVLNode*)Temp->Left();
-      }
-      //-- We have the left leaf. Push it at the same level than the
-      //-- node we have removed.
-      ((TCollection_AVLNode*)Child)->Value() = T->Value() ;
-      ((TCollection_AVLNode*)Child)->Count() = T->Count() ;
-      //-- Now we must remove in the right subtree this value; because
-      //-- now it appears twice.
-      MyTheRight = (Standard_Address)TheRight;
-      Result = RecursiveRemove( MyTheRight, Child, TCollection_Right, 
-                                ((TCollection_AVLNode*)Child)->Value(), ForAll);
-      }
-     else 
-      {
-      //-- only one subtree exists (left OR right)
-      //-- First delete the node
-      delete ((TCollection_AVLNode*)Child);
-      //-- Secondly see what is the child not empty
-      if ( ! TheLeft ) { Child = (Standard_Address) TheRight; }
-      else             { Child = (Standard_Address) TheLeft;  }
-      //-- Thirdly update the father node
-// "mip-avril-94 : if (Father is null) => Raise" 
-//    ((TCollection_AVLNode*)Father)->SetChild((TCollection_AVLNode*)Child, theSide);
-      if ((TCollection_AVLNode*)Father != NULL) 
-             ((TCollection_AVLNode*)Father)->SetChild((TCollection_AVLNode*)Child, theSide);
-      return Standard_True;
-      }
-  }
-  //-- Result = Standard_True means we must reorder the tree.
-  if (Result) return RemoveBalance(Child, Father, theSide);
-  return Standard_False;   //     Child has not been found for now
-       
-}
-
-//----------------------------------------------------------------------------
-// Insert
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::Insert (const Item& theItem)
-{
-  if ( ! TheRoot ) {
-     TheRoot = new TCollection_AVLNode(theItem,(TCollection_AVLNode*)0L,(TCollection_AVLNode*)0L);
-     return;
-  }
-  TCollection_AVLNode* Father = NULL;
-  Standard_Boolean forOnce = Standard_False;
-  RecursiveInsert( TheRoot, (Standard_Address)Father, TCollection_Left, theItem, 
-                   forOnce);
-}
-
-//-----------------------------------------------------------------------------
-// InsertOnce
-//-----------------------------------------------------------------------------
-Standard_Boolean TCollection_AVLSearchTree::InsertOnce (const Item& theItem)
-{
-  if ( ! TheRoot ) {
-    TheRoot = new TCollection_AVLNode(theItem,(TCollection_AVLNode*)0L,(TCollection_AVLNode*)0L);
-    return Standard_True;
-  }
-  TCollection_AVLNode* Father  = NULL;
-  Standard_Boolean  forOnce = Standard_True;
-  RecursiveInsert( TheRoot, (Standard_Address)Father, TCollection_Left, theItem, 
-                   forOnce);
-  //-- forOnce = Standard_False if the item was already in the tree
-  return forOnce;
-}
-
-//-----------------------------------------------------------------------------
-// Remove
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::Remove (const Item& theItem) 
-{
-  TCollection_AVLNode* Father = NULL;
-  //-- remove ONLY ONE item of the tree
-  RecursiveRemove( TheRoot, (Standard_Address)Father, TCollection_Left, theItem,Standard_False);
-}
-
-//----------------------------------------------------------------------------
-// RemoveAll
-//-----------------------------------------------------------------------------
-void TCollection_AVLSearchTree::RemoveAll (const Item& theItem) 
-{
-  TCollection_AVLNode* Father = NULL;
-  //-- Remove ALL item of the tree
-  RecursiveRemove( TheRoot, (Standard_Address)Father, TCollection_Left, theItem,Standard_True);
-}
-
-//----------------------------------------------------------------------------
-// Merge
-//-----------------------------------------------------------------------------
-TCollection_AVLSearchTree TCollection_AVLSearchTree::Merge(const TCollection_AVLSearchTree& aTree) const 
-{
-  Item theItem;
-  // First, make a shallowcopy and push the result into a new tree
-  //
-  TCollection_AVLSearchTree newTree = ShallowCopy();
-  // for test-- newTree.ShallowDump(cout);
-  //
-  TCollection_AVLIterator Iter( aTree );
-  //-- Secondly, make an iterator on the second tree
-  //
-  while( Iter.More()) {
-    //-- Thirdly get back its value
-    //  theItem = ((TCollection_AVLNode*)Iter.Value())->Value();
-    //
-    theItem = Iter.Value();
-    
-    //-- and push them into the new tree.
-    //
-    newTree.Insert(theItem);
-    Iter.Next();
-  }
-
-  return newTree;
-}
-
-//----------------------------------------------------------------------------
-// ShallowCopy 
-//-----------------------------------------------------------------------------
-TCollection_AVLSearchTree TCollection_AVLSearchTree::ShallowCopy() const 
-{
-  // Construct a new tree
-  // with same comparator
-  //
-  TCollection_AVLSearchTree newtree (TheComparator); 
-                         
-  // Copy an TCollection_AVLNode and put
-  // the result as root of new tree  
-  //
-  newtree.SetRoot(TCollection_AVLNode::Copy((TCollection_AVLNode*)TheRoot)) ; 
-
-  return newtree;                           
-}
-
diff --git a/src/TCollection/TCollection_AVLSearchTree.lxx b/src/TCollection/TCollection_AVLSearchTree.lxx
deleted file mode 100644 (file)
index dddbf3f..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-// Created by: J.P. TIRAULT
-// Copyright (c) 1998-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//-----------------------------------------------------------------------------
-// inline methods for AVLSearchTree
-//-----------------------------------------------------------------------------
-#include <Standard_Address.hxx>
-
-//-----------------------------------------------------------------------------
-// IsEmpty : Is the current tree empty ?
-//-----------------------------------------------------------------------------
-inline Standard_Boolean TCollection_AVLSearchTree::IsEmpty () const
-{
-  return TheRoot == NULL;
-}
-
-//-----------------------------------------------------------------------------
-// GetRoot : Returns the root of the current tree
-//-----------------------------------------------------------------------------
-inline Standard_Address TCollection_AVLSearchTree::GetRoot () const 
-{
-  return TheRoot;
-}
-
-//-----------------------------------------------------------------------------
-// GetComparator : Returns the Comparator of the current tree
-//-----------------------------------------------------------------------------
-inline Comparator TCollection_AVLSearchTree::GetComparator () const 
-{
-  return TheComparator;
-}
-
-// ---------------------------------------------------------------------------
-// SetRoot : Replaces the root of the current tree
-//-----------------------------------------------------------------------------
-inline void TCollection_AVLSearchTree::SetRoot(const Standard_Address ANode)
-{
-  TheRoot = ANode;
-}
-
-