0031004: Coding - eliminate warnings issued by gcc 9.1.0
[occt.git] / src / Interface / Interface_Graph.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14
15 #include <Interface_BitMap.hxx>
16 #include <Interface_EntityIterator.hxx>
17 #include <Interface_GeneralLib.hxx>
18 #include <Interface_GeneralModule.hxx>
19 #include <Interface_Graph.hxx>
20 #include <Interface_GTool.hxx>
21 #include <Interface_InterfaceModel.hxx>
22 #include <Interface_Protocol.hxx>
23 #include <Interface_ReportEntity.hxx>
24 #include <Interface_ShareTool.hxx>
25 #include <Standard_DomainError.hxx>
26 #include <Standard_Transient.hxx>
27 #include <TCollection_HAsciiString.hxx>
28 #include <TColStd_Array1OfInteger.hxx>
29 #include <TColStd_HSequenceOfTransient.hxx>
30 #include <TColStd_ListIteratorOfListOfInteger.hxx>
31
32 // Flags : 0 = Presence, 1 = Sharing Error
33 #define Graph_Present 0
34 #define Graph_ShareError 1
35
36
37 //  ###########################################################################
38
39 //  ....                           CONSTRUCTEURS                           ....
40
41 //  ....       Construction a partir de la connaissance des Entites        ....
42
43
44 Interface_Graph::Interface_Graph
45 (const Handle(Interface_InterfaceModel)& amodel,
46  const Interface_GeneralLib& /*lib*/,
47  Standard_Boolean theModeStat)
48  : themodel   (amodel), thepresents ("") 
49 {
50   if(theModeStat)
51     InitStats();
52   Evaluate();
53 }
54
55 Interface_Graph::Interface_Graph
56 (const Handle(Interface_InterfaceModel)& amodel,
57  const Handle(Interface_Protocol)& /*protocol*/,
58  Standard_Boolean theModeStat)
59  : themodel   (amodel) , thepresents ("")    
60
61 {
62  if(theModeStat)
63     InitStats();  
64   Evaluate();
65 }
66
67 Interface_Graph::Interface_Graph
68 (const Handle(Interface_InterfaceModel)& amodel,
69  const Handle(Interface_GTool)& /*gtool*/,
70  Standard_Boolean theModeStat)
71  : themodel   (amodel) , thepresents ("") 
72 {
73   if(theModeStat)
74     InitStats();
75   Evaluate();
76 }
77
78 Interface_Graph::Interface_Graph
79 (const Handle(Interface_InterfaceModel)& amodel,
80  Standard_Boolean theModeStat)
81 : themodel   (amodel) , thepresents ("")  
82 {
83   if(theModeStat)
84     InitStats();
85   Evaluate ();
86 }
87
88 //  ....                Construction depuis un autre Graph                ....
89
90 Interface_Graph::Interface_Graph
91 (const Interface_Graph& agraph, const Standard_Boolean /*copied*/)
92 : themodel   (agraph.Model()), thepresents ("") 
93 {
94   thesharings = agraph.SharingTable();
95   Standard_Integer nb = agraph.NbStatuses();
96   if(!nb)
97     return;
98   if(thestats.IsNull())
99     thestats = new TColStd_HArray1OfInteger(1,nb);
100   for (Standard_Integer i = 1; i <= nb; i ++)
101     thestats->SetValue (i,agraph.Status(i));
102   theflags.Initialize(agraph.BitMap(),Standard_True);
103 }
104
105 Interface_Graph& Interface_Graph::operator= (const Interface_Graph& theOther)
106 {
107   themodel = theOther.Model();
108   thepresents = theOther.thepresents;
109   thesharings = theOther.SharingTable();
110   thestats.Nullify();
111
112   const Standard_Integer nb = theOther.NbStatuses();
113   if (nb != 0)
114   {
115     thestats = new TColStd_HArray1OfInteger(1, nb);
116     for (Standard_Integer i = 1; i <= nb; ++i)
117     {
118       thestats->SetValue (i, theOther.Status(i));
119     }
120     theflags.Initialize (theOther.BitMap(), Standard_True);
121   }
122   return *this;
123 }
124
125 void Interface_Graph::InitStats()
126 {
127   thestats = new TColStd_HArray1OfInteger(1,themodel->NbEntities()) , 
128     theflags.Initialize(themodel->NbEntities(),2);
129   theflags.AddFlag ("ShareError");
130 }
131
132 Standard_Integer Interface_Graph::NbStatuses() const
133 {
134   return (thestats.IsNull() ? 0 : thestats->Length());
135 }
136
137 const Handle(TColStd_HArray1OfListOfInteger)& Interface_Graph::SharingTable () const
138 {  return thesharings;  }
139
140 void Interface_Graph::Evaluate()
141 {
142   //  Evaluation d un Graphe de dependances : sur chaque Entite, on prend sa
143   //  liste "Shared". On en deduit les "Sharing"  directement
144   Standard_Integer n = Size();
145   thesharings = new TColStd_HArray1OfListOfInteger(1,n);//TColStd_HArray1OfTransient(1,n);//Clear();
146   if(themodel->GTool().IsNull())
147     return;
148   
149
150   Standard_Integer i; // svv Jan11 2000 : porting on DEC
151   for (i = 1; i <= n; i ++) {
152      //    ATTENTION : Si Entite non chargee donc illisible, basculer sur son
153     //    "Contenu" equivalent
154     Handle(Standard_Transient) ent = themodel->Value(i);
155   
156
157     //    Resultat obtenu via GeneralLib
158     Interface_EntityIterator iter = GetShareds(ent);
159
160     //    Mise en forme : liste d entiers
161     for (iter.Start(); iter.More(); iter.Next()) {
162       //    num = 0 -> on sort du Model de depart, le noter "Error" et passer
163       Handle(Standard_Transient) entshare = iter.Value();
164       if(entshare == ent)
165         continue;
166
167       Standard_Integer num = EntityNumber(entshare);
168
169       if (!num )  
170       {
171         if(!thestats.IsNull())
172           theflags.SetTrue (i,Graph_ShareError);
173         continue;
174       }
175       thesharings->ChangeValue(num).Append(i);
176     }
177   }
178 }
179
180 //  ....                Construction depuis un autre Graph                ....
181
182
183 //  ###########################################################################
184
185 //  ....                ACCES UNITAIRES AUX DONNEES DE BASE                ....
186
187 void  Interface_Graph::Reset ()
188 {
189   if(!thestats.IsNull())
190   {
191     thestats.Nullify();
192     theflags.Init (Standard_False, Graph_Present);
193   }
194
195 }
196
197 void  Interface_Graph::ResetStatus ()
198
199   if(!thestats.IsNull())
200   {
201     thestats->Init(0);  
202     theflags.Init (Standard_False, Graph_Present);
203   }
204 }
205
206
207 Standard_Integer  Interface_Graph::Size () const 
208 {  return themodel->NbEntities(); }//thestats.Upper();  }
209
210 Standard_Integer  Interface_Graph::EntityNumber
211 (const Handle(Standard_Transient)& ent) const 
212 {  return themodel->Number(ent);  }
213
214 Standard_Boolean  Interface_Graph::IsPresent
215 (const Standard_Integer num) const 
216 {
217   if (num <= 0 || num > Size()) 
218     return Standard_False;
219   return (!thestats.IsNull() ? theflags.Value (num,Graph_Present) : Standard_False);
220 }
221
222 Standard_Boolean  Interface_Graph::IsPresent
223 (const Handle(Standard_Transient)& ent) const 
224 {  return IsPresent(EntityNumber(ent));  }
225
226 const Handle(Standard_Transient)&  Interface_Graph::Entity
227 (const Standard_Integer num) const 
228 {  
229   return themodel->Value(num);  
230 }
231
232
233 Standard_Integer  Interface_Graph::Status (const Standard_Integer num) const
234 {  
235   return (!thestats.IsNull() ? thestats->Value(num) : 0);  
236 }
237
238 void  Interface_Graph::SetStatus
239 (const Standard_Integer num, const Standard_Integer stat)
240 {  
241   if(!thestats.IsNull())
242     thestats->SetValue(num,stat);  
243 }
244
245 void  Interface_Graph::RemoveItem(const Standard_Integer num)
246 {
247   if(!thestats.IsNull())
248   {
249     thestats->SetValue(num,0);  
250     theflags.SetFalse (num,Graph_Present);
251   }
252 }
253
254 void  Interface_Graph::ChangeStatus
255 (const Standard_Integer oldstat, const Standard_Integer newstat)
256 {
257   if(thestats.IsNull())
258     return;
259   Standard_Integer nb = thestats->Upper();
260   for (Standard_Integer i = 1; i <= nb; i ++) {
261     if (thestats->Value(i) == oldstat) 
262       thestats->SetValue(i,newstat);
263   }
264 }
265
266 void  Interface_Graph::RemoveStatus(const Standard_Integer stat)
267 {
268   if(thestats.IsNull())
269     return;
270   Standard_Integer nb = thestats->Upper();
271   for (Standard_Integer i = 1; i <= nb; i ++) {
272     if (thestats->Value(i) == stat) RemoveItem(i);
273   }
274 }
275
276 const Interface_BitMap&  Interface_Graph::BitMap () const
277 {  return theflags;  }
278
279 Interface_BitMap&  Interface_Graph::CBitMap ()
280 {  return theflags;  }
281
282 //  ###########################################################################
283
284 //  ....      Chargements Elementaires avec Propagation de "Share"      .... //
285
286 const Handle(Interface_InterfaceModel)&  Interface_Graph::Model() const 
287 {  return themodel;  }
288
289 void  Interface_Graph::GetFromModel ()
290 {
291   if (themodel.IsNull() || thestats.IsNull()) 
292     return;    // no model ... (-> on n ira pas loin)
293   theflags.Init (Standard_True,Graph_Present);
294   thestats->Init (0);
295 }
296
297 void  Interface_Graph::GetFromEntity
298 (const Handle(Standard_Transient)& ent, const Standard_Boolean shared,
299  const Standard_Integer newstat)
300 {
301   if(thestats.IsNull())
302     return;
303   Standard_Integer num = EntityNumber(ent);
304   if (!num ) 
305     return;
306   if (theflags.CTrue(num,Graph_Present)) return;  // deja pris : on passe
307   thestats->SetValue(num,newstat);
308   if (!shared) return;
309   //  Attention a la redefinition !
310   Interface_EntityIterator aIter = GetShareds(ent);
311
312   for ( ; aIter.More() ; aIter.Next())    
313     GetFromEntity(aIter.Value(),Standard_True,newstat);
314 }
315
316 void  Interface_Graph::GetFromEntity
317 (const Handle(Standard_Transient)& ent, const Standard_Boolean shared,
318  const Standard_Integer newstat, const Standard_Integer overlapstat,
319  const Standard_Boolean cumul)
320 {
321   if(thestats.IsNull())
322     return;
323   Standard_Integer num   = EntityNumber(ent);
324   if (!num ) return;
325   Standard_Boolean pasla = !theflags.CTrue (num,Graph_Present);
326   Standard_Integer stat  = thestats->Value(num); 
327
328   if (pasla) {
329     ///    theflags.SetTrue (num, Graph_Present);   // nouveau : noter avec newstat
330     thestats->SetValue(num,newstat);
331   } else {
332     Standard_Integer overstat = stat;
333     if (stat != newstat) {                   // deja pris, meme statut : passer
334       if (cumul) overstat += overlapstat;    // nouveau statut : avec cumul ...
335       else       overstat  = overlapstat;    // ... ou sans (statut force)
336       if (stat != overstat)                  // si repasse deja faite, passer
337         thestats->SetValue(num,overstat);
338     }
339   }
340   if (!shared) return;
341   //  Attention a la redefinition !
342   Interface_EntityIterator aIter = GetShareds(ent);
343
344   for ( ; aIter.More() ; aIter.Next())    
345     GetFromEntity(aIter.Value(),Standard_True,newstat);
346 }
347
348 void  Interface_Graph::GetFromIter
349 (const Interface_EntityIterator& iter, const Standard_Integer newstat)
350 {
351    if(thestats.IsNull())
352     return;
353   for (iter.Start(); iter.More(); iter.Next()) {
354     Handle(Standard_Transient) ent = iter.Value();
355     Standard_Integer num = EntityNumber(ent);
356     if (!num) 
357       continue;
358     if (theflags.CTrue(num,Graph_Present)) 
359       continue;
360     thestats->SetValue(num,newstat);
361   }
362 }
363
364
365 void  Interface_Graph::GetFromIter
366 (const Interface_EntityIterator& iter,
367  const Standard_Integer newstat, const Standard_Integer overlapstat,
368  const Standard_Boolean cumul)
369 {
370   if(thestats.IsNull())
371     return;
372   for (iter.Start(); iter.More(); iter.Next()) {
373     Handle(Standard_Transient) ent = iter.Value();
374     Standard_Integer num   = EntityNumber(ent);
375     if (!num) 
376       continue;
377     /*Standard_Boolean pasla = !*/theflags.Value(num,Graph_Present);
378     /*Standard_Integer stat  = */thestats->Value(num); 
379     GetFromEntity (ent,Standard_False,newstat,overlapstat,cumul);
380   }
381 }
382
383
384 void Interface_Graph::GetFromGraph (const Interface_Graph& agraph)
385 {
386   if (Model() != agraph.Model()) throw Standard_DomainError("Graph from Interface : GetFromGraph");
387   Standard_Integer nb = Size();
388   for (Standard_Integer i = 1; i <= nb; i ++) {
389     if (agraph.IsPresent(i))
390       GetFromEntity (agraph.Entity(i),Standard_False,agraph.Status(i));
391   }
392 }
393
394 void Interface_Graph::GetFromGraph
395 (const Interface_Graph& agraph, const Standard_Integer stat)
396 {
397   if (Model() != agraph.Model()) throw Standard_DomainError("Graph from Interface : GetFromGraph");
398   Standard_Integer nb = Size();
399   for (Standard_Integer i = 1; i <= nb; i ++) {
400     if (agraph.IsPresent(i) && agraph.Status(i) == stat)
401       GetFromEntity (agraph.Entity(i),Standard_False,stat);
402   }
403 }
404
405 //  #####################################################################
406
407 //  ....                Listage des Entites Partagees                ....
408
409 Standard_Boolean Interface_Graph::HasShareErrors
410 (const Handle(Standard_Transient)& ent) const
411 {
412   if(thestats.IsNull())
413     return Standard_False;
414   Standard_Integer num   = EntityNumber(ent);
415   if (num == 0) return Standard_True;
416   return theflags.Value (num,Graph_ShareError);
417 }
418
419 Interface_EntityIterator Interface_Graph::Shareds
420 (const Handle(Standard_Transient)& ent) const
421 {
422   Interface_EntityIterator iter;
423   Standard_Integer num   = EntityNumber(ent);
424   if(!num)
425     return iter;
426
427   Handle(Standard_Transient) aCurEnt =  ent;
428   if (themodel->IsRedefinedContent(num)) 
429      aCurEnt = themodel->ReportEntity(num)->Content();
430
431   //if (num == 0)  throw Standard_DomainError("Interface : Shareds");
432   Handle(Interface_GeneralModule) module;
433   Standard_Integer CN;
434   if (themodel->GTool()->Select(aCurEnt,module,CN))  
435     module->FillShared(themodel,CN,aCurEnt,iter);
436   return iter;
437 }
438
439 Handle(TColStd_HSequenceOfTransient) Interface_Graph::GetShareds(const Handle(Standard_Transient)& ent) const
440 {
441   Handle(TColStd_HSequenceOfTransient) aseq = new TColStd_HSequenceOfTransient;
442   Interface_EntityIterator iter = Shareds(ent);
443   for( ; iter.More(); iter.Next())
444     aseq->Append(iter.Value());
445   return aseq;
446 }
447
448 Handle(TColStd_HSequenceOfTransient) Interface_Graph::GetSharings(const Handle(Standard_Transient)& ent) const
449 {
450   Standard_Integer num   = EntityNumber(ent);
451   if(!num)
452     return 0;
453   //return Handle(TColStd_HSequenceOfTransient)::DownCast(thesharings->Value(num));
454   const TColStd_ListOfInteger& alist = thesharings->Value(num);
455   Handle(TColStd_HSequenceOfTransient) aSharings = new TColStd_HSequenceOfTransient;
456   TColStd_ListIteratorOfListOfInteger aIt(alist);
457   for( ; aIt.More() ; aIt.Next())
458     aSharings->Append(Entity(aIt.Value()));
459   return aSharings;
460 }
461
462 Interface_EntityIterator Interface_Graph::Sharings
463 (const Handle(Standard_Transient)& ent) const
464 {
465   Interface_EntityIterator iter;
466   iter.AddList(GetSharings(ent));
467   return iter;
468
469 }
470
471 static void AddTypedSharings
472 (const Handle(Standard_Transient)& ent, const Handle(Standard_Type)& type,
473  Interface_EntityIterator& iter, const Standard_Integer n,
474  const Interface_Graph& G)
475 {
476   if (ent.IsNull()) return;
477   if (ent->IsKind(type))  {  iter.AddItem (ent);  return;  }
478   if (iter.NbEntities() > n) return;
479
480   Handle(TColStd_HSequenceOfTransient) list = G.GetSharings(ent);
481   if(list.IsNull())
482     return;
483
484   Standard_Integer nb = list->Length();
485   for (Standard_Integer i = 1; i <= nb; i ++)
486     AddTypedSharings (list->Value(i) ,type,iter,nb,G);
487 }
488
489 Interface_EntityIterator Interface_Graph::TypedSharings
490 (const Handle(Standard_Transient)& ent, const Handle(Standard_Type)& type) const
491 {
492   Interface_EntityIterator iter;
493   Standard_Integer n = Size();
494   AddTypedSharings (ent,type,iter,n,*this);
495   return iter;
496 }
497
498
499 Interface_EntityIterator Interface_Graph::RootEntities () const
500 {
501   Interface_EntityIterator iter;
502   Standard_Integer nb = thesharings->Length();
503   for (Standard_Integer i = 1; i <= nb; i ++) {
504     if(!thesharings->Value(i).IsEmpty())
505       continue;
506     iter.AddItem(Entity(i));
507   }
508   return iter;
509 }
510
511 Handle(TCollection_HAsciiString)  Interface_Graph::Name(const Handle(Standard_Transient)& ent) const
512 {
513   Handle(TCollection_HAsciiString) str;
514   if (themodel.IsNull()) return str;
515   if (themodel->Number(ent)) return str;
516
517   Handle(Interface_GTool) gtool = themodel->GTool();
518   if (gtool.IsNull()) return str;
519
520   Handle(Interface_GeneralModule) module;
521   Standard_Integer CN;
522   if (!gtool->Select(ent,module,CN)) return str;
523
524   Interface_ShareTool sht (*this);
525   return module->Name (CN,ent,sht);
526 }
527
528 Standard_Boolean Interface_Graph::ModeStat() const
529 {
530   return (!thestats.IsNull());
531 }