7fd59977 |
1 | #include <XSControl_Utils.ixx> |
2 | #include <Message_Messenger.hxx> |
3 | #include <Message.hxx> |
4 | #include <Interface_Macros.hxx> |
5 | #include <Interface_MSG.hxx> |
6 | |
7 | #include <TColStd_HSequenceOfAsciiString.hxx> |
8 | #include <TColStd_HSequenceOfExtendedString.hxx> |
9 | #include <TColStd_HArray1OfTransient.hxx> |
10 | #include <Interface_HArray1OfHAsciiString.hxx> |
11 | |
12 | #include <TransferBRep.hxx> |
13 | #include <TransferBRep_ShapeBinder.hxx> |
14 | #include <TransferBRep_ShapeMapper.hxx> |
15 | #include <TopoDS_HShape.hxx> |
16 | #include <TopoDS.hxx> |
17 | #include <TopoDS_Wire.hxx> |
18 | #include <TopoDS_Shell.hxx> |
19 | #include <TopoDS_Compound.hxx> |
20 | #include <TopoDS_Iterator.hxx> |
21 | #include <TopExp_Explorer.hxx> |
22 | #include <Transfer_SimpleBinderOfTransient.hxx> |
23 | |
24 | #include <BRep_Builder.hxx> |
25 | #include <BRepTools.hxx> |
26 | |
27 | |
28 | static TCollection_AsciiString bufasc; |
29 | static TCollection_ExtendedString bufext; |
30 | static const Standard_ExtString voidext = { 0 }; |
31 | |
32 | |
33 | XSControl_Utils::XSControl_Utils () { } |
34 | |
35 | // ######################################################### |
36 | // ####### Fonctions de TRACE ####### |
37 | |
38 | void XSControl_Utils::TraceLine (const Standard_CString line) const |
39 | { |
40 | Handle(Message_Messenger) sout = Message::DefaultMessenger(); |
41 | sout<<line<<endl; |
42 | } |
43 | |
44 | void XSControl_Utils::TraceLines (const Handle(Standard_Transient)& lines) const |
45 | { |
46 | Handle(Message_Messenger) sout = Message::DefaultMessenger(); |
47 | Standard_Integer i,nb; |
48 | DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,lines); |
49 | if (!linha.IsNull()) { |
50 | nb = linha->Length(); |
51 | for (i = 1; i <= nb; i ++) |
52 | if (!linha->Value(i).IsNull()) sout<<linha->Value(i)->ToCString()<<endl; |
53 | return; |
54 | } |
55 | DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,lines); |
56 | if (!lina.IsNull()) { |
57 | nb = lina->Length(); |
58 | for (i = 1; i <= nb; i ++) |
59 | sout<<lina->Value(i).ToCString()<<endl; |
60 | return; |
61 | } |
62 | DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,lines); |
63 | if (!linhe.IsNull()) { |
64 | nb = linhe->Length(); |
65 | for (i = 1; i <= nb; i ++) |
66 | if (!linhe->Value(i).IsNull()) |
67 | sout << linhe->Value(i) << endl; |
68 | return; |
69 | } |
70 | DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,lines); |
71 | if (!linee.IsNull()) { |
72 | nb = linee->Length(); |
73 | for (i = 1; i <= nb; i ++) |
74 | sout << linee->Value(i) << endl; |
75 | return; |
76 | } |
77 | DeclareAndCast(TCollection_HAsciiString,lin1a,lines); |
78 | if (!lin1a.IsNull()) sout<<lin1a; |
79 | DeclareAndCast(TCollection_HExtendedString,lin1e,lines); |
80 | if (!lin1e.IsNull()) sout<<lin1e; |
81 | } |
82 | |
83 | |
84 | // ######################################################### |
85 | // ####### TRANSIENT : Quelques acces de base ####### |
86 | |
87 | Standard_Boolean XSControl_Utils::IsKind |
88 | (const Handle(Standard_Transient)& item, const Handle(Standard_Type)& what) const |
89 | { |
90 | if (item.IsNull()) return Standard_False; |
91 | if (what.IsNull()) return Standard_False; |
92 | return item->IsKind(what); |
93 | } |
94 | |
95 | Standard_CString XSControl_Utils::TypeName |
96 | (const Handle(Standard_Transient)& item, const Standard_Boolean nopk) const |
97 | { |
98 | if (item.IsNull()) return ""; |
99 | DeclareAndCast(Standard_Type,atype,item); |
100 | if (atype.IsNull()) atype = item->DynamicType(); |
101 | Standard_CString tn = atype->Name(); |
102 | if (!nopk) return tn; |
103 | for (int i = 0; tn[i] != '\0'; i ++) { |
104 | if (tn[i] == '_') return &tn[i+1]; |
105 | } |
106 | return tn; |
107 | } |
108 | |
109 | |
110 | // ####### TRANSIENT : Fonctions de liste ####### |
111 | |
112 | Handle(Standard_Transient) XSControl_Utils::TraValue |
113 | (const Handle(Standard_Transient)& seqval, const Standard_Integer num) const |
114 | { |
115 | Handle(Standard_Transient) val; |
116 | if (num < 1) return val; |
117 | if (seqval.IsNull()) return val; |
118 | DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval); |
119 | if (!seqs.IsNull()) |
120 | { if (num <= seqs->Length()) val = seqs->Value(num); return val; } |
121 | DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval); |
122 | if (!seqt.IsNull()) |
123 | { if (num <= seqt->Length()) val = seqt->Value(num); return val; } |
124 | // Standard_TypeMismatch::Raise("XSControl_Utils::SeqTraValue"); |
125 | return val; |
126 | } |
127 | |
128 | Handle(TColStd_HSequenceOfTransient) XSControl_Utils::NewSeqTra () const |
129 | { return new TColStd_HSequenceOfTransient(); } |
130 | |
131 | void XSControl_Utils::AppendTra |
132 | (const Handle(TColStd_HSequenceOfTransient)& seqval, |
133 | const Handle(Standard_Transient)& traval) const |
134 | { seqval->Append (traval); } |
135 | |
136 | |
137 | // ####### DATES ####### |
138 | |
139 | Standard_CString XSControl_Utils::DateString |
140 | (const Standard_Integer yy, const Standard_Integer mm, |
141 | const Standard_Integer dd, const Standard_Integer hh, |
142 | const Standard_Integer mn, const Standard_Integer ss) const |
143 | { |
144 | char ladate[50]; |
145 | Interface_MSG::TDate (ladate, yy,mm,dd,hh,mn,ss); |
146 | bufasc.Clear(); bufasc.AssignCat(ladate); |
147 | return bufasc.ToCString(); |
148 | } |
149 | |
150 | void XSControl_Utils::DateValues |
151 | (const Standard_CString text, |
152 | Standard_Integer& yy, Standard_Integer& mm, Standard_Integer& dd, |
153 | Standard_Integer& hh, Standard_Integer& mn, Standard_Integer& ss) const |
154 | { Interface_MSG::NDate (text, yy,mm,dd,hh,mn,ss); } |
155 | |
156 | |
157 | // ########################################################## |
158 | // ####### STRING : Ascii de base ####### |
159 | |
160 | Standard_CString XSControl_Utils::ToCString |
161 | (const Handle(TCollection_HAsciiString)& strval) const |
162 | { |
163 | //JR/Hp |
164 | Standard_CString astr = (Standard_CString ) (strval.IsNull() ? "" : strval->ToCString()); |
165 | return astr ; |
166 | // return (strval.IsNull() ? "" : strval->ToCString()); |
167 | } |
168 | |
169 | Standard_CString XSControl_Utils::ToCString |
170 | (const TCollection_AsciiString& strval) const |
171 | { return strval.ToCString(); } |
172 | |
173 | Handle(TCollection_HAsciiString) XSControl_Utils::ToHString |
174 | (const Standard_CString strcon) const |
175 | { return new TCollection_HAsciiString(strcon); } |
176 | |
177 | TCollection_AsciiString XSControl_Utils::ToAString |
178 | (const Standard_CString strcon) const |
179 | { return TCollection_AsciiString(strcon); } |
180 | |
181 | // ####### STRING : Extended de base ####### |
182 | |
183 | Standard_ExtString XSControl_Utils::ToEString |
184 | (const Handle(TCollection_HExtendedString)& strval) const |
185 | { return (strval.IsNull() ? voidext : strval->ToExtString()); } |
186 | |
187 | Standard_ExtString XSControl_Utils::ToEString |
188 | (const TCollection_ExtendedString& strval) const |
189 | { return strval.ToExtString(); } |
190 | |
191 | Handle(TCollection_HExtendedString) XSControl_Utils::ToHString |
192 | (const Standard_ExtString strcon) const |
193 | { return new TCollection_HExtendedString(strcon); } |
194 | |
195 | TCollection_ExtendedString XSControl_Utils::ToXString |
196 | (const Standard_ExtString strcon) const |
197 | { return TCollection_ExtendedString(strcon); } |
198 | |
199 | // ####### STRING : Ascii <-> Extended ####### |
200 | |
201 | Standard_ExtString XSControl_Utils::AsciiToExtended (const Standard_CString str) const |
202 | { |
203 | bufext.Clear(); bufext = TCollection_ExtendedString (str); |
204 | return bufext.ToExtString(); |
205 | } |
206 | |
207 | Standard_Boolean XSControl_Utils::IsAscii (const Standard_ExtString str) const |
208 | { |
209 | bufext.Clear(); bufext.AssignCat (str); |
210 | return bufext.IsAscii(); |
211 | } |
212 | |
213 | Standard_CString XSControl_Utils::ExtendedToAscii (const Standard_ExtString str) const |
214 | { |
215 | bufext.Clear(); bufext.AssignCat (str); bufasc.Clear(); |
216 | Standard_Integer i, nb = bufext.Length(); |
217 | for (i = 1; i <= nb; i ++) { |
218 | int unext = bufext.Value(i); |
219 | unext = unext & 127; |
220 | char uncar = char(unext); |
221 | bufasc.AssignCat (uncar); |
222 | } |
223 | return bufasc.ToCString(); |
224 | } |
225 | |
226 | // ####### STRING : LISTES ####### |
227 | |
228 | Standard_CString XSControl_Utils::CStrValue |
229 | (const Handle(Standard_Transient)& list, const Standard_Integer num) const |
230 | { |
231 | DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,list); |
232 | if (!linha.IsNull()) { |
233 | //JR/Hp |
234 | Standard_CString astr = (Standard_CString ) |
235 | (num > linha->Length() ? "" : linha->Value(num)->ToCString()); |
236 | return astr ; |
237 | // return (num > linha->Length() ? "" : linha->Value(num)->ToCString()); |
238 | } |
239 | |
240 | DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,list); |
241 | if (!lina.IsNull()) { |
242 | //JR/Hp |
243 | Standard_CString astr = (Standard_CString ) |
244 | (num > lina->Length() ? "" : lina->Value(num).ToCString()); |
245 | return astr ; |
246 | // return (num > lina->Length() ? "" : lina->Value(num).ToCString()); |
247 | } |
248 | |
249 | DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,list); |
250 | if (!linhe.IsNull()) { |
251 | //JR/Hp |
252 | Standard_CString astr = (Standard_CString ) |
253 | (num > linhe->Length() ? "" : ExtendedToAscii(linhe->Value(num)->ToExtString())); |
254 | return astr ; |
255 | // return (num > linhe->Length() ? "" : ExtendedToAscii(linhe->Value(num)->ToExtString())); |
256 | } |
257 | |
258 | DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,list); |
259 | if (!linee.IsNull()) { |
260 | //JR/Hp |
261 | Standard_CString astr = (Standard_CString ) |
262 | (num > linee->Length() ? "" : ExtendedToAscii(linee->Value(num).ToExtString())); |
263 | return astr ; |
264 | // return (num > linee->Length() ? "" : ExtendedToAscii(linee->Value(num).T |
265 | } |
266 | |
267 | DeclareAndCast(TCollection_HAsciiString,lin1a,list); |
268 | if (!lin1a.IsNull()) return lin1a->ToCString(); |
269 | DeclareAndCast(TCollection_HExtendedString,lin1e,list); |
270 | if (!lin1e.IsNull()) return ExtendedToAscii(lin1e->ToExtString()); |
271 | return ""; |
272 | } |
273 | |
274 | |
275 | Standard_ExtString XSControl_Utils::EStrValue |
276 | (const Handle(Standard_Transient)& list, const Standard_Integer num) const |
277 | { |
278 | DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,list); |
279 | if (!linha.IsNull()) return |
280 | (num > linha->Length() ? voidext : AsciiToExtended(linha->Value(num)->ToCString())); |
281 | |
282 | DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,list); |
283 | if (!lina.IsNull()) |
284 | (num > lina->Length() ? voidext : AsciiToExtended(lina->Value(num).ToCString())); |
285 | |
286 | DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,list); |
287 | if (!linhe.IsNull()) return |
288 | (num > linhe->Length() ? voidext : linhe->Value(num)->ToExtString()); |
289 | |
290 | DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,list); |
291 | if (!linee.IsNull()) return |
292 | (num > linee->Length() ? voidext : linee->Value(num).ToExtString()); |
293 | |
294 | DeclareAndCast(TCollection_HAsciiString,lin1a,list); |
295 | if (!lin1a.IsNull()) return AsciiToExtended(lin1a->ToCString()); |
296 | DeclareAndCast(TCollection_HExtendedString,lin1e,list); |
297 | if (!lin1e.IsNull()) return lin1e->ToExtString(); |
298 | return voidext; |
299 | } |
300 | |
301 | Handle(TColStd_HSequenceOfHAsciiString) XSControl_Utils::NewSeqCStr () const |
302 | { return new TColStd_HSequenceOfHAsciiString(); } |
303 | |
304 | void XSControl_Utils::AppendCStr |
305 | (const Handle(TColStd_HSequenceOfHAsciiString)& seqval, |
306 | const Standard_CString strval) const |
307 | { seqval->Append (new TCollection_HAsciiString(strval)); } |
308 | |
309 | Handle(TColStd_HSequenceOfHExtendedString) XSControl_Utils::NewSeqEStr () const |
310 | { return new TColStd_HSequenceOfHExtendedString(); } |
311 | |
312 | void XSControl_Utils::AppendEStr |
313 | (const Handle(TColStd_HSequenceOfHExtendedString)& seqval, |
314 | const Standard_ExtString strval) const |
315 | { seqval->Append (new TCollection_HExtendedString(strval)); } |
316 | |
317 | |
318 | // ########################################################## |
319 | // ####### SHAPES : Acces de base ####### |
320 | |
321 | Standard_Boolean XSControl_Utils::WriteShape |
322 | (const TopoDS_Shape& shape, |
323 | const Standard_CString filename) const |
324 | { return BRepTools::Write (shape,filename); } |
325 | |
326 | TopoDS_Shape XSControl_Utils::NewShape () const |
327 | { TopoDS_Shape shape; return shape; } |
328 | |
329 | Standard_Boolean XSControl_Utils::ReadShape |
330 | (TopoDS_Shape& shape, |
331 | const Standard_CString filename) const |
332 | { |
333 | BRep_Builder B; |
334 | return BRepTools::Read (shape,filename,B); |
335 | } |
336 | |
337 | Standard_Boolean XSControl_Utils::IsNullShape (const TopoDS_Shape& shape) const |
338 | { return shape.IsNull(); } |
339 | |
340 | |
341 | TopoDS_Shape XSControl_Utils::CompoundFromSeq |
342 | (const Handle(TopTools_HSequenceOfShape)& seqval) const |
343 | { |
344 | BRep_Builder B; |
345 | TopoDS_Compound C; |
346 | B.MakeCompound(C); |
347 | Standard_Integer i,n = seqval->Length(); |
348 | for (i = 1; i <= n ; i ++) B.Add(C,seqval->Value(i)); |
349 | return C; |
350 | } |
351 | |
352 | TopAbs_ShapeEnum XSControl_Utils::ShapeType |
353 | (const TopoDS_Shape& shape, const Standard_Boolean compound) const |
354 | { |
355 | if (shape.IsNull()) return TopAbs_SHAPE; |
356 | TopAbs_ShapeEnum res = shape.ShapeType(); |
357 | if (!compound || res != TopAbs_COMPOUND) return res; |
358 | res = TopAbs_SHAPE; |
359 | for (TopoDS_Iterator iter(shape); iter.More(); iter.Next()) { |
360 | TopoDS_Shape sh = iter.Value(); |
361 | if (sh.IsNull()) continue; |
362 | TopAbs_ShapeEnum typ = sh.ShapeType(); |
363 | if (typ == TopAbs_COMPOUND) typ = ShapeType (sh,compound); |
364 | if (res == TopAbs_SHAPE) res = typ; |
365 | // Egalite : OK; Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL |
366 | else if (res == TopAbs_EDGE && typ == TopAbs_WIRE) res = typ; |
367 | else if (res == TopAbs_WIRE && typ == TopAbs_EDGE) continue; |
368 | else if (res == TopAbs_FACE && typ == TopAbs_SHELL) res = typ; |
369 | else if (res == TopAbs_SHELL && typ == TopAbs_FACE) continue; |
370 | else if (res != typ) return TopAbs_COMPOUND; |
371 | } |
372 | return res; |
373 | } |
374 | |
375 | TopoDS_Shape XSControl_Utils::SortedCompound |
376 | (const TopoDS_Shape& shape, const TopAbs_ShapeEnum type, |
377 | const Standard_Boolean explore, const Standard_Boolean compound) const |
378 | { |
379 | if (shape.IsNull()) return shape; |
380 | TopAbs_ShapeEnum typ = shape.ShapeType(); |
381 | TopoDS_Shape sh, sh0; |
382 | Standard_Integer nb = 0; |
383 | |
384 | // Compound : on le prend, soit tel quel, soit son contenu |
385 | if (typ == TopAbs_COMPOUND || typ == TopAbs_COMPSOLID) { |
386 | TopoDS_Compound C; |
387 | BRep_Builder B; |
388 | B.MakeCompound (C); |
389 | for (TopoDS_Iterator it(shape); it.More(); it.Next()) { |
390 | sh0 = SortedCompound (it.Value(),type,explore,compound); |
391 | if (sh0.IsNull()) continue; |
392 | sh = sh0; |
393 | typ = sh.ShapeType(); |
394 | if (typ == TopAbs_COMPOUND && !compound) { |
395 | for (TopoDS_Iterator it2 (sh); it2.More(); it2.Next()) |
396 | { nb ++; sh = it2.Value(); B.Add (C, sh); } |
397 | } |
398 | else { nb ++; B.Add (C,sh); } |
399 | } |
400 | if (nb == 0) C.Nullify(); |
401 | else if (nb == 1) return sh; |
402 | return C; |
403 | } |
404 | |
405 | // Egalite : OK; Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL |
406 | if (typ == type) return shape; |
407 | if (typ == TopAbs_EDGE && type == TopAbs_WIRE) { |
408 | BRep_Builder B; |
409 | TopoDS_Wire W; |
410 | B.MakeWire (W); |
411 | B.Add (W,shape); // ne passe pas ! : TopoDS::Edge(shape) |
412 | return W; |
413 | } |
414 | if (typ == TopAbs_FACE && type == TopAbs_SHELL) { |
415 | BRep_Builder B; |
416 | TopoDS_Shell S; |
417 | B.MakeShell (S); |
418 | B.Add (S,shape); // ne passe pas ! : TopoDS::Face(shape)); |
419 | return S; |
420 | } |
421 | |
422 | // Le reste : selon exploration |
423 | if (!explore) { |
424 | TopoDS_Shape nulsh; |
425 | return nulsh; |
426 | } |
427 | |
428 | // Ici, on doit explorer |
429 | // SOLID + mode COMPOUND : reconduire les SHELLs |
430 | if (typ == TopAbs_SOLID && compound) { |
431 | TopoDS_Compound C; |
432 | BRep_Builder B; |
433 | B.MakeCompound (C); |
434 | for (TopoDS_Iterator it(shape); it.More(); it.Next()) { |
435 | sh0 = SortedCompound (it.Value(),type,explore,compound); |
436 | if (sh0.IsNull()) continue; |
437 | sh = sh0; |
438 | nb ++; B.Add (C,sh); |
439 | } |
440 | if (nb == 0) C.Nullify(); |
441 | else if (nb == 1) return sh; |
442 | return C; |
443 | } |
444 | |
445 | // Exploration classique |
446 | TopoDS_Compound CC; |
447 | BRep_Builder BB; |
448 | BB.MakeCompound(CC); |
449 | for (TopExp_Explorer expl (shape,type); expl.More(); expl.Next()) { |
450 | nb ++; sh = expl.Current(); |
451 | BB.Add (CC,sh); |
452 | } |
453 | if (nb == 0) CC.Nullify(); |
454 | else if (nb == 1) return sh; |
455 | return CC; |
456 | } |
457 | |
458 | |
459 | // ####### SHAPES : Liste ####### |
460 | |
461 | TopoDS_Shape XSControl_Utils::ShapeValue |
462 | (const Handle(TopTools_HSequenceOfShape)& seqval, const Standard_Integer num) const |
463 | { |
464 | TopoDS_Shape shape; |
465 | if (seqval.IsNull()) return shape; |
466 | if (num > 0 && num <= seqval->Length()) shape = seqval->Value(num); |
467 | return shape; |
468 | } |
469 | |
470 | Handle(TopTools_HSequenceOfShape) XSControl_Utils::NewSeqShape () const |
471 | { return new TopTools_HSequenceOfShape(); } |
472 | |
473 | void XSControl_Utils::AppendShape |
474 | (const Handle(TopTools_HSequenceOfShape)& seqval, const TopoDS_Shape& shape) const |
475 | { seqval->Append (shape); } |
476 | |
477 | // ####### SHAPES <-> Transient ####### |
478 | |
479 | Handle(Standard_Transient) XSControl_Utils::ShapeBinder |
480 | (const TopoDS_Shape& shape, const Standard_Boolean hs) const |
481 | { if (hs) return new TopoDS_HShape (shape); |
482 | else return new TransferBRep_ShapeBinder (shape); } |
483 | |
484 | TopoDS_Shape XSControl_Utils::BinderShape |
485 | (const Handle(Standard_Transient)& tr) const |
486 | { |
487 | TopoDS_Shape sh; |
488 | DeclareAndCast(Transfer_Binder,sb,tr); |
489 | if (!sb.IsNull()) return TransferBRep::ShapeResult(sb); |
490 | DeclareAndCast(TransferBRep_ShapeMapper,sm,tr); |
491 | if (!sm.IsNull()) return sm->Value(); |
492 | DeclareAndCast(TopoDS_HShape,hs,tr); |
493 | if (!hs.IsNull()) return hs->Shape(); |
494 | return sh; |
495 | } |
496 | |
497 | |
498 | // ########################################################## |
499 | // ####### LISTES : Fonctions Generales ####### |
500 | |
501 | Standard_Integer XSControl_Utils::SeqLength |
502 | (const Handle(Standard_Transient)& seqval) const |
503 | { |
504 | if (seqval.IsNull()) return 0; |
505 | DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval); |
506 | if (!seqs.IsNull()) return seqs->Length(); |
507 | DeclareAndCast(TColStd_HSequenceOfAsciiString,seqa,seqval); |
508 | if (!seqa.IsNull()) return seqa->Length(); |
509 | DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqe,seqval); |
510 | if (!seqe.IsNull()) return seqe->Length(); |
511 | DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqx,seqval); |
512 | if (!seqx.IsNull()) return seqx->Length(); |
513 | |
514 | DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval); |
515 | if (!seqt.IsNull()) return seqt->Length(); |
516 | DeclareAndCast(TopTools_HSequenceOfShape,seqh,seqval); |
517 | if (!seqh.IsNull()) return seqh->Length(); |
518 | DeclareAndCast(TColStd_HSequenceOfInteger,seqi,seqval); |
519 | if (!seqi.IsNull()) return seqi->Length(); |
520 | // Standard_TypeMismatch::Raise("XSControl_Utils::SeqLength"); |
521 | return 0; |
522 | } |
523 | |
524 | Handle(Standard_Transient) XSControl_Utils::SeqToArr |
525 | (const Handle(Standard_Transient)& seqval, const Standard_Integer first) const |
526 | { |
527 | Standard_Integer i,lng; |
528 | Handle(Standard_Transient) val; |
529 | if (seqval.IsNull()) return val; |
530 | DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval); |
531 | if (!seqs.IsNull()) { |
532 | lng = seqs->Length(); |
533 | Handle(Interface_HArray1OfHAsciiString) arrs = |
534 | new Interface_HArray1OfHAsciiString(first,lng-first+1); |
535 | for (i = 1; i <= lng; i ++) arrs->SetValue (i-first+1,seqs->Value(i)); |
536 | return arrs; |
537 | } |
538 | DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval); |
539 | if (!seqt.IsNull()) { |
540 | lng = seqt->Length(); |
541 | Handle(TColStd_HArray1OfTransient) arrt = |
542 | new TColStd_HArray1OfTransient(first,lng-first+1); |
543 | for (i = 1; i <= lng; i ++) arrt->SetValue (i-first+1,seqt->Value(i)); |
544 | return arrt; |
545 | } |
546 | Standard_TypeMismatch::Raise("XSControl_Utils::SeqToArr"); |
547 | return val; |
548 | } |
549 | |
550 | |
551 | Handle(Standard_Transient) XSControl_Utils::ArrToSeq |
552 | (const Handle(Standard_Transient)& arrval) const |
553 | { |
554 | Standard_Integer i,first,last; |
555 | Handle(Standard_Transient) val; |
556 | if (arrval.IsNull()) return val; |
557 | DeclareAndCast(Interface_HArray1OfHAsciiString,arrs,arrval); |
558 | if (!arrs.IsNull()) { |
559 | first = arrs->Lower(); |
560 | last = arrs->Upper(); |
561 | Handle(TColStd_HSequenceOfHAsciiString) seqs = |
562 | new TColStd_HSequenceOfHAsciiString(); |
563 | for (i = first; i <= last; i ++) seqs->Append (arrs->Value(i)); |
564 | return seqs; |
565 | } |
566 | DeclareAndCast(TColStd_HArray1OfTransient,arrt,arrval); |
567 | if (!arrt.IsNull()) { |
568 | first = arrt->Lower(); |
569 | last = arrt->Upper(); |
570 | Handle(TColStd_HSequenceOfTransient) seqt = |
571 | new TColStd_HSequenceOfTransient(); |
572 | for (i = first; i <= last; i ++) seqt->Append (arrt->Value(i)); |
573 | return seqt; |
574 | } |
575 | Standard_TypeMismatch::Raise("XSControl_Utils::ArrToSeq"); |
576 | return val; |
577 | } |
578 | |
579 | |
580 | Standard_Integer XSControl_Utils::SeqIntValue |
581 | (const Handle(TColStd_HSequenceOfInteger)& seqval, |
582 | const Standard_Integer num) const |
583 | { |
584 | if (seqval.IsNull()) return 0; |
585 | return seqval->Value(num); |
586 | } |