0025748: Parallel version of progress indicator
[occt.git] / src / Transfer / Transfer_TransferOutput.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 //szv#4 S4163
15
16 #include <Interface_EntityIterator.hxx>
17 #include <Interface_Graph.hxx>
18 #include <Interface_InterfaceModel.hxx>
19 #include <Interface_Protocol.hxx>
20 #include <Interface_ShareFlags.hxx>
21 #include <Standard_NoSuchObject.hxx>
22 #include <Standard_Transient.hxx>
23 #include <Transfer_ActorOfTransientProcess.hxx>
24 #include <Transfer_Binder.hxx>
25 #include <Transfer_TransferFailure.hxx>
26 #include <Transfer_TransferOutput.hxx>
27 #include <Transfer_TransientProcess.hxx>
28 #include <Message_ProgressScope.hxx>
29
30 Transfer_TransferOutput::Transfer_TransferOutput (const Handle(Transfer_ActorOfTransientProcess)& actor,
31                                                   const Handle(Interface_InterfaceModel)& amodel)
32 {
33   theproc  = new Transfer_TransientProcess (amodel->NbEntities());
34   theproc->SetActor(actor);
35   themodel = amodel;
36 //  thescope = Standard_False;
37 //  theundef = Transfer_UndefIgnore;
38 }
39
40 Transfer_TransferOutput::Transfer_TransferOutput (const Handle(Transfer_TransientProcess)& proc,
41                                                   const Handle(Interface_InterfaceModel)& amodel)
42 {
43   theproc  = proc;
44   themodel = amodel;
45 //  thescope = Standard_False; //szv#4:S4163:12Mar99 initialization needed
46 //  theundef = Transfer_UndefIgnore;
47 }
48
49 //Standard_Boolean&  Transfer_TransferOutput::ScopeMode ()
50 //{  return  thescope;  }
51
52 Handle(Interface_InterfaceModel)  Transfer_TransferOutput::Model () const
53 {  return themodel;  }
54
55 Handle(Transfer_TransientProcess)  Transfer_TransferOutput::TransientProcess () const
56 {  return theproc;  }
57
58 void  Transfer_TransferOutput::Transfer (const Handle(Standard_Transient)& obj,
59                                          const Message_ProgressRange& theProgress)
60 {
61   if (themodel->Number(obj) == 0) throw Transfer_TransferFailure("TransferOutput : Transfer, entities do not come from same initial model");
62 //  Standard_Integer scope = 0;
63 //  if (thescope) scope = theproc->NewScope (obj);
64
65   //:1 modified by ABV 5 Nov 97
66   //:1  if (!theproc->Transfer(obj)) return;    // auparavant, traitement Undefined
67 //  Standard_Boolean ok = 
68   theproc->Transfer ( obj, theProgress );  
69 //  if (scope > 0) theproc->EndScope (scope);
70 //  if ( ! ok ) return;                               
71
72 /*  switch (theundef) {
73     case Transfer_UndefIgnore  : return;
74     case Transfer_UndefFailure : throw Transfer_TransferFailure("TransferOutput : Transfer Undefined as Failure");
75     case Transfer_UndefContent : break; // on ne sait pas traiter ...
76     case Transfer_UndefUser    : break; // idem
77   }
78 */
79 }
80
81
82 //  Resultats :
83 //   Pour transferer tout simplement toutes les racines d'un modele d'interface
84 //   Chacune est notee "Root" dans le Process final
85
86 void Transfer_TransferOutput::TransferRoots (const Message_ProgressRange& theProgress)
87 {  TransferRoots(Interface_Protocol::Active(), theProgress);  }
88
89 void Transfer_TransferOutput::TransferRoots (const Handle(Interface_Protocol)& protocol,
90                                              const Message_ProgressRange& theProgress)
91 {
92   theproc->SetRootManagement (Standard_False);
93   Interface_ShareFlags tool(themodel,protocol);
94   Interface_EntityIterator list = tool.RootEntities();
95   Message_ProgressScope aPS(theProgress, NULL, list.NbEntities());
96   for (list.Start(); list.More() && aPS.More(); list.Next()) {
97     Handle(Standard_Transient) ent = list.Value();
98 //    Standard_Integer scope = 0;
99 //    if (thescope) scope = theproc->NewScope (ent);
100     if (theproc->Transfer (ent, aPS.Next())) theproc->SetRoot(ent);
101 //    if (scope > 0) theproc->EndScope (scope);
102   }
103 }
104
105 void Transfer_TransferOutput::TransferRoots (const Interface_Graph& G,
106                                              const Message_ProgressRange& theProgress)
107 {
108   theproc->SetRootManagement (Standard_False);
109   Interface_ShareFlags tool(G);
110   theproc->SetModel (G.Model());
111   Interface_EntityIterator list = tool.RootEntities();
112   Message_ProgressScope aPS(theProgress, NULL, list.NbEntities());
113   for (list.Start(); list.More() && aPS.More(); list.Next()) {
114     Handle(Standard_Transient) ent = list.Value();
115 //    Standard_Integer scope = 0;
116 //    if (thescope) scope = theproc->NewScope (ent);
117     if (theproc->Transfer (ent, aPS.Next())) theproc->SetRoot(ent);
118 //    if (scope > 0) theproc->EndScope (scope);
119   }
120 }
121
122
123 Interface_EntityIterator  Transfer_TransferOutput::ListForStatus (const Standard_Boolean normal,
124                                                                   const Standard_Boolean roots) const
125 {
126   Interface_EntityIterator list;
127   Standard_Integer max = (roots ? theproc->NbRoots() : theproc->NbMapped());
128   for (Standard_Integer i = 1; i <= max; i ++) {
129     const Handle(Transfer_Binder)& binder =
130       (roots ? theproc->RootItem(i) : theproc->MapItem(i));
131     if (binder.IsNull()) continue;
132     Transfer_StatusExec statex = binder->StatusExec();
133     Standard_Boolean ok =
134       (statex == Transfer_StatusInitial || statex == Transfer_StatusDone);
135     if (ok == normal) list.AddItem
136       ( (roots ? theproc->Root(i) : theproc->Mapped(i)) );
137   }
138   return list;
139 }
140
141 Handle(Interface_InterfaceModel)  Transfer_TransferOutput::ModelForStatus
142   (const Handle(Interface_Protocol)& protocol,
143    const Standard_Boolean normal, const Standard_Boolean roots) const
144 {
145   Handle(Interface_InterfaceModel) newmod;
146   if (themodel.IsNull()) return newmod;
147   newmod = themodel->NewEmptyModel();
148   Interface_EntityIterator list = ListForStatus (normal, roots);
149   for (list.Start(); list.More(); list.Next())
150     newmod->AddWithRefs (list.Value(),protocol);
151   return newmod;
152 }