1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 // This file is part of Open CASCADE Technology software library.
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.
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
14 #include <XSControl_Utils.ixx>
15 #include <Message_Messenger.hxx>
16 #include <Message.hxx>
17 #include <Interface_Macros.hxx>
18 #include <Interface_MSG.hxx>
20 #include <TColStd_HSequenceOfAsciiString.hxx>
21 #include <TColStd_HSequenceOfExtendedString.hxx>
22 #include <TColStd_HArray1OfTransient.hxx>
23 #include <Interface_HArray1OfHAsciiString.hxx>
25 #include <TransferBRep.hxx>
26 #include <TransferBRep_ShapeBinder.hxx>
27 #include <TransferBRep_ShapeMapper.hxx>
28 #include <TopoDS_HShape.hxx>
30 #include <TopoDS_Wire.hxx>
31 #include <TopoDS_Shell.hxx>
32 #include <TopoDS_Compound.hxx>
33 #include <TopoDS_Iterator.hxx>
34 #include <TopExp_Explorer.hxx>
35 #include <Transfer_SimpleBinderOfTransient.hxx>
37 #include <BRep_Builder.hxx>
38 #include <BRepTools.hxx>
41 static TCollection_AsciiString bufasc;
42 static TCollection_ExtendedString bufext;
43 static const Standard_ExtString voidext = { 0 };
46 XSControl_Utils::XSControl_Utils () { }
48 // #########################################################
49 // ####### Fonctions de TRACE #######
51 void XSControl_Utils::TraceLine (const Standard_CString line) const
53 Handle(Message_Messenger) sout = Message::DefaultMessenger();
57 void XSControl_Utils::TraceLines (const Handle(Standard_Transient)& lines) const
59 Handle(Message_Messenger) sout = Message::DefaultMessenger();
60 Standard_Integer i,nb;
61 DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,lines);
62 if (!linha.IsNull()) {
64 for (i = 1; i <= nb; i ++)
65 if (!linha->Value(i).IsNull()) sout<<linha->Value(i)->ToCString()<<endl;
68 DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,lines);
71 for (i = 1; i <= nb; i ++)
72 sout<<lina->Value(i).ToCString()<<endl;
75 DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,lines);
76 if (!linhe.IsNull()) {
78 for (i = 1; i <= nb; i ++)
79 if (!linhe->Value(i).IsNull())
80 sout << linhe->Value(i) << endl;
83 DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,lines);
84 if (!linee.IsNull()) {
86 for (i = 1; i <= nb; i ++)
87 sout << linee->Value(i) << endl;
90 DeclareAndCast(TCollection_HAsciiString,lin1a,lines);
91 if (!lin1a.IsNull()) sout<<lin1a;
92 DeclareAndCast(TCollection_HExtendedString,lin1e,lines);
93 if (!lin1e.IsNull()) sout<<lin1e;
97 // #########################################################
98 // ####### TRANSIENT : Quelques acces de base #######
100 Standard_Boolean XSControl_Utils::IsKind
101 (const Handle(Standard_Transient)& item, const Handle(Standard_Type)& what) const
103 if (item.IsNull()) return Standard_False;
104 if (what.IsNull()) return Standard_False;
105 return item->IsKind(what);
108 Standard_CString XSControl_Utils::TypeName
109 (const Handle(Standard_Transient)& item, const Standard_Boolean nopk) const
111 if (item.IsNull()) return "";
112 DeclareAndCast(Standard_Type,atype,item);
113 if (atype.IsNull()) atype = item->DynamicType();
114 Standard_CString tn = atype->Name();
115 if (!nopk) return tn;
116 for (int i = 0; tn[i] != '\0'; i ++) {
117 if (tn[i] == '_') return &tn[i+1];
123 // ####### TRANSIENT : Fonctions de liste #######
125 Handle(Standard_Transient) XSControl_Utils::TraValue
126 (const Handle(Standard_Transient)& seqval, const Standard_Integer num) const
128 Handle(Standard_Transient) val;
129 if (num < 1) return val;
130 if (seqval.IsNull()) return val;
131 DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
133 { if (num <= seqs->Length()) val = seqs->Value(num); return val; }
134 DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
136 { if (num <= seqt->Length()) val = seqt->Value(num); return val; }
137 // Standard_TypeMismatch::Raise("XSControl_Utils::SeqTraValue");
141 Handle(TColStd_HSequenceOfTransient) XSControl_Utils::NewSeqTra () const
142 { return new TColStd_HSequenceOfTransient(); }
144 void XSControl_Utils::AppendTra
145 (const Handle(TColStd_HSequenceOfTransient)& seqval,
146 const Handle(Standard_Transient)& traval) const
147 { seqval->Append (traval); }
150 // ####### DATES #######
152 Standard_CString XSControl_Utils::DateString
153 (const Standard_Integer yy, const Standard_Integer mm,
154 const Standard_Integer dd, const Standard_Integer hh,
155 const Standard_Integer mn, const Standard_Integer ss) const
158 Interface_MSG::TDate (ladate, yy,mm,dd,hh,mn,ss);
159 bufasc.Clear(); bufasc.AssignCat(ladate);
160 return bufasc.ToCString();
163 void XSControl_Utils::DateValues
164 (const Standard_CString text,
165 Standard_Integer& yy, Standard_Integer& mm, Standard_Integer& dd,
166 Standard_Integer& hh, Standard_Integer& mn, Standard_Integer& ss) const
167 { Interface_MSG::NDate (text, yy,mm,dd,hh,mn,ss); }
170 // ##########################################################
171 // ####### STRING : Ascii de base #######
173 Standard_CString XSControl_Utils::ToCString
174 (const Handle(TCollection_HAsciiString)& strval) const
177 Standard_CString astr = (Standard_CString ) (strval.IsNull() ? "" : strval->ToCString());
179 // return (strval.IsNull() ? "" : strval->ToCString());
182 Standard_CString XSControl_Utils::ToCString
183 (const TCollection_AsciiString& strval) const
184 { return strval.ToCString(); }
186 Handle(TCollection_HAsciiString) XSControl_Utils::ToHString
187 (const Standard_CString strcon) const
188 { return new TCollection_HAsciiString(strcon); }
190 TCollection_AsciiString XSControl_Utils::ToAString
191 (const Standard_CString strcon) const
192 { return TCollection_AsciiString(strcon); }
194 // ####### STRING : Extended de base #######
196 Standard_ExtString XSControl_Utils::ToEString
197 (const Handle(TCollection_HExtendedString)& strval) const
198 { return (strval.IsNull() ? voidext : strval->ToExtString()); }
200 Standard_ExtString XSControl_Utils::ToEString
201 (const TCollection_ExtendedString& strval) const
202 { return strval.ToExtString(); }
204 Handle(TCollection_HExtendedString) XSControl_Utils::ToHString
205 (const Standard_ExtString strcon) const
206 { return new TCollection_HExtendedString(strcon); }
208 TCollection_ExtendedString XSControl_Utils::ToXString
209 (const Standard_ExtString strcon) const
210 { return TCollection_ExtendedString(strcon); }
212 // ####### STRING : Ascii <-> Extended #######
214 Standard_ExtString XSControl_Utils::AsciiToExtended (const Standard_CString str) const
216 bufext.Clear(); bufext = TCollection_ExtendedString (str);
217 return bufext.ToExtString();
220 Standard_Boolean XSControl_Utils::IsAscii (const Standard_ExtString str) const
222 bufext.Clear(); bufext.AssignCat (str);
223 return bufext.IsAscii();
226 Standard_CString XSControl_Utils::ExtendedToAscii (const Standard_ExtString str) const
228 bufext.Clear(); bufext.AssignCat (str); bufasc.Clear();
229 Standard_Integer i, nb = bufext.Length();
230 for (i = 1; i <= nb; i ++) {
231 int unext = bufext.Value(i);
233 char uncar = char(unext);
234 bufasc.AssignCat (uncar);
236 return bufasc.ToCString();
239 // ####### STRING : LISTES #######
241 Standard_CString XSControl_Utils::CStrValue
242 (const Handle(Standard_Transient)& list, const Standard_Integer num) const
244 DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,list);
245 if (!linha.IsNull()) {
247 Standard_CString astr = (Standard_CString )
248 (num > linha->Length() ? "" : linha->Value(num)->ToCString());
250 // return (num > linha->Length() ? "" : linha->Value(num)->ToCString());
253 DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,list);
254 if (!lina.IsNull()) {
256 Standard_CString astr = (Standard_CString )
257 (num > lina->Length() ? "" : lina->Value(num).ToCString());
259 // return (num > lina->Length() ? "" : lina->Value(num).ToCString());
262 DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,list);
263 if (!linhe.IsNull()) {
265 Standard_CString astr = (Standard_CString )
266 (num > linhe->Length() ? "" : ExtendedToAscii(linhe->Value(num)->ToExtString()));
268 // return (num > linhe->Length() ? "" : ExtendedToAscii(linhe->Value(num)->ToExtString()));
271 DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,list);
272 if (!linee.IsNull()) {
274 Standard_CString astr = (Standard_CString )
275 (num > linee->Length() ? "" : ExtendedToAscii(linee->Value(num).ToExtString()));
277 // return (num > linee->Length() ? "" : ExtendedToAscii(linee->Value(num).T
280 DeclareAndCast(TCollection_HAsciiString,lin1a,list);
281 if (!lin1a.IsNull()) return lin1a->ToCString();
282 DeclareAndCast(TCollection_HExtendedString,lin1e,list);
283 if (!lin1e.IsNull()) return ExtendedToAscii(lin1e->ToExtString());
288 Standard_ExtString XSControl_Utils::EStrValue
289 (const Handle(Standard_Transient)& list, const Standard_Integer num) const
291 DeclareAndCast(TColStd_HSequenceOfHAsciiString,linha,list);
292 if (!linha.IsNull()) return
293 (num > linha->Length() ? voidext : AsciiToExtended(linha->Value(num)->ToCString()));
295 DeclareAndCast(TColStd_HSequenceOfAsciiString,lina,list);
297 (num > lina->Length() ? voidext : AsciiToExtended(lina->Value(num).ToCString()));
299 DeclareAndCast(TColStd_HSequenceOfHExtendedString,linhe,list);
300 if (!linhe.IsNull()) return
301 (num > linhe->Length() ? voidext : linhe->Value(num)->ToExtString());
303 DeclareAndCast(TColStd_HSequenceOfExtendedString,linee,list);
304 if (!linee.IsNull()) return
305 (num > linee->Length() ? voidext : linee->Value(num).ToExtString());
307 DeclareAndCast(TCollection_HAsciiString,lin1a,list);
308 if (!lin1a.IsNull()) return AsciiToExtended(lin1a->ToCString());
309 DeclareAndCast(TCollection_HExtendedString,lin1e,list);
310 if (!lin1e.IsNull()) return lin1e->ToExtString();
314 Handle(TColStd_HSequenceOfHAsciiString) XSControl_Utils::NewSeqCStr () const
315 { return new TColStd_HSequenceOfHAsciiString(); }
317 void XSControl_Utils::AppendCStr
318 (const Handle(TColStd_HSequenceOfHAsciiString)& seqval,
319 const Standard_CString strval) const
320 { seqval->Append (new TCollection_HAsciiString(strval)); }
322 Handle(TColStd_HSequenceOfHExtendedString) XSControl_Utils::NewSeqEStr () const
323 { return new TColStd_HSequenceOfHExtendedString(); }
325 void XSControl_Utils::AppendEStr
326 (const Handle(TColStd_HSequenceOfHExtendedString)& seqval,
327 const Standard_ExtString strval) const
328 { seqval->Append (new TCollection_HExtendedString(strval)); }
331 // ##########################################################
332 // ####### SHAPES : Acces de base #######
334 Standard_Boolean XSControl_Utils::WriteShape
335 (const TopoDS_Shape& shape,
336 const Standard_CString filename) const
337 { return BRepTools::Write (shape,filename); }
339 TopoDS_Shape XSControl_Utils::NewShape () const
340 { TopoDS_Shape shape; return shape; }
342 Standard_Boolean XSControl_Utils::ReadShape
343 (TopoDS_Shape& shape,
344 const Standard_CString filename) const
347 return BRepTools::Read (shape,filename,B);
350 Standard_Boolean XSControl_Utils::IsNullShape (const TopoDS_Shape& shape) const
351 { return shape.IsNull(); }
354 TopoDS_Shape XSControl_Utils::CompoundFromSeq
355 (const Handle(TopTools_HSequenceOfShape)& seqval) const
360 Standard_Integer i,n = seqval->Length();
361 for (i = 1; i <= n ; i ++) B.Add(C,seqval->Value(i));
365 TopAbs_ShapeEnum XSControl_Utils::ShapeType
366 (const TopoDS_Shape& shape, const Standard_Boolean compound) const
368 if (shape.IsNull()) return TopAbs_SHAPE;
369 TopAbs_ShapeEnum res = shape.ShapeType();
370 if (!compound || res != TopAbs_COMPOUND) return res;
372 for (TopoDS_Iterator iter(shape); iter.More(); iter.Next()) {
373 TopoDS_Shape sh = iter.Value();
374 if (sh.IsNull()) continue;
375 TopAbs_ShapeEnum typ = sh.ShapeType();
376 if (typ == TopAbs_COMPOUND) typ = ShapeType (sh,compound);
377 if (res == TopAbs_SHAPE) res = typ;
378 // Egalite : OK; Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
379 else if (res == TopAbs_EDGE && typ == TopAbs_WIRE) res = typ;
380 else if (res == TopAbs_WIRE && typ == TopAbs_EDGE) continue;
381 else if (res == TopAbs_FACE && typ == TopAbs_SHELL) res = typ;
382 else if (res == TopAbs_SHELL && typ == TopAbs_FACE) continue;
383 else if (res != typ) return TopAbs_COMPOUND;
388 TopoDS_Shape XSControl_Utils::SortedCompound
389 (const TopoDS_Shape& shape, const TopAbs_ShapeEnum type,
390 const Standard_Boolean explore, const Standard_Boolean compound) const
392 if (shape.IsNull()) return shape;
393 TopAbs_ShapeEnum typ = shape.ShapeType();
394 TopoDS_Shape sh, sh0;
395 Standard_Integer nb = 0;
397 // Compound : on le prend, soit tel quel, soit son contenu
398 if (typ == TopAbs_COMPOUND || typ == TopAbs_COMPSOLID) {
402 for (TopoDS_Iterator it(shape); it.More(); it.Next()) {
403 sh0 = SortedCompound (it.Value(),type,explore,compound);
404 if (sh0.IsNull()) continue;
406 typ = sh.ShapeType();
407 if (typ == TopAbs_COMPOUND && !compound) {
408 for (TopoDS_Iterator it2 (sh); it2.More(); it2.Next())
409 { nb ++; sh = it2.Value(); B.Add (C, sh); }
411 else { nb ++; B.Add (C,sh); }
413 if (nb == 0) C.Nullify();
414 else if (nb == 1) return sh;
418 // Egalite : OK; Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
419 if (typ == type) return shape;
420 if (typ == TopAbs_EDGE && type == TopAbs_WIRE) {
424 B.Add (W,shape); // ne passe pas ! : TopoDS::Edge(shape)
427 if (typ == TopAbs_FACE && type == TopAbs_SHELL) {
431 B.Add (S,shape); // ne passe pas ! : TopoDS::Face(shape));
432 S.Closed (BRep_Tool::IsClosed (S));
436 // Le reste : selon exploration
442 // Ici, on doit explorer
443 // SOLID + mode COMPOUND : reconduire les SHELLs
444 if (typ == TopAbs_SOLID && compound) {
448 for (TopoDS_Iterator it(shape); it.More(); it.Next()) {
449 sh0 = SortedCompound (it.Value(),type,explore,compound);
450 if (sh0.IsNull()) continue;
454 if (nb == 0) C.Nullify();
455 else if (nb == 1) return sh;
459 // Exploration classique
463 for (TopExp_Explorer expl (shape,type); expl.More(); expl.Next()) {
464 nb ++; sh = expl.Current();
467 if (nb == 0) CC.Nullify();
468 else if (nb == 1) return sh;
473 // ####### SHAPES : Liste #######
475 TopoDS_Shape XSControl_Utils::ShapeValue
476 (const Handle(TopTools_HSequenceOfShape)& seqval, const Standard_Integer num) const
479 if (seqval.IsNull()) return shape;
480 if (num > 0 && num <= seqval->Length()) shape = seqval->Value(num);
484 Handle(TopTools_HSequenceOfShape) XSControl_Utils::NewSeqShape () const
485 { return new TopTools_HSequenceOfShape(); }
487 void XSControl_Utils::AppendShape
488 (const Handle(TopTools_HSequenceOfShape)& seqval, const TopoDS_Shape& shape) const
489 { seqval->Append (shape); }
491 // ####### SHAPES <-> Transient #######
493 Handle(Standard_Transient) XSControl_Utils::ShapeBinder
494 (const TopoDS_Shape& shape, const Standard_Boolean hs) const
495 { if (hs) return new TopoDS_HShape (shape);
496 else return new TransferBRep_ShapeBinder (shape); }
498 TopoDS_Shape XSControl_Utils::BinderShape
499 (const Handle(Standard_Transient)& tr) const
502 DeclareAndCast(Transfer_Binder,sb,tr);
503 if (!sb.IsNull()) return TransferBRep::ShapeResult(sb);
504 DeclareAndCast(TransferBRep_ShapeMapper,sm,tr);
505 if (!sm.IsNull()) return sm->Value();
506 DeclareAndCast(TopoDS_HShape,hs,tr);
507 if (!hs.IsNull()) return hs->Shape();
512 // ##########################################################
513 // ####### LISTES : Fonctions Generales #######
515 Standard_Integer XSControl_Utils::SeqLength
516 (const Handle(Standard_Transient)& seqval) const
518 if (seqval.IsNull()) return 0;
519 DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
520 if (!seqs.IsNull()) return seqs->Length();
521 DeclareAndCast(TColStd_HSequenceOfAsciiString,seqa,seqval);
522 if (!seqa.IsNull()) return seqa->Length();
523 DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqe,seqval);
524 if (!seqe.IsNull()) return seqe->Length();
525 DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqx,seqval);
526 if (!seqx.IsNull()) return seqx->Length();
528 DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
529 if (!seqt.IsNull()) return seqt->Length();
530 DeclareAndCast(TopTools_HSequenceOfShape,seqh,seqval);
531 if (!seqh.IsNull()) return seqh->Length();
532 DeclareAndCast(TColStd_HSequenceOfInteger,seqi,seqval);
533 if (!seqi.IsNull()) return seqi->Length();
534 // Standard_TypeMismatch::Raise("XSControl_Utils::SeqLength");
538 Handle(Standard_Transient) XSControl_Utils::SeqToArr
539 (const Handle(Standard_Transient)& seqval, const Standard_Integer first) const
541 Standard_Integer i,lng;
542 Handle(Standard_Transient) val;
543 if (seqval.IsNull()) return val;
544 DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
545 if (!seqs.IsNull()) {
546 lng = seqs->Length();
547 Handle(Interface_HArray1OfHAsciiString) arrs =
548 new Interface_HArray1OfHAsciiString(first,lng-first+1);
549 for (i = 1; i <= lng; i ++) arrs->SetValue (i-first+1,seqs->Value(i));
552 DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
553 if (!seqt.IsNull()) {
554 lng = seqt->Length();
555 Handle(TColStd_HArray1OfTransient) arrt =
556 new TColStd_HArray1OfTransient(first,lng-first+1);
557 for (i = 1; i <= lng; i ++) arrt->SetValue (i-first+1,seqt->Value(i));
560 Standard_TypeMismatch::Raise("XSControl_Utils::SeqToArr");
565 Handle(Standard_Transient) XSControl_Utils::ArrToSeq
566 (const Handle(Standard_Transient)& arrval) const
568 Standard_Integer i,first,last;
569 Handle(Standard_Transient) val;
570 if (arrval.IsNull()) return val;
571 DeclareAndCast(Interface_HArray1OfHAsciiString,arrs,arrval);
572 if (!arrs.IsNull()) {
573 first = arrs->Lower();
574 last = arrs->Upper();
575 Handle(TColStd_HSequenceOfHAsciiString) seqs =
576 new TColStd_HSequenceOfHAsciiString();
577 for (i = first; i <= last; i ++) seqs->Append (arrs->Value(i));
580 DeclareAndCast(TColStd_HArray1OfTransient,arrt,arrval);
581 if (!arrt.IsNull()) {
582 first = arrt->Lower();
583 last = arrt->Upper();
584 Handle(TColStd_HSequenceOfTransient) seqt =
585 new TColStd_HSequenceOfTransient();
586 for (i = first; i <= last; i ++) seqt->Append (arrt->Value(i));
589 Standard_TypeMismatch::Raise("XSControl_Utils::ArrToSeq");
594 Standard_Integer XSControl_Utils::SeqIntValue
595 (const Handle(TColStd_HSequenceOfInteger)& seqval,
596 const Standard_Integer num) const
598 if (seqval.IsNull()) return 0;
599 return seqval->Value(num);