0025748: Parallel version of progress indicator
[occt.git] / src / TransferBRep / TransferBRep_Reader.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 <BRep_Builder.hxx>
16 #include <Interface_CheckIterator.hxx>
17 #include <Interface_CheckTool.hxx>
18 #include <Interface_InterfaceModel.hxx>
19 #include <Interface_Macros.hxx>
20 #include <Interface_Protocol.hxx>
21 #include <Message_Messenger.hxx>
22 #include <Message_ProgressScope.hxx>
23 #include <Standard_OutOfRange.hxx>
24 #include <Standard_Transient.hxx>
25 #include <TopoDS_Compound.hxx>
26 #include <TopoDS_Shape.hxx>
27 #include <Transfer_ActorOfTransientProcess.hxx>
28 #include <Transfer_TransferOutput.hxx>
29 #include <Transfer_TransientProcess.hxx>
30 #include <TransferBRep.hxx>
31 #include <TransferBRep_Reader.hxx>
32
33 TransferBRep_Reader::TransferBRep_Reader ()
34     : theDone (Standard_False) , theFilest (0) , theNewpr (Standard_False)
35       {    theShapes = new TopTools_HSequenceOfShape();  theTransi = new TColStd_HSequenceOfTransient();  }
36
37     void  TransferBRep_Reader::SetProtocol
38   (const Handle(Interface_Protocol)& protocol)
39       {  theProto = protocol;  }
40
41     Handle(Interface_Protocol)  TransferBRep_Reader::Protocol () const
42       {  return theProto;  }
43
44     void  TransferBRep_Reader::SetActor
45   (const Handle(Transfer_ActorOfTransientProcess)& actor)
46       {  theActor = actor;  }
47
48     Handle(Transfer_ActorOfTransientProcess) TransferBRep_Reader::Actor () const
49       {  return theActor;  }
50
51     void  TransferBRep_Reader::SetFileStatus (const Standard_Integer status)
52       {  theFilest = status;  }
53
54     Standard_Integer  TransferBRep_Reader::FileStatus () const
55       { return theFilest;  }
56
57     Standard_Boolean  TransferBRep_Reader::FileNotFound () const
58       {  return (theFilest < 0);  }
59
60     Standard_Boolean  TransferBRep_Reader::SyntaxError () const
61       {  return (theFilest > 0);  }
62
63
64     void  TransferBRep_Reader::SetModel
65   (const Handle(Interface_InterfaceModel)& model)
66 {
67   theModel = model;
68   Clear();
69 }
70
71     Handle(Interface_InterfaceModel)  TransferBRep_Reader::Model () const
72       {  return theModel;  }
73
74
75     void  TransferBRep_Reader::Clear ()
76 {
77   theDone = Standard_False;
78   theShapes->Clear();  theTransi->Clear();
79 }
80
81     Standard_Boolean  TransferBRep_Reader::CheckStatusModel
82   (const Standard_Boolean withprint) const
83 {
84   Interface_CheckTool cht (theModel,theProto);
85   Interface_CheckIterator chl = cht.CompleteCheckList();
86   if (withprint
87   && !theProc.IsNull()
88   && !theProc->Messenger().IsNull())
89   {
90     Message_Messenger::StreamBuffer aBuffer = theProc->Messenger()->SendInfo();
91     chl.Print (aBuffer, theModel, Standard_False);
92   }
93   return chl.IsEmpty(Standard_True);
94 }
95
96     Interface_CheckIterator  TransferBRep_Reader::CheckListModel () const
97 {
98   Interface_CheckTool cht (theModel,theProto);
99   Interface_CheckIterator chl = cht.CompleteCheckList();
100   return chl;
101 }
102
103     Standard_Boolean&  TransferBRep_Reader::ModeNewTransfer ()
104       {  return theNewpr;  }
105
106     Standard_Boolean  TransferBRep_Reader::BeginTransfer ()
107 {
108   theDone = Standard_False;
109   if (theModel.IsNull()) return Standard_False;
110
111   if (theNewpr || theProc.IsNull())
112     theProc = new Transfer_TransientProcess (theModel->NbEntities());
113   else theProc->Clear();
114   theProc->SetErrorHandle(Standard_True);
115   theProc->SetModel (theModel);
116   PrepareTransfer();
117   theProc->SetActor (theActor);
118   return Standard_True;
119 }
120
121     void  TransferBRep_Reader::EndTransfer ()
122 {
123   theShapes->Append ( TransferBRep::Shapes (theProc,Standard_True) );
124   Standard_Integer i,nb = theProc->NbRoots();
125   for (i = 1; i <= nb; i ++) {
126     Handle(Standard_Transient) ent = theProc->Root(i);
127     Handle(Standard_Transient) res = theProc->FindTransient(ent);
128     if (!res.IsNull()) theTransi->Append (res);
129   }
130   theDone = Standard_True;
131 }
132
133
134     void  TransferBRep_Reader::PrepareTransfer ()    {  }
135
136     void  TransferBRep_Reader::TransferRoots (const Message_ProgressRange& theProgress)
137 {
138   Clear();
139   if (!BeginTransfer()) return;
140   Transfer_TransferOutput TP (theProc,theModel);
141
142   TP.TransferRoots(theProto, theProgress);
143   EndTransfer();
144 }
145
146     Standard_Boolean TransferBRep_Reader::Transfer (const Standard_Integer num,
147                                                     const Message_ProgressRange& theProgress)
148 {
149   if (!BeginTransfer()) return Standard_False;
150   if (num <= 0 || num > theModel->NbEntities()) return Standard_False;
151   Handle(Standard_Transient) ent = theModel->Value(num);
152   Transfer_TransferOutput TP (theProc,theModel);
153
154   if (theProc->TraceLevel() > 1) {
155     Message_Messenger::StreamBuffer sout = theProc->Messenger()->SendInfo();
156     sout<<"--  Transfer(Read) : ";  
157     theModel->Print (ent, sout);
158     sout<<std::endl;
159   }
160   TP.Transfer(ent, theProgress);
161   theProc->SetRoot(ent);
162   EndTransfer();
163   return Standard_True;
164 }
165
166     void  TransferBRep_Reader::TransferList
167   (const Handle(TColStd_HSequenceOfTransient)& list,
168    const Message_ProgressRange& theProgress)
169 {
170   if (!BeginTransfer()) return;
171   if (list.IsNull()) return;
172   Transfer_TransferOutput TP (theProc,theModel);
173   Standard_Integer i, nb = list->Length();
174   Message_Messenger::StreamBuffer sout = theProc->Messenger()->SendInfo();
175
176   if (theProc->TraceLevel() > 1) 
177     sout<<"--  Transfer(Read-List) : "<<nb<<" Items"<<std::endl;
178   Message_ProgressScope aPS(theProgress, NULL, nb);
179   for (i = 1; i <= nb && aPS.More(); i++) {
180     Message_ProgressRange aRange = aPS.Next();
181     Handle(Standard_Transient) ent = list->Value(i);
182     if (theModel->Number(ent) == 0) continue;
183
184     if (theProc->TraceLevel() > 1) 
185     {
186       sout<<"--  Transfer(Read-List), Item "<<i<<" : ";
187       theModel->Print (ent, sout);
188       sout<<std::endl;
189     }
190     TP.Transfer (ent, aRange);
191     theProc->SetRoot(ent);
192   }
193   EndTransfer();
194 }
195
196     Standard_Boolean  TransferBRep_Reader::IsDone () const
197       {  return theDone;  }
198
199 //   ######    RESULTAT : SHAPES    ######
200
201     Standard_Integer  TransferBRep_Reader::NbShapes () const
202       {  return theShapes->Length();  }
203
204     Handle(TopTools_HSequenceOfShape)  TransferBRep_Reader::Shapes () const
205       {  return theShapes;  }
206
207     const TopoDS_Shape&  TransferBRep_Reader::Shape
208   (const Standard_Integer num) const
209       {  return theShapes->Value(num);  }
210
211     TopoDS_Shape  TransferBRep_Reader::OneShape () const
212 {
213   TopoDS_Shape res;
214   Standard_Integer nb = theShapes->Length();
215   if (nb == 0) return res;
216   else if (nb == 1) return theShapes->Value(1);
217   else {
218     TopoDS_Compound C;
219     BRep_Builder B;
220     B.MakeCompound(C);
221     for (Standard_Integer i = 1; i <= nb; i ++)  B.Add (C,theShapes->Value(i));
222     return C;
223   }
224 }
225
226     TopoDS_Shape  TransferBRep_Reader::ShapeResult
227   (const Handle(Standard_Transient)& ent) const
228       {  return TransferBRep::ShapeResult (theProc,ent);  }
229
230 //   ######    RESULTAT : TRANSIENTS    ######
231
232     Standard_Integer  TransferBRep_Reader::NbTransients () const
233       {  return theTransi->Length();  }
234
235     Handle(TColStd_HSequenceOfTransient)  TransferBRep_Reader::Transients () const
236       {  return theTransi;  }
237
238     Handle(Standard_Transient)  TransferBRep_Reader::Transient
239   (const Standard_Integer num) const
240       {  return theTransi->Value(num);  }
241
242
243 //   ######    CHECKS    ######
244
245     Standard_Boolean  TransferBRep_Reader::CheckStatusResult
246   (const Standard_Boolean withprint) const
247 {
248   Interface_CheckIterator chl;
249   if (!theProc.IsNull()) chl = theProc->CheckList(Standard_False);
250   if (withprint
251   && !theProc.IsNull()
252   && !theProc->Messenger().IsNull())
253   {
254     Message_Messenger::StreamBuffer aBuffer = theProc->Messenger()->SendInfo();
255     chl.Print (aBuffer, theModel, Standard_False);
256   }
257   return chl.IsEmpty(Standard_True);
258 }
259
260     Interface_CheckIterator  TransferBRep_Reader::CheckListResult () const
261 {
262   if (!theProc.IsNull()) return theProc->CheckList(Standard_False);
263   Interface_CheckIterator chbid;  return chbid;
264 }
265
266     Handle(Transfer_TransientProcess)  TransferBRep_Reader::TransientProcess
267   () const
268       {  return theProc;  }
269
270 TransferBRep_Reader::~TransferBRep_Reader()
271 {}
272