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