0024171: Eliminate CLang compiler warning -Wreorder
[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-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22
23
24 #include <TNaming_NamedShape.ixx>
25 #include <TNaming_Builder.ixx>
26
27 #include <TDF_Label.hxx>
28 #include <TDF_Data.hxx>
29 #include <TDF_DeltaOnAddition.hxx>
30 #include <TDF_AttributeIterator.hxx>
31 #include <TNaming_PtrNode.hxx>
32 #include <TNaming_PtrRefShape.hxx>
33 #include <TNaming_RefShape.hxx>
34 #include <TNaming_PtrDataMapOfShapePtrRefShape.hxx>
35 #include <TNaming_UsedShapes.hxx>
36 #include <TNaming_Tool.hxx>
37 #include <TNaming_Iterator.hxx>
38 #include <TNaming_NewShapeIterator.hxx>
39 #include <TNaming_OldShapeIterator.hxx>
40 #include <TNaming_SameShapeIterator.hxx>
41
42 #include <TNaming_DeltaOnModification.hxx>
43 #include <TNaming_DeltaOnRemoval.hxx>
44 #include <Standard_NoMoreObject.hxx>
45 #include <Standard_NoSuchObject.hxx>
46 #include <Standard_ConstructionError.hxx>
47 #include <Standard_NullObject.hxx>
48
49 #include <gp_Pnt.hxx>
50 #include <BRepBuilderAPI_MakeVertex.hxx>
51 #include <TopoDS_Vertex.hxx>
52
53 // Defines the nodes classes
54
55 #include <Standard.hxx>
56 #include <TNaming_CopyShape.hxx>
57
58 #define BUC60921   //SRN 15/05/01 : Fixes the memory leak due to pointer to RefShape is not deleted
59 //#define MDTV_DEB_HASL
60 //=======================================================================
61 //function : GetID
62 //purpose  : 
63 //=======================================================================
64
65 const Standard_GUID& TNaming_NamedShape::GetID() 
66 {
67   static Standard_GUID TNaming_NamedShapeID("c4ef4200-568f-11d1-8940-080009dc3333");
68   return TNaming_NamedShapeID;
69 }
70
71 //=======================================================================
72 //class: TNaming_Node
73 //=======================================================================
74
75 class TNaming_Node {
76 public:
77   TNaming_Node(TNaming_PtrRefShape        Old,
78                TNaming_PtrRefShape        New)
79     : myOld(Old),myNew(New),
80   myAtt(0L),
81   nextSameAttribute(0L), nextSameOld(0L),nextSameNew(0L)
82   {}
83   
84   //Label : Donne le Label
85   TDF_Label Label();
86
87   // NextSameShape
88   TNaming_Node* NextSameShape(TNaming_RefShape* prs);
89
90   // Test si l evolution est valide dans la transaction Trans
91   // ie : Trans n est pas anterieure a sa creation
92   //      et Trans n est pas posterieure a son BackUp
93   Standard_Boolean IsValidInTrans(Standard_Integer Trans);
94
95   // Memory management
96   DEFINE_STANDARD_ALLOC
97   
98   TNaming_PtrRefShape  myOld;
99   TNaming_PtrRefShape  myNew;
100   TNaming_NamedShape*  myAtt;
101   TNaming_PtrNode      nextSameAttribute;
102   TNaming_PtrNode      nextSameOld;
103   TNaming_PtrNode      nextSameNew;
104 };
105
106 //=======================================================================
107 //function : NextSameShape
108 //purpose  : 
109 //=======================================================================
110
111 TNaming_Node* TNaming_Node::NextSameShape(TNaming_RefShape* prs)
112 {
113   if (myOld == prs) return nextSameOld;
114   if (myNew == prs) return nextSameNew;
115   return nextSameNew;
116 }  
117
118 //=======================================================================
119 //function : Label
120 //purpose  : 
121 //=======================================================================
122
123 TDF_Label TNaming_Node::Label() 
124
125   return myAtt->Label();
126 }
127
128 //=======================================================================
129 //function : IsValidInTrans
130 //purpose  : 
131 //=======================================================================
132
133 Standard_Boolean TNaming_Node::IsValidInTrans(Standard_Integer Trans)
134 {
135   if (myAtt->Transaction() <= Trans && Trans <= myAtt->UntilTransaction()) {
136     return 1;
137   }
138   return 0;
139 }
140
141 //**********************************************************************
142 // Methods of TNaming_NamedShape
143 //**********************************************************************
144
145 //=======================================================================
146 //function : TNaming_NamedShape
147 //purpose  : 
148 //=======================================================================
149
150 TNaming_NamedShape::TNaming_NamedShape()
151
152   myNode    = 0L;
153   myVersion = 0;
154 }
155
156 //=======================================================================
157 //function : IsEmpty
158 //purpose  : 
159 //=======================================================================
160
161 Standard_Boolean  TNaming_NamedShape::IsEmpty () const
162 {  
163   TNaming_Iterator it (this);
164   return !it.More();
165 }
166
167
168 //=======================================================================
169 //function : Get
170 //purpose  : 
171 //=======================================================================
172
173 TopoDS_Shape TNaming_NamedShape::Get () const
174 {  
175   return TNaming_Tool::GetShape (this);
176 }
177
178
179
180
181 //=======================================================================
182 //function : RemoveNode
183 //purpose  : 
184 //=======================================================================
185
186 static void RemoveNode(Standard_Boolean                   MapExist ,
187                        TNaming_DataMapOfShapePtrRefShape& M, 
188                        TNaming_Node*&                     N) 
189 {
190   TNaming_RefShape* pos  = N->myOld;  
191   if (pos != 0L) {
192     if (pos->FirstUse() == N) {
193       TNaming_Node*  nextOld = N->nextSameOld;
194       if (nextOld != 0L) 
195         pos->FirstUse(nextOld);
196       else {
197         // le shape disparait
198         if (MapExist)
199           M.UnBind(pos->Shape());
200         //#ifdef BUC60921
201         N->myOld = 0L;
202         if(pos != N->myNew)
203         {
204           delete pos;
205           pos = 0L;
206         }
207         //#endif 
208       }
209     }
210     else {
211       TNaming_Node* pdn = pos->FirstUse();
212       while (pdn != 0L) {
213         
214         if (pdn->NextSameShape(pos) == N) {
215           if (pdn->myOld == pos) pdn->nextSameOld =  N->nextSameOld;
216           else                   pdn->nextSameNew =  N->nextSameOld;
217           break;
218         }
219         pdn = pdn->NextSameShape(pos);
220       }
221     }
222   }
223
224   TNaming_RefShape* pns  = N->myNew;  
225   if (pns != 0L) {
226     if (pns->FirstUse() == N) {
227       TNaming_Node*  nextNew = N->nextSameNew;
228       if (nextNew != 0L) 
229         pns->FirstUse(nextNew);
230       else 
231       {
232         // le shape disparait
233         if (MapExist) 
234           M.UnBind(pns->Shape());
235       
236         pns->FirstUse(0L);
237         delete pns;
238         pns = 0L;
239
240         N->myNew = 0L;
241       
242       }
243     }
244     else {
245       TNaming_Node* pdn = pns->FirstUse();
246       while (pdn != 0L) {
247         if (pdn->NextSameShape(pns) == N) {
248           if (pdn->myOld == pns) pdn->nextSameOld =  N->nextSameNew;
249           else                   pdn->nextSameNew =  N->nextSameNew;
250           break;
251         }
252         pdn = pdn->NextSameShape(pns);
253       }
254     }
255   }
256 }
257
258 //=======================================================================
259 //function : Clear
260 //purpose  : 
261 //=======================================================================
262
263 void TNaming_NamedShape::Clear()
264 {
265   if (Label().IsNull()) {
266 #ifdef DEB
267     cout << "attention etat fantomatique" << endl;
268 #endif
269     return;
270   }
271
272   Handle(TNaming_UsedShapes) US;
273     
274   TNaming_DataMapOfShapePtrRefShape* M=NULL;
275     
276   // Recuperation de la map si celle-ci n est pas deja detruite.
277   //Standard_Boolean MapExist = Ins.FindInRoot(TNaming_UsedShapes::GetID(),US);
278
279   Standard_Boolean MapExist = Label().Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
280   if (MapExist) M = &(US->Map());
281     
282   TNaming_Node* p = myNode;
283   while (p != 0L) {
284     RemoveNode (MapExist,*M,p);
285     p = p->nextSameAttribute;
286   }
287     
288   p = myNode;
289   TNaming_Node* q;
290   while (p != 0L) {
291     q = p;
292     p = p->nextSameAttribute;
293     if( q !=0L)
294     {
295       delete q;
296       q = 0L;
297     }
298   }
299     
300   myNode = 0L;
301 }
302
303 //=======================================================================
304 //function : BeforeRemoval
305 //purpose  : 
306 //=======================================================================
307
308 void TNaming_NamedShape::BeforeRemoval()
309 {
310   Clear();
311 }
312
313
314 //=======================================================================
315 //function : BeforeUndo
316 //purpose  : before application of a TDF_Delta.
317 //=======================================================================
318
319 Standard_Boolean TNaming_NamedShape::BeforeUndo
320   (const Handle(TDF_AttributeDelta)& /*anAttDelta*/,
321    const Standard_Boolean /*forceIt*/)
322 {
323 //  if (anAttDelta->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition))) {
324 //    anAttDelta->Attribute()->BeforeRemoval();
325 //  }
326   return Standard_True;
327 }
328
329 //=======================================================================
330 //function : AfterUndo 
331 //purpose  : After application of a TDF_Delta.
332 //=======================================================================
333
334 Standard_Boolean TNaming_NamedShape::AfterUndo
335   (const Handle(TDF_AttributeDelta)& anAttDelta,
336    const Standard_Boolean /*forceIt*/)
337 {
338   if (anAttDelta->IsKind(STANDARD_TYPE(TDF_DeltaOnAddition))) {
339     Handle(TNaming_UsedShapes) US;
340
341     TNaming_DataMapOfShapePtrRefShape* M=NULL;
342
343   // Recuperation de la map si celle-ci n est pas deja detruite.
344     //Standard_Boolean MapExist = Ins.FindInRoot(TNaming_UsedShapes::GetID(),US);
345     
346     Standard_Boolean MapExist = anAttDelta->Label().Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
347
348     if (MapExist) M = &(US->Map());
349     
350     TNaming_Node* p = myNode;
351     while (p != 0L) {
352       RemoveNode (MapExist,*M,p);
353       p = p->nextSameAttribute;
354     }
355     
356     p = myNode;
357     TNaming_Node* q;
358     while (p != 0L) {
359       q = p;
360       p = p->nextSameAttribute;
361       if(q != 0L)
362       {
363         delete q;
364         q = 0L;
365       }
366     }
367
368     myNode = 0L;
369   }
370   return Standard_True;
371 }
372
373
374 //=======================================================================
375 //function : BackupCopy
376 //purpose  : 
377 //=======================================================================
378
379 Handle(TDF_Attribute) TNaming_NamedShape::BackupCopy() const
380 {
381   // Remarque dans le copy il est important de reporter le noeud de l attribut
382   // pour ne pas casser le chemin nextSameShape.
383
384   Handle(TNaming_NamedShape) Cop = new TNaming_NamedShape();
385   Cop->myNode      = myNode;
386   Cop->myEvolution = myEvolution;
387   Cop->myVersion   = myVersion;
388
389   // Mise a jour de myAtt sur les noeuds dans l attribut.
390   TNaming_Node*  CN = Cop->myNode;
391
392   Handle(TNaming_NamedShape) A = this;
393   A->myNode = 0L;
394
395   while (CN != 0L) {
396     CN->myAtt = Cop.operator->();
397     CN        = CN->nextSameAttribute;
398   }
399   return Cop;
400 }
401
402
403 //=======================================================================
404 //function : Restore
405 //purpose  : 
406 //=======================================================================
407
408 void TNaming_NamedShape::Restore(const Handle(TDF_Attribute)& anAttribute) 
409 {
410   Clear();
411
412   TNaming_NamedShape* PAtt  = (TNaming_NamedShape*)anAttribute.operator->();
413   myNode                   = PAtt->myNode;
414   myEvolution              = PAtt->myEvolution;
415   myVersion                = PAtt->myVersion;
416   
417   // Mise a jour de myAtt sur les noeuds dans l attribut.
418   TNaming_Node*  CN = myNode;
419   while (CN != 0L) {
420     CN->myAtt = this;
421     CN        = CN->nextSameAttribute;
422   }
423   PAtt->myNode = 0L; //un noeud est dans un seul attribut.
424 }
425
426
427 //=======================================================================
428 //function : DeltaOnModification
429 //purpose  : 
430 //=======================================================================
431
432 Handle(TDF_DeltaOnModification) TNaming_NamedShape::DeltaOnModification
433 (const Handle(TDF_Attribute)& anOldAttribute) const
434 {
435   
436   return new TNaming_DeltaOnModification(*((Handle(TNaming_NamedShape)*)&anOldAttribute));
437 }
438
439 //=======================================================================
440 //function : DeltaOnModification
441 //purpose  : 
442 //=======================================================================
443
444 void TNaming_NamedShape::DeltaOnModification(const Handle(TDF_DeltaOnModification)& aDelta) 
445 {
446   aDelta->Apply();
447 }
448
449 //=======================================================================
450 //function : DeltaOnRemoval
451 //purpose  : 
452 //=======================================================================
453
454 Handle(TDF_DeltaOnRemoval) TNaming_NamedShape::DeltaOnRemoval() const
455 {
456   return new TNaming_DeltaOnRemoval(this);
457 }
458
459 //=======================================================================
460 //function : NewEmpty
461 //purpose  : 
462 //=======================================================================
463
464 Handle(TDF_Attribute) TNaming_NamedShape::NewEmpty () const
465 {
466   return new TNaming_NamedShape();
467 }
468
469 //=======================================================================
470 //function : static GetLocation 23.06.99 (szy)
471 //purpose  : service: returns copy of Location if exist Relocation 
472 //=======================================================================
473
474 static TopLoc_Location GetLocation(const TopLoc_Location& L,
475                                    const Handle(TDF_RelocationTable)& RT)
476 {
477   TopLoc_Location result;
478   
479   if (!L.IsIdentity()) {
480     Handle(TopLoc_Datum3D) TD;
481     if(!RT->HasTransientRelocation(L.FirstDatum(), TD))
482 #ifdef DEB
483       cout <<"TNaming_Named_Shape::Paste : Relocation for TopLocation don't exist" << endl;
484 #endif
485     result = GetLocation(L.NextLocation(), RT) * 
486       TopLoc_Location(TD).Powered(L.FirstPower());
487   }
488   return result;
489 }
490
491 //=======================================================================
492 //function : Paste
493 //purpose  : 
494 //=======================================================================
495
496 void TNaming_NamedShape::Paste(const Handle(TDF_Attribute)&       into,
497                                const Handle(TDF_RelocationTable)& Tab) 
498 const
499
500   TDF_Label        Lab = into->Label();
501   if (Lab.IsNull()) {
502     Standard_NullObject::Raise("TNaming_NamedShape::Paste");
503   }
504   TNaming_Builder B(Lab);
505
506   TNaming_Iterator It (this);
507   for ( ;It.More() ; It.Next()) {
508     const TopoDS_Shape& OS     = It.OldShape();
509     const TopoDS_Shape& NS     = It.NewShape();
510     TNaming_Evolution   Status = It.Evolution();
511
512 // Modification_1 24.06.99 (szy)  
513     TopoDS_Shape copOS, copNS;
514     if(Status != TNaming_PRIMITIVE)
515       TNaming_CopyShape::CopyTool(OS, Tab->TransientTable(), copOS);
516     else copOS.Nullify();    
517     if(Status != TNaming_DELETE )
518       TNaming_CopyShape::CopyTool(NS, Tab->TransientTable(), copNS);
519     else copNS.Nullify();
520     
521     switch (Status) {
522     case TNaming_PRIMITIVE :
523       {
524         B.Generated(copNS);
525         break;
526       }
527     case TNaming_GENERATED :
528       {
529         B.Generated(copOS, copNS);
530         break;
531       }
532     case TNaming_MODIFY : 
533       {
534         B.Modify(copOS, copNS);
535         break;
536       }
537     case TNaming_DELETE : 
538       {
539         B.Delete (copOS);
540         break;
541       }
542     case TNaming_SELECTED :
543       {
544         B.Select(copNS,copOS);
545         break;
546       }
547
548     default:
549         break;
550     }
551   }
552 }
553
554 //=======================================================================
555 //function : References
556 //purpose  : 
557 //=======================================================================
558
559 void TNaming_NamedShape::References(const Handle(TDF_DataSet)& aDataSet) const
560 {
561   // Recherche des dependances.
562   // Pour chaque OldShape de l attribut on ajoute au dataSet son label d origine.
563   TNaming_Node* Current = myNode;
564   while (Current != NULL) {
565     if (Current->myOld != NULL) {
566       TNaming_RefShape* prs = Current->myOld;
567       TNaming_Node*     pdn = prs->FirstUse();
568       
569       while (pdn != NULL) {
570         if (pdn->myNew == prs && pdn->myAtt->Evolution() != TNaming_SELECTED) {
571           aDataSet->AddLabel(pdn->Label());
572         }
573         pdn = pdn->NextSameShape(prs);
574       }
575     }
576     Current = Current->nextSameAttribute;
577   }
578 }
579
580
581 //=======================================================================
582 //function : Add
583 //purpose  : 
584 //=======================================================================
585
586 void TNaming_NamedShape::Add(TNaming_Node*& pdn )
587
588   pdn->myAtt             = this;
589   if (!myNode == 0L){
590     pdn->nextSameAttribute = myNode;
591   }
592   myNode = pdn;
593 }
594
595 //=======================================================================
596 //function : Dump
597 //purpose  : 
598 //=======================================================================
599
600 Standard_OStream& TNaming_NamedShape::Dump(Standard_OStream& anOS) const
601 {
602   return anOS;
603 }
604
605 //***************************************
606 //       Fin Class Named_Shape.
607 //***************************************
608
609
610 //**********************************************************************
611 // Methods of the TNaming_Builder class
612 //**********************************************************************
613
614 ///=======================================================================
615 //function : TNaming_Builder
616 //purpose  : 
617 //=======================================================================
618
619 TNaming_Builder::TNaming_Builder (const TDF_Label& L)
620 {
621   // Find or Build Map;
622   const TDF_Label& root = L.Root();
623   if (!root.FindAttribute(TNaming_UsedShapes::GetID(),myShapes)) {
624     myShapes = new TNaming_UsedShapes();
625     root.AddAttribute (myShapes);
626   }
627   
628   //Find Or Build Attribute in LIns.
629   if (!L.FindAttribute(TNaming_NamedShape::GetID(),myAtt)) {
630     myAtt = new TNaming_NamedShape();  
631     L.AddAttribute(myAtt);
632   }
633   else {
634     myAtt->Backup();
635     myAtt->Clear();  
636     myAtt->myVersion++;
637   }
638 }
639
640 //=======================================================================
641 //function : TNaming_Builder
642 //purpose  : 
643 //=======================================================================
644
645 Handle(TNaming_NamedShape) TNaming_Builder::NamedShape() const
646 {
647   return myAtt;
648 }
649
650 //=======================================================================
651 //function : UpdateNextSameShape
652 //purpose  : 
653 //=======================================================================
654
655 static void UpdateFirstUseOrNextSameShape(TNaming_RefShape*& prs,
656                                           TNaming_Node*& pdn)
657 {  
658   TNaming_Node* ldn = prs->FirstUse();
659   if (ldn == 0L) {
660     prs->FirstUse(pdn);
661   }
662   else {
663     TNaming_Node* cdn = ldn;
664     while (cdn != 0L) {
665       ldn = cdn;
666       cdn = cdn->NextSameShape(prs);
667       if (ldn == cdn) {
668         Standard_ConstructionError::Raise("UpdateFirstUseOrNextSameShape");
669         break;
670       }
671     }
672     // boucle interdite et inutile.
673     if (ldn != pdn) {
674       if (ldn->myOld == prs) ldn->nextSameOld = pdn;
675       if (ldn->myNew == prs) ldn->nextSameNew = pdn;
676     }
677   }
678 }
679
680 //=======================================================================
681 //function : Generate
682 //purpose  : 
683 //=======================================================================
684
685 void TNaming_Builder::Generated(const TopoDS_Shape& newShape) 
686 {
687   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_PRIMITIVE;
688   else {
689     if (myAtt->myEvolution != TNaming_PRIMITIVE)
690       Standard_ConstructionError::Raise("TNaming_Builder : not same evolution");
691   }
692
693   TNaming_RefShape* pos = 0L;
694   TNaming_RefShape* pns;
695   
696   if (myShapes->myMap.IsBound(newShape)) {
697 #ifdef DEB
698     cout <<"TNaming_Builder::Generate : the shape is already in the attribute"<<endl;
699 #endif
700     pns = myShapes->myMap.ChangeFind(newShape);
701     if (pns->FirstUse()->myAtt  == myAtt.operator->()) {
702       Standard_ConstructionError::Raise("TNaming_Builder::Generate");
703     }
704     TNaming_Node* pdn = new TNaming_Node(pos,pns);
705     myAtt->Add(pdn);
706     UpdateFirstUseOrNextSameShape (pns,pdn);
707   }
708   else {
709     pns = new TNaming_RefShape(newShape);    
710     TNaming_Node*     pdn = new TNaming_Node(pos,pns); 
711     pns  ->FirstUse(pdn);
712     myShapes->myMap.Bind (newShape , pns);
713     myAtt->Add(pdn);
714   }
715 }
716
717
718
719 //=======================================================================
720 //function : Delete
721 //purpose  : 
722 //=======================================================================
723
724 void TNaming_Builder::Delete(const TopoDS_Shape& oldShape) 
725 {  
726   if (myAtt->myNode == 0L) myAtt->myEvolution = TNaming_DELETE;
727   else {
728     if (myAtt->myEvolution != TNaming_DELETE)
729       Standard_ConstructionError::Raise("TNaming_Builder : not same evolution");
730   }
731
732   TNaming_RefShape* pns = 0L;
733   TNaming_RefShape* pos;
734
735   if (myShapes->myMap.IsBound(oldShape)) 
736     pos = myShapes->myMap.ChangeFind(oldShape); 
737   else {
738 #ifdef DEB
739     cout <<"TNaming_Builder::Delete : the shape is not in the data"<<endl;
740 #endif
741     pos = new TNaming_RefShape(oldShape);  
742     myShapes->myMap.Bind(oldShape, pos);
743   }
744   TNaming_Node*     pdn = new TNaming_Node(pos,pns);   
745   myAtt->Add(pdn);
746   UpdateFirstUseOrNextSameShape (pos,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       Standard_ConstructionError::Raise("TNaming_Builder : not same evolution");
761   }
762
763   if (oldShape.IsSame(newShape)) {
764 #ifdef DEB
765     cout <<"TNaming_Builder::Generate : oldShape IsSame newShape"<<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       Standard_ConstructionError::Raise("TNaming_Builder : not same evolution");
804   }
805
806   if (oldShape.IsSame(newShape)) {
807 #ifdef DEB
808     cout <<"TNaming_Builder::Modify : oldShape IsSame newShape"<<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       Standard_ConstructionError::Raise("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(TNaming_NamedShape) Att;
912   if (Lab.FindAttribute(TNaming_NamedShape::GetID(),Trans,Att)) {
913     myNode = Att->myNode;
914   }
915   else {
916     myNode = 0L;
917 #ifdef DEB
918     cout <<"TNaming_Iterator : No Shape for this label"<<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_Boolean  Old = Standard_True;  
1049   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1050   myNode = RS->FirstUse();
1051   SelectSameShape(myNode,Old,RS,myTrans);
1052 }
1053
1054 //=======================================================================
1055 //function : TNaming_NewShapeIterator
1056 //purpose  : 
1057 //=======================================================================
1058
1059 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1060 (const TopoDS_Shape&               aShape,
1061  const Standard_Integer            Trans,
1062  const TDF_Label&                  access)
1063 :myTrans(Trans)
1064 {  
1065   Handle(TNaming_UsedShapes) Shapes;
1066   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {
1067     Standard_Boolean  Old = Standard_True;  
1068     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1069     myNode = RS->FirstUse();
1070     SelectSameShape(myNode,Old,RS,myTrans);
1071   }
1072 }
1073
1074 //=======================================================================
1075 //function : TNaming_NewShapeIterator
1076 //purpose  : 
1077 //=======================================================================
1078
1079 TNaming_NewShapeIterator::TNaming_NewShapeIterator (const TNaming_Iterator& anIterator)
1080 :myTrans(anIterator.myTrans)
1081 {
1082   Standard_Boolean Old = Standard_True;  
1083   myNode = anIterator.myNode;
1084   TNaming_RefShape* RS = myNode->myNew;
1085   if (RS == 0L) 
1086     myNode = 0L;  // No descendant
1087   else {    
1088     // il faut repartir de la premiere utilisation.
1089     myNode = RS->FirstUse();
1090     SelectSameShape(myNode,Old,RS,myTrans);
1091   }
1092 }
1093
1094 //=======================================================================
1095 //function : TNaming_NewShapeIterator
1096 //purpose  : 
1097 //=======================================================================
1098
1099 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1100 (const TopoDS_Shape&               aShape,
1101  const Handle(TNaming_UsedShapes)& Shapes)
1102 :myTrans(-1)
1103 {
1104   Standard_Boolean  Old = Standard_True;  
1105   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1106   myNode = RS->FirstUse();
1107   SelectSameShape(myNode,Old,RS,myTrans);
1108 }
1109
1110 //=======================================================================
1111 //function : TNaming_NewShapeIterator
1112 //purpose  : 
1113 //=======================================================================
1114
1115 TNaming_NewShapeIterator::TNaming_NewShapeIterator
1116 (const TopoDS_Shape& aShape,
1117  const TDF_Label&    access)
1118 :myTrans(-1)
1119 {
1120   Handle(TNaming_UsedShapes) Shapes;
1121   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {
1122     Standard_Boolean  Old = Standard_True;  
1123     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1124     myNode = RS->FirstUse();
1125     SelectSameShape(myNode,Old,RS,myTrans);
1126   }
1127 }
1128
1129 //=======================================================================
1130 //function : TNaming_NewShapeIterator
1131 //purpose  : 
1132 //=======================================================================
1133
1134 TNaming_NewShapeIterator::TNaming_NewShapeIterator(const TNaming_NewShapeIterator& anIterator)
1135 :myTrans(anIterator.myTrans)
1136 {
1137   Standard_Boolean Old = Standard_True;
1138   myNode = anIterator.myNode;
1139   TNaming_RefShape* RS = myNode->myNew;
1140   if (RS == 0L) 
1141     myNode = 0L;  // No descendant
1142   else  {
1143     // il faut repartir de la premiere utilisation.
1144     myNode = RS->FirstUse();
1145     SelectSameShape(myNode,Old,RS,myTrans);
1146   }
1147 }
1148
1149 //=======================================================================
1150 //function : Next
1151 //purpose  : 
1152 //=======================================================================
1153
1154 void TNaming_NewShapeIterator::Next() 
1155 {
1156   Standard_Boolean  Old = Standard_True;
1157   TNaming_RefShape* RS  = myNode->myOld;
1158   myNode = myNode->NextSameShape(RS);
1159   SelectSameShape(myNode,Old,RS,myTrans);
1160 }
1161
1162 //=======================================================================
1163 //function : Label
1164 //purpose  : 
1165 //=======================================================================
1166
1167 TDF_Label TNaming_NewShapeIterator::Label() const
1168 {  
1169   Standard_NoSuchObject_Raise_if(myNode == 0L,
1170                                  "TNaming_NewShapeIterator::Label");
1171   return myNode->Label();
1172 }
1173
1174 //=======================================================================
1175 //function : NamedShape
1176 //purpose  : 
1177 //=======================================================================
1178
1179 Handle(TNaming_NamedShape) TNaming_NewShapeIterator::NamedShape() const
1180 {  
1181   Standard_NoSuchObject_Raise_if(myNode == 0L,
1182                                  "TNaming_NewShapeIterator::Label");
1183   return myNode->myAtt;
1184 }
1185
1186 //=======================================================================
1187 //function : Shape
1188 //purpose  : 
1189 //=======================================================================
1190
1191 const TopoDS_Shape& TNaming_NewShapeIterator::Shape() const
1192 {
1193   Standard_NoSuchObject_Raise_if(myNode == 0L,
1194                                  "TNaming_NewShapeIterator::Shape"); 
1195   return myNode->myNew->Shape();
1196 }
1197
1198 //=======================================================================
1199 //function : IsModification
1200 //purpose  : 
1201 //=======================================================================
1202
1203 Standard_Boolean TNaming_NewShapeIterator::IsModification() const
1204 {  
1205   Standard_NoSuchObject_Raise_if(myNode == 0L,
1206                                  "TNaming_NewShapeIterator::IsModification");
1207
1208   return (myNode->myAtt->myEvolution == TNaming_MODIFY || 
1209           myNode->myAtt->myEvolution == TNaming_DELETE );
1210 }
1211
1212 //**********************************************************************
1213 //Methods of the TNaming_OldShapeIterator class
1214 //**********************************************************************
1215 //=======================================================================
1216 //function : TNaming_OldShapeIterator
1217 //purpose  : 
1218 //=======================================================================
1219
1220 TNaming_OldShapeIterator::TNaming_OldShapeIterator
1221 (const TopoDS_Shape&               aShape,
1222  const Standard_Integer            Trans,
1223  const Handle(TNaming_UsedShapes)& Shapes)
1224 :myTrans(Trans)
1225 {
1226   Standard_Boolean  Old = Standard_False;
1227   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1228   myNode = RS->FirstUse();
1229   SelectSameShape(myNode,Old,RS,myTrans);
1230 }
1231
1232 //=======================================================================
1233 //function : TNaming_OldShapeIterator
1234 //purpose  : 
1235 //=======================================================================
1236
1237 TNaming_OldShapeIterator::TNaming_OldShapeIterator 
1238 (const TopoDS_Shape& aShape,
1239  const Standard_Integer Trans,
1240  const TDF_Label& access)
1241 :myTrans(Trans)
1242 {
1243   Handle(TNaming_UsedShapes) Shapes;
1244   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {
1245     Standard_Boolean  Old = Standard_False;
1246     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1247     myNode = RS->FirstUse();
1248     SelectSameShape(myNode,Old,RS,myTrans);
1249   }
1250 }
1251 //=======================================================================
1252 //function : TNaming_OldShapeIterator
1253 //purpose  : 
1254 //=======================================================================
1255
1256 TNaming_OldShapeIterator::TNaming_OldShapeIterator
1257 (const TopoDS_Shape&               aShape,
1258  const Handle(TNaming_UsedShapes)& Shapes)
1259 :myTrans(-1)
1260 {  
1261   Standard_Boolean  Old = Standard_False;
1262   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1263   myNode = RS->FirstUse();
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 TDF_Label& access)
1275 :myTrans(-1)
1276 {  
1277   Handle(TNaming_UsedShapes) Shapes;
1278   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) {  
1279     Standard_Boolean  Old = Standard_False;
1280     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1281     myNode = RS->FirstUse();
1282     SelectSameShape(myNode,Old,RS,myTrans);
1283   }
1284 }
1285
1286 //=======================================================================
1287 //function : TNaming_OldShapeIterator
1288 //purpose  : 
1289 //=======================================================================
1290
1291 TNaming_OldShapeIterator::TNaming_OldShapeIterator (const TNaming_Iterator& anIterator)
1292 :myTrans(anIterator.myTrans)
1293 {
1294   Standard_Boolean Old = Standard_False;  
1295   myNode = anIterator.myNode;
1296   TNaming_RefShape* RS = myNode->myNew;
1297   if (RS == 0L) 
1298     myNode = 0L;  // No descendant
1299   else {    
1300     // il faut repartir de la premiere utilisation.
1301     myNode = RS->FirstUse();
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_OldShapeIterator& anIterator)
1312 :myTrans(anIterator.myTrans)
1313 {
1314   Standard_Boolean Old = Standard_False;  
1315   myNode = anIterator.myNode;
1316   TNaming_RefShape* RS = myNode->myOld;
1317   if (RS == 0L) 
1318     myNode = 0L;  // No descendant
1319   else  {
1320     // il faut repartir de la premiere utilisation.
1321     myNode = RS->FirstUse();
1322     SelectSameShape(myNode,Old,RS,myTrans);
1323   }
1324 }
1325
1326 //=======================================================================
1327 //function : Next
1328 //purpose  : 
1329 //=======================================================================
1330
1331 void TNaming_OldShapeIterator::Next() 
1332 {
1333   Standard_Boolean  Old = Standard_False;  
1334   TNaming_RefShape* RS  = myNode->myNew;
1335   myNode = myNode->NextSameShape(RS);
1336   SelectSameShape(myNode,Old,RS,myTrans);
1337 }
1338
1339 //=======================================================================
1340 //function : Label
1341 //purpose  : 
1342 //=======================================================================
1343
1344 TDF_Label TNaming_OldShapeIterator::Label() const
1345 {  
1346   if (myNode == 0L) Standard_NoSuchObject::Raise("TNaming_OldShapeIterator::Label");
1347   return myNode->Label();
1348   
1349 }
1350
1351 //=======================================================================
1352 //function : NamedShape
1353 //purpose  : 
1354 //=======================================================================
1355
1356 Handle(TNaming_NamedShape) TNaming_OldShapeIterator::NamedShape() const
1357 {  
1358   if (myNode == 0L) Standard_NoSuchObject::Raise("TNaming_OldShapeIterator::Label");
1359   return myNode->myAtt;
1360 }
1361 //=======================================================================
1362 //function : Shape
1363 //purpose  : 
1364 //=======================================================================
1365
1366 const TopoDS_Shape& TNaming_OldShapeIterator::Shape() const
1367 {   
1368   if(myNode == 0L) Standard_NoSuchObject::Raise("TNaming_OldShapeIterator::Shape"); 
1369   return myNode->myOld->Shape();
1370 }
1371
1372 //=======================================================================
1373 //function : IsModification
1374 //purpose  : 
1375 //=======================================================================
1376
1377 Standard_Boolean TNaming_OldShapeIterator::IsModification() const
1378 {  
1379   Standard_NoSuchObject_Raise_if(myNode == 0L,
1380                                  "TNaming_OldShapeIterator::IsModification");  
1381   return (myNode->myAtt->myEvolution == TNaming_MODIFY || 
1382           myNode->myAtt->myEvolution == TNaming_DELETE );
1383 }
1384
1385
1386 //**********************************************************************
1387 //Methods of the SameShapeIterator
1388 //**********************************************************************
1389
1390 //=======================================================================
1391 //function : 
1392 //purpose  : 
1393 //=======================================================================
1394
1395 TNaming_SameShapeIterator::TNaming_SameShapeIterator
1396 (const TopoDS_Shape& aShape,
1397  const Handle(TNaming_UsedShapes)& Shapes)
1398 {
1399   TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1400   myNode  = RS->FirstUse();
1401   myIsNew = (myNode->myNew == RS);
1402 }
1403
1404
1405 //=======================================================================
1406 //function : TNaming_SameShapeIterator
1407 //purpose  : 
1408 //=======================================================================
1409
1410 TNaming_SameShapeIterator::TNaming_SameShapeIterator
1411 (const TopoDS_Shape& aShape,
1412  const TDF_Label& access)
1413 {  
1414   Handle(TNaming_UsedShapes) Shapes;
1415   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),Shapes)) { 
1416     TNaming_RefShape* RS  = Shapes->Map().ChangeFind(aShape);
1417     myNode  = RS->FirstUse();
1418     myIsNew = (myNode->myNew == RS);
1419   }
1420 }
1421
1422 //=======================================================================
1423 //function : Next
1424 //purpose  : 
1425 //=======================================================================
1426
1427 void TNaming_SameShapeIterator::Next() 
1428 {
1429   TNaming_RefShape* prs;
1430   if (myIsNew) prs = myNode->myNew; else prs = myNode->myOld;
1431   
1432   myNode = myNode->NextSameShape(prs);
1433   if (myNode != 0L) myIsNew = (myNode->myNew == prs);
1434 }
1435
1436 //=======================================================================
1437 //function : Label
1438 //purpose  : 
1439 //=======================================================================
1440
1441 TDF_Label TNaming_SameShapeIterator::Label() const
1442 {  
1443   Standard_NoSuchObject_Raise_if(myNode == 0L,
1444                                  "TNaming_SameShapeIterator::Label");
1445   return myNode->Label();
1446 }
1447
1448
1449 //**********************************************************************
1450 //Methods of the TNaming_RefShape
1451 //**********************************************************************
1452 //=======================================================================
1453 //function : Label
1454 //purpose  : 
1455 //=======================================================================
1456
1457 TDF_Label TNaming_RefShape::Label() const
1458 {
1459   return myFirstUse->myAtt->Label();
1460 }
1461
1462 //=======================================================================
1463 //function : NamedShape
1464 //purpose  : 
1465 //=======================================================================
1466
1467 Handle(TNaming_NamedShape) TNaming_RefShape::NamedShape() const
1468 {
1469   return myFirstUse->myAtt;
1470 }
1471
1472
1473 //**********************************************************************
1474 //Methods of the TNaming_Tool class
1475 //**********************************************************************
1476
1477 //=======================================================================
1478 //function : HasLabel
1479 //purpose  : 
1480 //=======================================================================
1481
1482 Standard_Boolean TNaming_Tool::HasLabel (const TDF_Label&    access,
1483                                          const TopoDS_Shape& S)
1484 {
1485   Handle(TNaming_UsedShapes) US;
1486   if (access.Root().FindAttribute(TNaming_UsedShapes::GetID(),US)) {
1487     return (US->Map().IsBound(S));
1488   }
1489 #ifdef MDTV_DEB_HASL
1490   cout << "##==> Sub-Shape has no Label!" <<endl;
1491 #endif
1492   return Standard_False;
1493 }
1494
1495
1496 //=======================================================================
1497 //function : Label
1498 //purpose  : 
1499 //=======================================================================
1500
1501 TDF_Label TNaming_Tool::Label(const TDF_Label&    access,
1502                               const TopoDS_Shape& S,
1503                               Standard_Integer&   Trans)
1504
1505   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(access,S),"TNaming_Tool::Label"); 
1506   Handle(TNaming_UsedShapes) US;
1507   access.Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
1508   return TNaming_Tool::Label(US,S,Trans);
1509 }
1510
1511
1512 //=======================================================================
1513 //function : IsValidInTrans
1514 //purpose  : un shape est valid tant que l attribut ou il est cree est valid 
1515 //=======================================================================
1516
1517 Standard_Integer TNaming_Tool::ValidUntil (const TDF_Label& access, const TopoDS_Shape& S)
1518 {  
1519   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(access,S),"TNaming_Tool::ValidUntil"); 
1520   Handle(TNaming_UsedShapes) US;
1521   access.Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
1522   return TNaming_Tool::ValidUntil(S,US);
1523 }
1524  
1525
1526 //=======================================================================
1527 //function : HasLabel
1528 //purpose  : 
1529 //=======================================================================
1530
1531 Standard_Boolean TNaming_Tool::HasLabel(const Handle(TNaming_UsedShapes)& Shapes,
1532                                         const TopoDS_Shape&               S)
1533 {
1534   return (Shapes->Map().IsBound(S));
1535 }
1536
1537
1538 //=======================================================================
1539 //function : Label
1540 //purpose  : 
1541 //=======================================================================
1542
1543 TDF_Label TNaming_Tool::Label(const Handle(TNaming_UsedShapes)& Shapes,
1544                               const TopoDS_Shape&               S,
1545                               Standard_Integer&                 Trans)
1546 {
1547   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(Shapes,S),"TNaming_Tool::Label");
1548   TNaming_RefShape* prs = Shapes->Map().Find(S);
1549   TNaming_Node*     pdn = prs->FirstUse();
1550
1551   while (pdn != 0L && !(pdn->myNew == prs && pdn->myAtt->Evolution() != TNaming_SELECTED)){
1552     pdn = pdn->NextSameShape(prs);
1553   }
1554   if (pdn == 0L) pdn = prs->FirstUse();
1555
1556   TDF_Label      L   = pdn->Label();
1557   Trans = pdn->myAtt->Transaction();
1558   return L;
1559 }
1560 //=======================================================================
1561 //function : NamedShape
1562 //purpose  : 
1563 //=======================================================================
1564 Handle(TNaming_NamedShape) TNaming_Tool::NamedShape(const TopoDS_Shape& S,
1565                                                     const TDF_Label&    Acces) 
1566
1567   Handle(TNaming_UsedShapes) US;
1568   Acces.Root().FindAttribute(TNaming_UsedShapes::GetID(),US);
1569   Handle(TNaming_NamedShape) NS;
1570   
1571   if(!TNaming_Tool::HasLabel(US,S)) {
1572     return NS;
1573   }
1574   
1575   TNaming_RefShape* prs = US->Map().Find(S);
1576   TNaming_Node*     pdn = prs->FirstUse();
1577   TNaming_Node*     res = 0L;
1578
1579   while (pdn != 0L) {
1580     if (pdn->myNew == prs && pdn->myAtt->Evolution() != TNaming_SELECTED) {
1581       res = pdn;
1582       if (pdn->myAtt->Evolution() != TNaming_GENERATED) {
1583         // Les modifications sont privilegiees par rapport au generation.
1584         // Dans le cas des shapes qui sont a la fois des modifications et des generations
1585         // faces tangentes.
1586         break;
1587       }
1588     }
1589     pdn = pdn->NextSameShape(prs);
1590   }
1591   
1592   if (res == 0L) return NS;
1593
1594   // VERUE EN ATTENDANT DE REVOIR ABORT 03/11/98
1595   // Protection pour eviter de renvoyer un attribut backuped
1596   TDF_Label Lab = res->Label();
1597   Lab.FindAttribute(TNaming_NamedShape::GetID(),NS);
1598   return NS;
1599   //  return res->myAtt;
1600
1601
1602 //=======================================================================
1603 //function : IsValidInTrans
1604 //purpose  : un shape est valid tant que l attribut ou il est cree est valid 
1605 //=======================================================================
1606
1607 Standard_Integer TNaming_Tool::ValidUntil (const TopoDS_Shape&               S,
1608                                            const Handle(TNaming_UsedShapes)& US)
1609 {  
1610   Standard_NoSuchObject_Raise_if(!TNaming_Tool::HasLabel(US,S),"TNaming_Tool::ValidUntil"); 
1611   
1612   TNaming_RefShape* RS  = US->Map().ChangeFind(S);
1613   Standard_Integer  Cur;
1614   Standard_Integer  Until  = 0;  
1615   TNaming_Node*     Node   = RS->FirstUse();
1616
1617   while (Node != 0L) {
1618     if (Node->myNew != 0L && Node->myNew == RS) {
1619       Cur    = Node->myAtt->UntilTransaction();
1620       if (Cur > Until) Until = Cur;
1621     }
1622     Node = Node->NextSameShape(RS);
1623   }
1624   return Until;
1625 }