0031313: Foundation Classes - Dump improvement for classes
[occt.git] / src / TNaming / TNaming_NamedShape.cxx
1 // Created on: 1996-12-18
2 // Created by: Yves FRICAUD
3 // Copyright (c) 1996-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <BRepBuilderAPI_MakeVertex.hxx>
19 #include <gp_Pnt.hxx>
20 #include <Standard.hxx>
21 #include <Standard_ConstructionError.hxx>
22 #include <Standard_GUID.hxx>
23 #include <Standard_NoMoreObject.hxx>
24 #include <Standard_NoSuchObject.hxx>
25 #include <Standard_NullObject.hxx>
26 #include <Standard_Type.hxx>
27 #include <TDF_Attribute.hxx>
28 #include <TDF_AttributeDelta.hxx>
29 #include <TDF_AttributeIterator.hxx>
30 #include <TDF_Data.hxx>
31 #include <TDF_DataSet.hxx>
32 #include <TDF_DeltaOnAddition.hxx>
33 #include <TDF_DeltaOnModification.hxx>
34 #include <TDF_DeltaOnRemoval.hxx>
35 #include <TDF_Label.hxx>
36 #include <TDF_RelocationTable.hxx>
37 #include <TDF_Tool.hxx>
38 #include <TNaming_Builder.hxx>
39 #include <TNaming_CopyShape.hxx>
40 #include <TNaming_DeltaOnModification.hxx>
41 #include <TNaming_DeltaOnRemoval.hxx>
42 #include <TNaming_Iterator.hxx>
43 #include <TNaming_NamedShape.hxx>
44 #include <TNaming_NewShapeIterator.hxx>
45 #include <TNaming_OldShapeIterator.hxx>
46 #include <TNaming_PtrNode.hxx>
47 #include <TNaming_PtrRefShape.hxx>
48 #include <TNaming_RefShape.hxx>
49 #include <TNaming_SameShapeIterator.hxx>
50 #include <TNaming_Tool.hxx>
51 #include <TNaming_UsedShapes.hxx>
52 #include <TopoDS_Shape.hxx>
53 #include <TopoDS_Vertex.hxx>
54
55 IMPLEMENT_STANDARD_RTTIEXT(TNaming_NamedShape,TDF_Attribute)
56
57 // Defines the nodes classes
58 //#define MDTV_DEB_HASL
59 //=======================================================================
60 //function : GetID
61 //purpose  : 
62 //=======================================================================
63 const Standard_GUID& TNaming_NamedShape::GetID() 
64 {
65   static Standard_GUID TNaming_NamedShapeID("c4ef4200-568f-11d1-8940-080009dc3333");
66   return TNaming_NamedShapeID;
67 }
68
69 //=======================================================================
70 //class: TNaming_Node
71 //=======================================================================
72
73 class TNaming_Node {
74 public:
75   TNaming_Node(TNaming_PtrRefShape        Old,
76                TNaming_PtrRefShape        New)
77     : myOld(Old),myNew(New),
78   myAtt(0L),
79   nextSameAttribute(0L), nextSameOld(0L),nextSameNew(0L)
80   {}
81   
82   //Label : Donne le Label
83   TDF_Label Label();
84
85   // NextSameShape
86   TNaming_Node* NextSameShape(TNaming_RefShape* prs);
87
88   // Test si l evolution est valide dans la transaction Trans
89   // ie : Trans n est pas anterieure a sa creation
90   //      et Trans n est pas posterieure a son BackUp
91   Standard_Boolean IsValidInTrans(Standard_Integer Trans);
92
93   //! Dumps the content of me into the stream
94   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
95
96   // Memory management
97   DEFINE_STANDARD_ALLOC
98   
99   TNaming_PtrRefShape  myOld;
100   TNaming_PtrRefShape  myNew;
101   TNaming_NamedShape*  myAtt;
102   TNaming_PtrNode      nextSameAttribute;
103   TNaming_PtrNode      nextSameOld;
104   TNaming_PtrNode      nextSameNew;
105 };
106
107 //=======================================================================
108 //function : NextSameShape
109 //purpose  : 
110 //=======================================================================
111
112 TNaming_Node* TNaming_Node::NextSameShape(TNaming_RefShape* prs)
113 {
114   if (myOld == prs) return nextSameOld;
115   if (myNew == prs) return nextSameNew;
116   return nextSameNew;
117 }  
118
119 //=======================================================================
120 //function : Label
121 //purpose  : 
122 //=======================================================================
123
124 TDF_Label TNaming_Node::Label() 
125
126   return myAtt->Label();
127 }
128
129 //=======================================================================
130 //function : IsValidInTrans
131 //purpose  : 
132 //=======================================================================
133
134 Standard_Boolean TNaming_Node::IsValidInTrans(Standard_Integer Trans)
135 {
136   if (myAtt->Transaction() <= Trans && Trans <= myAtt->UntilTransaction()) {
137     return 1;
138   }
139   return 0;
140 }
141
142 //=======================================================================
143 //function : DumpJson
144 //purpose  : 
145 //=======================================================================
146 void TNaming_Node::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const
147 {
148   OCCT_DUMP_CLASS_BEGIN (theOStream, TNaming_Node)
149
150   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, myOld)
151   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, myNew)
152   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, myAtt)
153
154   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, nextSameAttribute)
155   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, nextSameOld)
156   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, nextSameNew)
157 }
158
159 //**********************************************************************
160 // Methods of TNaming_NamedShape
161 //**********************************************************************
162
163 //=======================================================================
164 //function : TNaming_NamedShape
165 //purpose  : 
166 //=======================================================================
167
168 TNaming_NamedShape::TNaming_NamedShape()
169
170   myNode    = 0L;
171   myVersion = 0;
172 }
173
174 //=======================================================================
175 //function : IsEmpty
176 //purpose  : 
177 //=======================================================================
178
179 Standard_Boolean  TNaming_NamedShape::IsEmpty () const
180 {  
181   TNaming_Iterator it (this);
182   return !it.More();
183 }
184
185
186 //=======================================================================
187 //function : Get
188 //purpose  : 
189 //=======================================================================
190
191 TopoDS_Shape TNaming_NamedShape::Get () const
192 {  
193   return TNaming_Tool::GetShape (this);
194 }
195
196
197
198
199 //=======================================================================
200 //function : RemoveNode
201 //purpose  : 
202 //=======================================================================
203
204 static void RemoveNode(Standard_Boolean                   MapExist ,
205                        TNaming_DataMapOfShapePtrRefShape& M, 
206                        TNaming_Node*&                     N) 
207 {
208   TNaming_RefShape* pos  = N->myOld;  
209   if (pos != 0L) {
210     if (pos->FirstUse() == N) {
211       TNaming_Node*  nextOld = N->nextSameOld;
212       if (nextOld != 0L) 
213         pos->FirstUse(nextOld);
214       else {
215         // le shape disparait
216         if (MapExist)
217           M.UnBind(pos->Shape());
218         N->myOld = 0L;
219         if(pos != N->myNew)
220         {
221           delete pos;
222           pos = 0L;
223         }
224       }
225     }
226     else {
227       TNaming_Node* pdn = pos->FirstUse();
228       while (pdn != 0L) {
229         
230         if (pdn->NextSameShape(pos) == N) {
231           if (pdn->myOld == pos) pdn->nextSameOld =  N->nextSameOld;
232           else                   pdn->nextSameNew =  N->nextSameOld;
233           break;
234         }
235         pdn = pdn->NextSameShape(pos);
236       }
237     }
238   }
239
240   TNaming_RefShape* pns  = N->myNew;  
241   if (pns != 0L) {
242     if (pns->FirstUse() == N) {
243       TNaming_Node*  nextNew = N->nextSameNew;
244       if (nextNew != 0L) 
245         pns->FirstUse(nextNew);
246       else 
247       {
248         // le shape disparait
249         if (MapExist) 
250           M.UnBind(pns->Shape());
251       
252         pns->FirstUse(0L);
253         delete pns;
254         pns = 0L;
255
256         N->myNew = 0L;
257       
258       }
259     }
260     else {
261       TNaming_Node* pdn = pns->FirstUse();
262       while (pdn != 0L) {
263         if (pdn->NextSameShape(pns) == N) {
264           if (pdn->myOld == pns) pdn->nextSameOld =  N->nextSameNew;
265           else                   pdn->nextSameNew =  N->nextSameNew;
266           break;
267         }
268         pdn = pdn->NextSameShape(pns);
269       }
270     }
271   }
272 }
273
274 //=======================================================================
275 //function : Clear
276 //purpose  : 
277 //=======================================================================
278
279 void TNaming_NamedShape::Clear()
280 {
281   if (Label().IsNull()) {
282 #ifdef OCCT_DEBUG_BUILDER
283     std::cout << "attention etat fantomatique" << std::endl;
284 #endif
285     return;
286   }
287
288   Handle(TNaming_UsedShapes) US;
289     
290   TNaming_DataMapOfShapePtrRefShape* M=NULL;
291     
292   // Recuperation de la map si celle-ci n est pas deja detruite.
293   //Standard_Boolean MapExist = Ins.FindInRoot(TNaming_UsedShapes::GetID(),US);
294
295   Standard_Boolean MapExist = Label().Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
296   if (MapExist) M = &(US->Map());
297     
298   TNaming_Node* p = myNode;
299   while (p != 0L) {
300     RemoveNode (MapExist,*M,p);
301     p = p->nextSameAttribute;
302   }
303     
304   p = myNode;
305   TNaming_Node* q;
306   while (p != 0L) {
307     q = p;
308     p = p->nextSameAttribute;
309     if( q !=0L)
310     {
311       delete q;
312       q = 0L;
313     }
314   }
315     
316   myNode = 0L;
317 }
318
319 //=======================================================================
320 //function : BeforeRemoval
321 //purpose  : 
322 //=======================================================================
323
324 void TNaming_NamedShape::BeforeRemoval()
325 {
326   Clear();
327 }
328
329
330 //=======================================================================
331 //function : BeforeUndo
332 //purpose  : before application of a TDF_Delta.
333 //=======================================================================
334
335 Standard_Boolean TNaming_NamedShape::BeforeUndo
336   (const Handle(TDF_AttributeDelta)& /*anAttDelta*/,
337    const Standard_Boolean /*forceIt*/)
338 {
339 //  if (anAttDelta->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition))) {
340 //    anAttDelta->Attribute()->BeforeRemoval();
341 //  }
342   return Standard_True;
343 }
344
345 //=======================================================================
346 //function : AfterUndo 
347 //purpose  : After application of a TDF_Delta.
348 //=======================================================================
349
350 Standard_Boolean TNaming_NamedShape::AfterUndo
351   (const Handle(TDF_AttributeDelta)& anAttDelta,
352    const Standard_Boolean /*forceIt*/)
353 {
354   if (anAttDelta->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition))) {
355     Handle(TNaming_UsedShapes) US;
356
357     TNaming_DataMapOfShapePtrRefShape* M=NULL;
358
359   // Recuperation de la map si celle-ci n est pas deja detruite.
360     //Standard_Boolean MapExist = Ins.FindInRoot(TNaming_UsedShapes::GetID(),US);
361     
362     Standard_Boolean MapExist = anAttDelta->Label().Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
363
364     if (MapExist) M = &(US->Map());
365     
366     TNaming_Node* p = myNode;
367     while (p != 0L) {
368       RemoveNode (MapExist,*M,p);
369       p = p->nextSameAttribute;
370     }
371     
372     p = myNode;
373     TNaming_Node* q;
374     while (p != 0L) {
375       q = p;
376       p = p->nextSameAttribute;
377       if(q != 0L)
378       {
379         delete q;
380         q = 0L;
381       }
382     }
383
384     myNode = 0L;
385   }
386   return Standard_True;
387 }
388
389
390 //=======================================================================
391 //function : BackupCopy
392 //purpose  : 
393 //=======================================================================
394
395 Handle(TDF_Attribute) TNaming_NamedShape::BackupCopy() const
396 {
397   // Remarque dans le copy il est important de reporter le noeud de l attribut
398   // pour ne pas casser le chemin nextSameShape.
399
400   Handle(TNaming_NamedShape) Cop = new TNaming_NamedShape();
401   Cop->myNode      = myNode;
402   Cop->myEvolution = myEvolution;
403   Cop->myVersion   = myVersion;
404
405   // Mise a jour de myAtt sur les noeuds dans l attribut.
406   TNaming_Node*  CN = Cop->myNode;
407
408   Handle(TNaming_NamedShape) A = this;
409   A->myNode = 0L;
410
411   while (CN != 0L) {
412     CN->myAtt = Cop.operator->();
413     CN        = CN->nextSameAttribute;
414   }
415   return Cop;
416 }
417
418
419 //=======================================================================
420 //function : Restore
421 //purpose  : 
422 //=======================================================================
423
424 void TNaming_NamedShape::Restore(const Handle(TDF_Attribute)& anAttribute) 
425 {
426   Clear();
427
428   TNaming_NamedShape* PAtt  = (TNaming_NamedShape*)anAttribute.operator->();
429   myNode                   = PAtt->myNode;
430   myEvolution              = PAtt->myEvolution;
431   myVersion                = PAtt->myVersion;
432   
433   // Mise a jour de myAtt sur les noeuds dans l attribut.
434   TNaming_Node*  CN = myNode;
435   while (CN != 0L) {
436     CN->myAtt = this;
437     CN        = CN->nextSameAttribute;
438   }
439   PAtt->myNode = 0L; //un noeud est dans un seul attribut.
440 }
441
442
443 //=======================================================================
444 //function : DeltaOnModification
445 //purpose  : 
446 //=======================================================================
447
448 Handle(TDF_DeltaOnModification) TNaming_NamedShape::DeltaOnModification
449 (const Handle(TDF_Attribute)& anOldAttribute) const
450 {
451   
452   return new TNaming_DeltaOnModification(Handle(TNaming_NamedShape)::DownCast (anOldAttribute));
453 }
454
455 //=======================================================================
456 //function : DeltaOnModification
457 //purpose  : 
458 //=======================================================================
459
460 void TNaming_NamedShape::DeltaOnModification(const Handle(TDF_DeltaOnModification)& aDelta) 
461 {
462   aDelta->Apply();
463 }
464
465 //=======================================================================
466 //function : DeltaOnRemoval
467 //purpose  : 
468 //=======================================================================
469
470 Handle(TDF_DeltaOnRemoval) TNaming_NamedShape::DeltaOnRemoval() const
471 {
472   return new TNaming_DeltaOnRemoval(this);
473 }
474
475 //=======================================================================
476 //function : NewEmpty
477 //purpose  : 
478 //=======================================================================
479
480 Handle(TDF_Attribute) TNaming_NamedShape::NewEmpty () const
481 {
482   return new TNaming_NamedShape();
483 }
484
485 //=======================================================================
486 //function : Paste
487 //purpose  : 
488 //=======================================================================
489
490 void TNaming_NamedShape::Paste(const Handle(TDF_Attribute)&       into,
491                                const Handle(TDF_RelocationTable)& Tab) 
492 const
493
494   TDF_Label        Lab = into->Label();
495   if (Lab.IsNull()) {
496     throw Standard_NullObject("TNaming_NamedShape::Paste");
497   }
498   TNaming_Builder B(Lab);
499
500   TNaming_Iterator It (this);
501   for ( ;It.More() ; It.Next()) {
502     const TopoDS_Shape& OS     = It.OldShape();
503     const TopoDS_Shape& NS     = It.NewShape();
504     TNaming_Evolution   aStatus = It.Evolution();
505
506 // Modification_1 24.06.99 (szy)  
507     TopoDS_Shape copOS, copNS;
508     if(aStatus != TNaming_PRIMITIVE)
509       TNaming_CopyShape::CopyTool(OS, Tab->TransientTable(), copOS);
510     else copOS.Nullify();    
511     if(aStatus != TNaming_DELETE )
512       TNaming_CopyShape::CopyTool(NS, Tab->TransientTable(), copNS);
513     else copNS.Nullify();
514     
515     switch (aStatus) {
516     case TNaming_PRIMITIVE :
517       {
518         B.Generated(copNS);
519         break;
520       }
521     case TNaming_GENERATED :
522       {
523         B.Generated(copOS, copNS);
524         break;
525       }
526     case TNaming_MODIFY : 
527       {
528         B.Modify(copOS, copNS);
529         break;
530       }
531     case TNaming_DELETE : 
532       {
533         B.Delete (copOS);
534         break;
535       }
536     case TNaming_SELECTED :
537       {
538         B.Select(copNS,copOS);
539         break;
540       }
541
542     default:
543         break;
544     }
545   }
546 }
547
548 //=======================================================================
549 //function : References
550 //purpose  : 
551 //=======================================================================
552
553 void TNaming_NamedShape::References(const Handle(TDF_DataSet)& aDataSet) const
554 {
555   // Recherche des dependances.
556   // Pour chaque OldShape de l attribut on ajoute au dataSet son label d origine.
557   TNaming_Node* Current = myNode;
558   while (Current != NULL) {
559     if (Current->myOld != NULL) {
560       TNaming_RefShape* prs = Current->myOld;
561       TNaming_Node*     pdn = prs->FirstUse();
562       
563       while (pdn != NULL) {
564         if (pdn->myNew == prs && pdn->myAtt->Evolution() != TNaming_SELECTED) {
565           aDataSet->AddLabel(pdn->Label());
566         }
567         pdn = pdn->NextSameShape(prs);
568       }
569     }
570     Current = Current->nextSameAttribute;
571   }
572 }
573
574
575 //=======================================================================
576 //function : Add
577 //purpose  : 
578 //=======================================================================
579
580 void TNaming_NamedShape::Add(TNaming_Node*& pdn )
581
582   pdn->myAtt             = this;
583   if (myNode != 0L){
584     pdn->nextSameAttribute = myNode;
585   }
586   myNode = pdn;
587 }
588
589 //=======================================================================
590 //function : Dump
591 //purpose  : 
592 //=======================================================================
593
594 Standard_OStream& TNaming_NamedShape::Dump(Standard_OStream& anOS) const
595 {
596   return anOS;
597 }
598
599 //***************************************
600 //       Fin Class Named_Shape.
601 //***************************************
602
603
604 //**********************************************************************
605 // Methods of the TNaming_Builder class
606 //**********************************************************************
607
608 ///=======================================================================
609 //function : TNaming_Builder
610 //purpose  : 
611 //=======================================================================
612
613 TNaming_Builder::TNaming_Builder (const TDF_Label& L)
614 {
615   // Find or Build Map;
616   const TDF_Label& root = L.Root();
617   if (!root.FindAttribute(TNaming_UsedShapes::GetID(),myShapes)) {
618     myShapes = new TNaming_UsedShapes();
619     root.AddAttribute (myShapes);
620   }
621   
622   //Find Or Build Attribute in LIns.
623   if (!L.FindAttribute(TNaming_NamedShape::GetID(),myAtt)) {
624     myAtt = new TNaming_NamedShape();  
625     L.AddAttribute(myAtt);
626   }
627   else {
628     myAtt->Backup();
629     myAtt->Clear();  
630     myAtt->myVersion++;
631   }
632 }
633
634 //=======================================================================
635 //function : TNaming_Builder
636 //purpose  : 
637 //=======================================================================
638
639 Handle(TNaming_NamedShape) TNaming_Builder::NamedShape() const
640 {
641   return myAtt;
642 }
643
644 //=======================================================================
645 //function : UpdateNextSameShape
646 //purpose  : 
647 //=======================================================================
648
649 static void UpdateFirstUseOrNextSameShape(TNaming_RefShape*& prs,
650                                           TNaming_Node*& pdn)
651 {  
652   TNaming_Node* ldn = prs->FirstUse();
653   if (ldn == 0L) {
654     prs->FirstUse(pdn);
655   }
656   else {
657     TNaming_Node* cdn = ldn;
658     while (cdn != 0L) {
659       ldn = cdn;
660       cdn = cdn->NextSameShape(prs);
661       if (ldn == cdn) {
662         throw Standard_ConstructionError("UpdateFirstUseOrNextSameShape");
663         break;
664       }
665     }
666     // boucle interdite et inutile.
667     if (ldn != pdn) {
668       if (ldn->myOld == prs) ldn->nextSameOld = pdn;
669       if (ldn->myNew == prs) ldn->nextSameNew = pdn;
670     }
671   }
672 }
673
674 //=======================================================================
675 //function : Generate
676 //purpose  : 
677 //=======================================================================
678
679 void TNaming_Builder::Generated(const TopoDS_Shape& newShape) 
680 {
681   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_PRIMITIVE;
682   else {
683     if (myAtt->myEvolution != TNaming_PRIMITIVE)
684       throw Standard_ConstructionError("TNaming_Builder : not same evolution");
685   }
686
687   TNaming_RefShape* pos = 0L;
688   TNaming_RefShape* pns;
689   
690   if (myShapes->myMap.IsBound(newShape)) {
691 #ifdef OCCT_DEBUG_BUILDER
692     std::cout <<"TNaming_Builder::Generate : the shape is already in the attribute"<<std::endl;
693 #endif
694     pns = myShapes->myMap.ChangeFind(newShape);
695     if (pns->FirstUse()->myAtt  == myAtt.operator->()) {
696       throw Standard_ConstructionError("TNaming_Builder::Generate");
697     }
698     TNaming_Node* pdn = new TNaming_Node(pos,pns);
699     myAtt->Add(pdn);
700     UpdateFirstUseOrNextSameShape (pns,pdn);
701   }
702   else {
703     pns = new TNaming_RefShape(newShape);    
704     TNaming_Node*     pdn = new TNaming_Node(pos,pns); 
705     pns  ->FirstUse(pdn);
706     myShapes->myMap.Bind (newShape , pns);
707     myAtt->Add(pdn);
708   }
709 }
710
711
712
713 //=======================================================================
714 //function : Delete
715 //purpose  : 
716 //=======================================================================
717
718 void TNaming_Builder::Delete(const TopoDS_Shape& oldShape) 
719 {  
720   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_DELETE;
721   else {
722     if (myAtt->myEvolution != TNaming_DELETE)
723       throw Standard_ConstructionError("TNaming_Builder : not same evolution");
724   }
725
726   TNaming_RefShape* pns;
727   TNaming_RefShape* pos;
728
729   if (myShapes->myMap.IsBound(oldShape)) 
730     pos = myShapes->myMap.ChangeFind(oldShape); 
731   else {
732 #ifdef OCCT_DEBUG_BUILDER
733     std::cout <<"TNaming_Builder::Delete : the shape is not in the data"<<std::endl;
734 #endif
735     pos = new TNaming_RefShape(oldShape);  
736     myShapes->myMap.Bind(oldShape, pos);
737   }
738
739   TopoDS_Shape nullShape;
740   pns = new TNaming_RefShape(nullShape);  
741   myShapes->myMap.Bind(nullShape, pns);
742
743   TNaming_Node*     pdn = new TNaming_Node(pos,pns);   
744   myAtt->Add(pdn);
745   UpdateFirstUseOrNextSameShape (pos,pdn);
746   UpdateFirstUseOrNextSameShape (pns,pdn);
747 }
748
749 //=======================================================================
750 //function : Generate
751 //purpose  : 
752 //=======================================================================
753
754 void TNaming_Builder::Generated(const TopoDS_Shape& oldShape,
755                                 const TopoDS_Shape& newShape) 
756 {  
757   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_GENERATED;
758   else {
759     if (myAtt->myEvolution != TNaming_GENERATED)
760       throw Standard_ConstructionError("TNaming_Builder : not same evolution");
761   }
762
763   if (oldShape.IsSame(newShape)) {
764 #ifdef OCCT_DEBUG_BUILDER
765     std::cout <<"TNaming_Builder::Generate : oldShape IsSame newShape"<<std::endl;
766 #endif
767     return;
768   }
769   TNaming_RefShape* pos;
770   if (!myShapes->myMap.IsBound(oldShape)) {
771     pos = new TNaming_RefShape(oldShape);
772     myShapes->myMap.Bind(oldShape,pos);
773   }
774   else
775     pos = myShapes->myMap.ChangeFind(oldShape);
776   
777   TNaming_RefShape* pns;
778   if (!myShapes->myMap.IsBound(newShape)) {
779     pns = new TNaming_RefShape(newShape);
780     myShapes->myMap.Bind(newShape,pns);
781   }
782   else
783     pns = myShapes->myMap.ChangeFind(newShape);
784   
785   TNaming_Node* pdn = new TNaming_Node(pos,pns);
786   myAtt->Add(pdn);
787   UpdateFirstUseOrNextSameShape (pos,pdn);
788   UpdateFirstUseOrNextSameShape (pns,pdn);
789 }
790
791
792 //=======================================================================
793 //function : Modify
794 //purpose  : 
795 //=======================================================================
796
797 void TNaming_Builder::Modify(const TopoDS_Shape& oldShape,
798                               const TopoDS_Shape& newShape) 
799
800   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_MODIFY;
801   else {
802     if (myAtt->myEvolution != TNaming_MODIFY)
803       throw Standard_ConstructionError("TNaming_Builder : not same evolution");
804   }
805
806   if (oldShape.IsSame(newShape)) {
807 #ifdef OCCT_DEBUG_BUILDER
808     std::cout <<"TNaming_Builder::Modify : oldShape IsSame newShape"<<std::endl;
809 #endif
810     return;
811   }
812   TNaming_RefShape* pos;
813   if (!myShapes->myMap.IsBound(oldShape)) {
814     pos = new TNaming_RefShape(oldShape);
815     myShapes->myMap.Bind(oldShape,pos);
816   }
817   else
818     pos = myShapes->myMap.ChangeFind(oldShape);
819   
820   TNaming_RefShape* pns;
821   if (!myShapes->myMap.IsBound(newShape)) {
822     pns = new TNaming_RefShape(newShape);
823     myShapes->myMap.Bind(newShape,pns);
824   }
825   else
826     pns = myShapes->myMap.ChangeFind(newShape);
827   
828   TNaming_Node* pdn = new TNaming_Node(pos,pns);
829   myAtt->Add(pdn);
830   UpdateFirstUseOrNextSameShape (pos,pdn);
831   UpdateFirstUseOrNextSameShape (pns,pdn);
832   
833 }
834
835 //=======================================================================
836 //function : Select
837 //purpose  : 
838 //=======================================================================
839 void TNaming_Builder::Select (const TopoDS_Shape& S,
840                               const TopoDS_Shape& InS)
841 {  
842   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_SELECTED;
843   else {
844     if (myAtt->myEvolution != TNaming_SELECTED)
845       throw Standard_ConstructionError("TNaming_Builder : not same evolution");
846   }
847
848   TNaming_RefShape* pos;  
849   if (!myShapes->myMap.IsBound(InS)) {
850     pos = new TNaming_RefShape(InS);
851     myShapes->myMap.Bind(InS,pos);
852   }
853   else
854     pos = myShapes->myMap.ChangeFind(InS);
855
856   TNaming_RefShape* pns;
857   if (!myShapes->myMap.IsBound(S)) {
858     pns = new TNaming_RefShape(S);
859     myShapes->myMap.Bind(S,pns);
860   }
861   else
862     pns = myShapes->myMap.ChangeFind(S);  
863
864   TNaming_Node* pdn = new TNaming_Node(pos,pns);
865   myAtt->Add(pdn);
866   UpdateFirstUseOrNextSameShape (pos,pdn);
867   UpdateFirstUseOrNextSameShape (pns,pdn);
868 }
869
870 //**********************************************************************
871 //Methods of the TNaming_Iterator class
872 //**********************************************************************
873
874 //=======================================================================
875 //function : TNaming_Iterator
876 //purpose  : 
877 //=======================================================================
878
879 TNaming_Iterator::TNaming_Iterator(const Handle(TNaming_NamedShape)& Att)
880 :myTrans(-1)
881 {
882   myNode  = Att->myNode; 
883 }
884
885 //=======================================================================
886 //function : TNaming_Iterator
887 //purpose  : 
888 //=======================================================================
889
890 TNaming_Iterator::TNaming_Iterator(const TDF_Label& Lab)
891 :myTrans(-1)
892 {
893   Handle(TNaming_NamedShape) Att;
894   if (Lab.FindAttribute(TNaming_NamedShape::GetID(),Att)) {
895     myNode = Att->myNode;
896   }
897   else {
898     myNode = 0L; 
899   }
900 }
901
902 //=====================================================================
903 //function : TNaming_Iterator
904 //purpose  : 
905 //=======================================================================
906
907 TNaming_Iterator::TNaming_Iterator(const TDF_Label&       Lab,
908                                    const Standard_Integer Trans)
909 :myTrans(Trans)
910 {
911   Handle(TDF_Attribute) Att;
912   if (Lab.FindAttribute(TNaming_NamedShape::GetID(),Trans,Att)) {
913     myNode = Handle(TNaming_NamedShape)::DownCast (Att)->myNode;
914   }
915   else {
916     myNode = 0L;
917 #ifdef OCCT_DEBUG
918     std::cout <<"TNaming_Iterator : No Shape for this label"<<std::endl;
919 #endif
920   }
921 }
922
923 //=======================================================================
924 //function : Next
925 //purpose  : 
926 //=======================================================================
927
928 void TNaming_Iterator::Next() 
929 {
930   Standard_NoMoreObject_Raise_if(myNode == 0L,
931                                  "TNaming_Iterator::Next");
932   myNode = myNode->nextSameAttribute;   
933 }
934
935 //=======================================================================
936 //function : OldShape
937 //purpose  : 
938 //=======================================================================
939
940 const TopoDS_Shape& TNaming_Iterator::OldShape() const 
941 {  
942   Standard_NoSuchObject_Raise_if(myNode == 0L,
943                                  "TNaming_Iterator::OldShape");
944   if (myNode->myOld == 0L) {
945     static TopoDS_Shape NullShape;
946     return NullShape;
947   }
948   return myNode->myOld->Shape();
949 }
950
951 //=======================================================================
952 //function : NewShape
953 //purpose  : 
954 //=======================================================================
955
956 const TopoDS_Shape& TNaming_Iterator::NewShape() const 
957 {
958   Standard_NoSuchObject_Raise_if(myNode == 0L,
959                                  "TNaming_Iterator::NewShape");
960   if (myNode->myNew == 0L) {
961     static TopoDS_Shape NullShape;
962     return NullShape;
963   }
964   return myNode->myNew->Shape();
965 }
966
967
968 //=======================================================================
969 //function : IsModification
970 //purpose  : 
971 //=======================================================================
972
973 Standard_Boolean TNaming_Iterator::IsModification() const
974 {
975   Standard_NoSuchObject_Raise_if(myNode == 0L,
976                                  "TNaming_Iterator::IsModification");
977   return (myNode->myAtt->myEvolution == TNaming_MODIFY || 
978           myNode->myAtt->myEvolution == TNaming_DELETE );
979 }
980
981 //=======================================================================
982 //function : Evolution
983 //purpose  : 
984 //=======================================================================
985
986 TNaming_Evolution  TNaming_Iterator::Evolution() const
987 {
988   Standard_NoSuchObject_Raise_if(myNode == 0L,
989                                  "TNaming_Iterator::IsModification");
990   return myNode->myAtt->myEvolution;
991 }
992
993
994
995 //**********************************************************************
996 //Methods of the TNaming_NewShapeIterator class
997 //**********************************************************************
998
999 //=======================================================================
1000 //function : SelectSameShape
1001 //purpose  : Selectionne le prochain noeud ou le shape est le meme que celui
1002 //           de RS. Old = 0 si il doit etre new dans le noeud a chercher.
1003 //           selection dans la transaction valide.
1004 //           On saute aussi les noeud ou OS = NS;
1005 //=======================================================================
1006
1007 static void SelectSameShape (TNaming_Node*&          myNode,
1008                              Standard_Boolean        Old,
1009                              TNaming_RefShape*&      RS,
1010                              const Standard_Integer& Trans)
1011 {
1012   TNaming_Node* pdn = myNode;
1013   
1014   while (pdn != 0L) {
1015     Standard_Boolean Valid;
1016     if (Trans < 0) Valid = pdn->myAtt->IsValid(); 
1017     else Valid = pdn->IsValidInTrans(Trans);
1018
1019     if (Valid)
1020     {
1021       if (Old) {
1022         if( pdn->myOld == RS && pdn->myNew != 0L && pdn->myNew != RS) {
1023           break;
1024         }  
1025       }
1026       else {
1027         if( pdn->myNew == RS && pdn->myOld != 0L && pdn->myOld != RS) {
1028           break;
1029         }
1030       }
1031     }
1032     pdn = pdn->NextSameShape(RS);
1033   }
1034   myNode = pdn;
1035 }  
1036
1037 //=======================================================================
1038 //function : TNaming_NewShapeIterator
1039 //purpose  : 
1040 //=======================================================================
1041
1042 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1043 (const TopoDS_Shape&               aShape,
1044  const Standard_Integer            Trans,
1045  const Handle(TNaming_UsedShapes)& Shapes)
1046 :myTrans(Trans)
1047
1048   Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1049                                      "TNaming_NewShapeIterator::TNaming_NewShapeIterator aShape");  
1050   TNaming_RefShape* RS = Shapes->Map().ChangeFind(aShape);  
1051   myNode = RS->FirstUse();
1052   Standard_Boolean  Old(Standard_True); 
1053   SelectSameShape(myNode,Old,RS,myTrans);
1054 }
1055
1056 //=======================================================================
1057 //function : TNaming_NewShapeIterator
1058 //purpose  : 
1059 //=======================================================================
1060
1061 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1062 (const TopoDS_Shape&               aShape,
1063  const Standard_Integer            Trans,
1064  const TDF_Label&                  access)
1065 :myTrans(Trans)
1066 {  
1067   Handle(TNaming_UsedShapes) Shapes;
1068   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {    
1069         Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1070                                            "TNaming_NewShapeIterator::TNaming_NewShapeIterator aShape");
1071     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);   
1072     myNode = RS->FirstUse();
1073         Standard_Boolean  Old(Standard_True);
1074     SelectSameShape(myNode,Old,RS,myTrans);
1075   }
1076 }
1077
1078 //=======================================================================
1079 //function : TNaming_NewShapeIterator
1080 //purpose  : 
1081 //=======================================================================
1082
1083 TNaming_NewShapeIterator::TNaming_NewShapeIterator (const TNaming_Iterator& anIterator)
1084 :myTrans(anIterator.myTrans)
1085 {
1086   Standard_NoSuchObject_Raise_if(anIterator.myNode == 0L,
1087                                  "TNaming_NewShapeIterator::TNaming_NewShapeIterator");
1088   myNode = anIterator.myNode;  
1089   TNaming_RefShape* RS = myNode->myNew;
1090   if (RS == 0L) 
1091     myNode = 0L;  // No descendant
1092   else {    
1093     // il faut repartir de la premiere utilisation.
1094     myNode = RS->FirstUse();
1095         Standard_Boolean Old(Standard_True);  
1096     SelectSameShape(myNode,Old,RS,myTrans);
1097   }
1098 }
1099
1100 //=======================================================================
1101 //function : TNaming_NewShapeIterator
1102 //purpose  : 
1103 //=======================================================================
1104
1105 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1106 (const TopoDS_Shape&               aShape,
1107  const Handle(TNaming_UsedShapes)& Shapes)
1108 :myTrans(-1)
1109 {
1110   Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1111                                          "TNaming_NewShapeIterator::TNaming_NewShapeIterator aShape");
1112   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1113   myNode = RS->FirstUse();
1114    Standard_Boolean  Old(Standard_True);  
1115   SelectSameShape(myNode,Old,RS,myTrans);
1116 }
1117
1118 //=======================================================================
1119 //function : TNaming_NewShapeIterator
1120 //purpose  : 
1121 //=======================================================================
1122
1123 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1124 (const TopoDS_Shape& aShape,
1125  const TDF_Label&    access)
1126 :myTrans(-1)
1127 {
1128   Handle(TNaming_UsedShapes) Shapes;
1129   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {
1130     Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1131                                            "TNaming_NewShapeIterator::TNaming_NewShapeIterator aShape");
1132     Standard_Boolean  Old(Standard_True);  
1133     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);   
1134     myNode = RS->FirstUse();
1135     SelectSameShape(myNode,Old,RS,myTrans);
1136   }
1137 }
1138
1139 //=======================================================================
1140 //function : TNaming_NewShapeIterator
1141 //purpose  : 
1142 //=======================================================================
1143
1144 TNaming_NewShapeIterator::TNaming_NewShapeIterator(const TNaming_NewShapeIterator& anIterator)
1145 :myTrans(anIterator.myTrans)
1146 {
1147   Standard_NoSuchObject_Raise_if(anIterator.myNode == 0L,
1148                                  "TNaming_NewShapeIterator::TNaming_NewShapeIterator");
1149   myNode = anIterator.myNode;
1150   TNaming_RefShape* RS = myNode->myNew;
1151   if (RS == 0L) 
1152     myNode = 0L;  // No descendant
1153   else  {
1154     // il faut repartir de la premiere utilisation.
1155     myNode = RS->FirstUse();
1156         Standard_Boolean Old(Standard_True);
1157     SelectSameShape(myNode,Old,RS,myTrans);
1158   }
1159 }
1160
1161 //=======================================================================
1162 //function : Next
1163 //purpose  : 
1164 //=======================================================================
1165
1166 void TNaming_NewShapeIterator::Next() 
1167 {
1168   TNaming_RefShape* RS  = myNode->myOld;
1169   myNode = myNode->NextSameShape(RS);
1170   Standard_Boolean  Old(Standard_True);
1171   SelectSameShape(myNode,Old,RS,myTrans);
1172 }
1173
1174 //=======================================================================
1175 //function : Label
1176 //purpose  : 
1177 //=======================================================================
1178
1179 TDF_Label TNaming_NewShapeIterator::Label() const
1180 {  
1181   Standard_NoSuchObject_Raise_if(myNode == 0L,
1182                                  "TNaming_NewShapeIterator::Label");
1183   return myNode->Label();
1184 }
1185
1186 //=======================================================================
1187 //function : NamedShape
1188 //purpose  : 
1189 //=======================================================================
1190
1191 Handle(TNaming_NamedShape) TNaming_NewShapeIterator::NamedShape() const
1192 {  
1193   Standard_NoSuchObject_Raise_if(myNode == 0L,
1194                                  "TNaming_NewShapeIterator::Label");
1195   return myNode->myAtt;
1196 }
1197
1198 //=======================================================================
1199 //function : Shape
1200 //purpose  : 
1201 //=======================================================================
1202
1203 const TopoDS_Shape& TNaming_NewShapeIterator::Shape() const
1204 {
1205   Standard_NoSuchObject_Raise_if(myNode == 0L,
1206                                  "TNaming_NewShapeIterator::Shape"); 
1207   return myNode->myNew->Shape();
1208 }
1209
1210 //=======================================================================
1211 //function : IsModification
1212 //purpose  : 
1213 //=======================================================================
1214
1215 Standard_Boolean TNaming_NewShapeIterator::IsModification() const
1216 {  
1217   Standard_NoSuchObject_Raise_if(myNode == 0L,
1218                                  "TNaming_NewShapeIterator::IsModification");
1219
1220   return (myNode->myAtt->myEvolution == TNaming_MODIFY || 
1221           myNode->myAtt->myEvolution == TNaming_DELETE );
1222 }
1223
1224 //**********************************************************************
1225 //Methods of the TNaming_OldShapeIterator class
1226 //**********************************************************************
1227 //=======================================================================
1228 //function : TNaming_OldShapeIterator
1229 //purpose  : 
1230 //=======================================================================
1231
1232 TNaming_OldShapeIterator::TNaming_OldShapeIterator
1233 (const TopoDS_Shape&               aShape,
1234  const Standard_Integer            Trans,
1235  const Handle(TNaming_UsedShapes)& Shapes)
1236 :myTrans(Trans)
1237 {
1238   Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1239                                          "TNaming_OldShapeIterator::TNaming_OldShapeIterator aShape");
1240   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1241   myNode = RS->FirstUse();
1242   Standard_Boolean  Old(Standard_False);
1243   SelectSameShape(myNode,Old,RS,myTrans);
1244 }
1245
1246 //=======================================================================
1247 //function : TNaming_OldShapeIterator
1248 //purpose  : 
1249 //=======================================================================
1250
1251 TNaming_OldShapeIterator::TNaming_OldShapeIterator 
1252 (const TopoDS_Shape& aShape,
1253  const Standard_Integer Trans,
1254  const TDF_Label& access)
1255 :myTrans(Trans)
1256 {
1257   Handle(TNaming_UsedShapes) Shapes;
1258   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {
1259         Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1260                                            "TNaming_OldShapeIterator::TNaming_OldShapeIterator aShape");    
1261     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1262     myNode = RS->FirstUse();
1263         Standard_Boolean  Old(Standard_False);
1264     SelectSameShape(myNode,Old,RS,myTrans);
1265   }
1266 }
1267 //=======================================================================
1268 //function : TNaming_OldShapeIterator
1269 //purpose  : 
1270 //=======================================================================
1271
1272 TNaming_OldShapeIterator::TNaming_OldShapeIterator
1273 (const TopoDS_Shape&               aShape,
1274  const Handle(TNaming_UsedShapes)& Shapes)
1275 :myTrans(-1)
1276 {  
1277   Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1278                                          "TNaming_OldShapeIterator::TNaming_OldShapeIterator aShape"); 
1279   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1280   myNode = RS->FirstUse();
1281   Standard_Boolean  Old(Standard_False);
1282   SelectSameShape(myNode,Old,RS,myTrans);
1283 }
1284
1285 //=======================================================================
1286 //function : TNaming_OldShapeIterator
1287 //purpose  : 
1288 //=======================================================================
1289
1290 TNaming_OldShapeIterator::TNaming_OldShapeIterator
1291 (const TopoDS_Shape& aShape,
1292  const TDF_Label& access)
1293 :myTrans(-1)
1294 {  
1295   Handle(TNaming_UsedShapes) Shapes;
1296   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {
1297     Standard_NoSuchObject_Raise_if(!Shapes->Map().IsBound(aShape), 
1298                                            "TNaming_OldShapeIterator::TNaming_OldShapeIterator aShape"); 
1299     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1300     myNode = RS->FirstUse();
1301         Standard_Boolean  Old(Standard_False);
1302     SelectSameShape(myNode,Old,RS,myTrans);
1303   }
1304 }
1305
1306 //=======================================================================
1307 //function : TNaming_OldShapeIterator
1308 //purpose  : 
1309 //=======================================================================
1310
1311 TNaming_OldShapeIterator::TNaming_OldShapeIterator (const TNaming_Iterator& anIterator)
1312 :myTrans(anIterator.myTrans)
1313 {
1314   Standard_NoSuchObject_Raise_if(anIterator.myNode == 0L,
1315                                                  "TNaming_OldShapeIterator::TNaming_OldShapeIterator");
1316   myNode = anIterator.myNode; 
1317   TNaming_RefShape* RS = myNode->myNew;
1318   if (RS == 0L) 
1319     myNode = 0L;  // No descendant
1320   else {    
1321     // il faut repartir de la premiere utilisation.
1322     myNode = RS->FirstUse();
1323         Standard_Boolean Old(Standard_False);  
1324     SelectSameShape(myNode,Old,RS,myTrans);
1325   }
1326 }
1327
1328 //=======================================================================
1329 //function : TNaming_OldShapeIterator
1330 //purpose  : 
1331 //=======================================================================
1332
1333 TNaming_OldShapeIterator::TNaming_OldShapeIterator(const TNaming_OldShapeIterator& anIterator)
1334 :myTrans(anIterator.myTrans)
1335 {
1336   Standard_NoSuchObject_Raise_if(anIterator.myNode == 0L,
1337                                                  "TNaming_OldShapeIterator::TNaming_OldShapeIterator");
1338   myNode = anIterator.myNode;  
1339   TNaming_RefShape* RS = myNode->myOld;
1340   if (RS == 0L) 
1341     myNode = 0L;  // No descendant
1342   else  {
1343     // il faut repartir de la premiere utilisation.
1344     myNode = RS->FirstUse();
1345         Standard_Boolean Old(Standard_False);  
1346     SelectSameShape(myNode,Old,RS,myTrans);
1347   }
1348 }
1349
1350 //=======================================================================
1351 //function : Next
1352 //purpose  : 
1353 //=======================================================================
1354
1355 void TNaming_OldShapeIterator::Next() 
1356 {
1357   Standard_Boolean  Old = Standard_False;  
1358   TNaming_RefShape* RS  = myNode->myNew;
1359   myNode = myNode->NextSameShape(RS);
1360   SelectSameShape(myNode,Old,RS,myTrans);
1361 }
1362
1363 //=======================================================================
1364 //function : Label
1365 //purpose  : 
1366 //=======================================================================
1367
1368 TDF_Label TNaming_OldShapeIterator::Label() const
1369 {  
1370   if (myNode == 0L) throw Standard_NoSuchObject("TNaming_OldShapeIterator::Label");
1371   return myNode->Label();
1372   
1373 }
1374
1375 //=======================================================================
1376 //function : NamedShape
1377 //purpose  : 
1378 //=======================================================================
1379
1380 Handle(TNaming_NamedShape) TNaming_OldShapeIterator::NamedShape() const
1381 {  
1382   if (myNode == 0L) throw Standard_NoSuchObject("TNaming_OldShapeIterator::Label");
1383   return myNode->myAtt;
1384 }
1385 //=======================================================================
1386 //function : Shape
1387 //purpose  : 
1388 //=======================================================================
1389
1390 const TopoDS_Shape& TNaming_OldShapeIterator::Shape() const
1391 {   
1392   if(myNode == 0L) throw Standard_NoSuchObject("TNaming_OldShapeIterator::Shape");
1393   return myNode->myOld->Shape();
1394 }
1395
1396 //=======================================================================
1397 //function : IsModification
1398 //purpose  : 
1399 //=======================================================================
1400
1401 Standard_Boolean TNaming_OldShapeIterator::IsModification() const
1402 {  
1403   Standard_NoSuchObject_Raise_if(myNode == 0L,
1404                                  "TNaming_OldShapeIterator::IsModification");  
1405   return (myNode->myAtt->myEvolution == TNaming_MODIFY || 
1406           myNode->myAtt->myEvolution == TNaming_DELETE );
1407 }
1408
1409
1410 //**********************************************************************
1411 //Methods of the SameShapeIterator
1412 //**********************************************************************
1413
1414 //=======================================================================
1415 //function : 
1416 //purpose  : 
1417 //=======================================================================
1418
1419 TNaming_SameShapeIterator::TNaming_SameShapeIterator
1420 (const TopoDS_Shape& aShape,
1421  const Handle(TNaming_UsedShapes)& Shapes)
1422 {
1423   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1424   myNode  = RS->FirstUse();
1425   myIsNew = (myNode->myNew == RS);
1426 }
1427
1428
1429 //=======================================================================
1430 //function : TNaming_SameShapeIterator
1431 //purpose  : 
1432 //=======================================================================
1433
1434 TNaming_SameShapeIterator::TNaming_SameShapeIterator
1435 (const TopoDS_Shape& aShape,
1436  const TDF_Label& access)
1437 {  
1438   Handle(TNaming_UsedShapes) Shapes;
1439   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) { 
1440     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1441     myNode  = RS->FirstUse();
1442     myIsNew = (myNode->myNew == RS);
1443   }
1444 }
1445
1446 //=======================================================================
1447 //function : Next
1448 //purpose  : 
1449 //=======================================================================
1450
1451 void TNaming_SameShapeIterator::Next() 
1452 {
1453   TNaming_RefShape* prs;
1454   if (myIsNew) prs = myNode->myNew; else prs = myNode->myOld;
1455   
1456   myNode = myNode->NextSameShape(prs);
1457   if (myNode != 0L) myIsNew = (myNode->myNew == prs);
1458 }
1459
1460 //=======================================================================
1461 //function : Label
1462 //purpose  : 
1463 //=======================================================================
1464
1465 TDF_Label TNaming_SameShapeIterator::Label() const
1466 {  
1467   Standard_NoSuchObject_Raise_if(myNode == 0L,
1468                                  "TNaming_SameShapeIterator::Label");
1469   return myNode->Label();
1470 }
1471
1472
1473 //**********************************************************************
1474 //Methods of the TNaming_RefShape
1475 //**********************************************************************
1476 //=======================================================================
1477 //function : Label
1478 //purpose  : 
1479 //=======================================================================
1480
1481 TDF_Label TNaming_RefShape::Label() const
1482 {
1483   return myFirstUse->myAtt->Label();
1484 }
1485
1486 //=======================================================================
1487 //function : NamedShape
1488 //purpose  : 
1489 //=======================================================================
1490
1491 Handle(TNaming_NamedShape) TNaming_RefShape::NamedShape() const
1492 {
1493   return myFirstUse->myAtt;
1494 }
1495
1496 //=======================================================================
1497 //function : DumpJson
1498 //purpose  : 
1499 //=======================================================================
1500 void TNaming_RefShape::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const
1501 {
1502   OCCT_DUMP_CLASS_BEGIN (theOStream, TNaming_NamedShape);
1503
1504   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myShape);
1505   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, myFirstUse);
1506 }
1507
1508 //**********************************************************************
1509 //Methods of the TNaming_Tool class
1510 //**********************************************************************
1511
1512 //=======================================================================
1513 //function : HasLabel
1514 //purpose  : 
1515 //=======================================================================
1516
1517 Standard_Boolean TNaming_Tool::HasLabel (const TDF_Label&    access,
1518                                          const TopoDS_Shape& S)
1519 {
1520   Handle(TNaming_UsedShapes) US;
1521   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),US)) {
1522     return (US->Map().IsBound(S));
1523   }
1524 #ifdef OCCT_DEBUG_HASL
1525   std::cout << "##==> Sub-Shape has no Label!" <<std::endl;
1526 #endif
1527   return Standard_False;
1528 }
1529
1530
1531 //=======================================================================
1532 //function : Label
1533 //purpose  : 
1534 //=======================================================================
1535
1536 TDF_Label TNaming_Tool::Label(const TDF_Label&    access,
1537                               const TopoDS_Shape& S,
1538                               Standard_Integer&   Trans)
1539
1540   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(access,S),"TNaming_Tool::Label"); 
1541   Handle(TNaming_UsedShapes) US;
1542   access.Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
1543   return TNaming_Tool::Label(US,S,Trans);
1544 }
1545
1546
1547 //=======================================================================
1548 //function : IsValidInTrans
1549 //purpose  : un shape est valid tant que l attribut ou il est cree est valid 
1550 //=======================================================================
1551
1552 Standard_Integer TNaming_Tool::ValidUntil (const TDF_Label& access, const TopoDS_Shape& S)
1553 {  
1554   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(access,S),"TNaming_Tool::ValidUntil"); 
1555   Handle(TNaming_UsedShapes) US;
1556   access.Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
1557   return TNaming_Tool::ValidUntil(S,US);
1558 }
1559  
1560
1561 //=======================================================================
1562 //function : HasLabel
1563 //purpose  : 
1564 //=======================================================================
1565
1566 Standard_Boolean TNaming_Tool::HasLabel(const Handle(TNaming_UsedShapes)& Shapes,
1567                                         const TopoDS_Shape&               S)
1568 {
1569   return (Shapes->Map().IsBound(S));
1570 }
1571
1572
1573 //=======================================================================
1574 //function : Label
1575 //purpose  : 
1576 //=======================================================================
1577
1578 TDF_Label TNaming_Tool::Label(const Handle(TNaming_UsedShapes)& Shapes,
1579                               const TopoDS_Shape&               S,
1580                               Standard_Integer&                 Trans)
1581 {
1582   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(Shapes,S),"TNaming_Tool::Label");
1583   TNaming_RefShape* prs = Shapes->Map().Find(S);
1584   TNaming_Node*     pdn = prs->FirstUse();
1585
1586   while (pdn != 0L && !(pdn->myNew == prs && pdn->myAtt->Evolution() != TNaming_SELECTED)){
1587     pdn = pdn->NextSameShape(prs);
1588   }
1589   if (pdn == 0L) pdn = prs->FirstUse();
1590
1591   TDF_Label      L   = pdn->Label();
1592   Trans = pdn->myAtt->Transaction();
1593   return L;
1594 }
1595 //=======================================================================
1596 //function : NamedShape
1597 //purpose  : 
1598 //=======================================================================
1599 Handle(TNaming_NamedShape) TNaming_Tool::NamedShape(const TopoDS_Shape& S,
1600                                                     const TDF_Label&    Acces) 
1601
1602   Handle(TNaming_UsedShapes) US;
1603   Acces.Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
1604   Handle(TNaming_NamedShape) NS;
1605   
1606   if(!TNaming_Tool::HasLabel(US,S)) {
1607     return NS;
1608   }
1609   
1610   TNaming_RefShape* prs = US->Map().Find(S);
1611   TNaming_Node*     pdn = prs->FirstUse();
1612   TNaming_Node*     res = 0L;
1613
1614   while (pdn != 0L) {
1615     if (pdn->myNew == prs && pdn->myAtt->Evolution() != TNaming_SELECTED) {
1616       res = pdn;
1617       if (pdn->myAtt->Evolution() != TNaming_GENERATED) {
1618         // Les modifications sont privilegiees par rapport au generation.
1619         // Dans le cas des shapes qui sont a la fois des modifications et des generations
1620         // faces tangentes.
1621         break;
1622       }
1623     }
1624     pdn = pdn->NextSameShape(prs);
1625   }
1626   
1627   if (res == 0L) return NS;
1628
1629   // VERUE EN ATTENDANT DE REVOIR ABORT 03/11/98
1630   // Protection pour eviter de renvoyer un attribut backuped
1631   TDF_Label Lab = res->Label();
1632   Lab.FindAttribute(TNaming_NamedShape::GetID(),NS);
1633   return NS;
1634   //  return res->myAtt;
1635
1636
1637 //=======================================================================
1638 //function : IsValidInTrans
1639 //purpose  : un shape est valid tant que l attribut ou il est cree est valid 
1640 //=======================================================================
1641
1642 Standard_Integer TNaming_Tool::ValidUntil (const TopoDS_Shape&               S,
1643                                            const Handle(TNaming_UsedShapes)& US)
1644 {  
1645   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(US,S),"TNaming_Tool::ValidUntil"); 
1646   
1647   TNaming_RefShape* RS  = US->Map().ChangeFind(S);
1648   Standard_Integer  Cur;
1649   Standard_Integer  Until  = 0;  
1650   TNaming_Node*     Node   = RS->FirstUse();
1651
1652   while (Node != 0L) {
1653     if (Node->myNew != 0L && Node->myNew == RS) {
1654       Cur    = Node->myAtt->UntilTransaction();
1655       if (Cur > Until) Until = Cur;
1656     }
1657     Node = Node->NextSameShape(RS);
1658   }
1659   return Until;
1660 }
1661
1662 //=======================================================================
1663 //function : DumpJson
1664 //purpose  : 
1665 //=======================================================================
1666 void TNaming_NamedShape::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const
1667 {
1668   OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream)
1669
1670   OCCT_DUMP_BASE_CLASS (theOStream, theDepth, TDF_Attribute)
1671   
1672   TCollection_AsciiString aLabel;
1673   TDF_Tool::Entry (myNode->Label(), aLabel);
1674   OCCT_DUMP_FIELD_VALUE_STRING (theOStream, aLabel)
1675   OCCT_DUMP_FIELD_VALUE_STRING (theOStream, myEvolution)
1676   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myVersion)
1677 }