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