0028403: Avoid useless calls to BRepTools::Write()
[occt.git] / src / XSControl / XSControl_Utils.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 <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
50     XSControl_Utils::XSControl_Utils ()    {  }
51
52 //  #########################################################
53 //  #######           Fonctions  de   TRACE           #######
54
55     void  XSControl_Utils::TraceLine (const Standard_CString line) const
56 {
57   Handle(Message_Messenger) sout = Message::DefaultMessenger();
58   sout<<line<<endl;
59 }
60
61     void  XSControl_Utils::TraceLines (const Handle(Standard_Transient)& lines) const
62 {
63   Handle(Message_Messenger) sout = Message::DefaultMessenger();
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()<<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()<<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) << 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) << endl;
92     return;
93   }
94   DeclareAndCast(TCollection_HAsciiString,lin1a,lines);
95   if (!lin1a.IsNull()) sout<<lin1a;
96   DeclareAndCast(TCollection_HExtendedString,lin1e,lines);
97   if (!lin1e.IsNull()) sout<<lin1e;
98 }
99
100
101 //  #########################################################
102 //  #######   TRANSIENT : Quelques  acces  de  base   #######
103
104     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
112     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
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 //  Standard_TypeMismatch::Raise("XSControl_Utils::SeqTraValue");
142   return val;
143 }
144
145     Handle(TColStd_HSequenceOfTransient) XSControl_Utils::NewSeqTra () const
146       {  return  new TColStd_HSequenceOfTransient();  }
147
148     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
156     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
167     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
177     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
186     Standard_CString  XSControl_Utils::ToCString
187   (const TCollection_AsciiString& strval) const
188       {  return strval.ToCString();  }
189
190     Handle(TCollection_HAsciiString)  XSControl_Utils::ToHString
191   (const Standard_CString strcon) const
192       {  return new TCollection_HAsciiString(strcon);  }
193
194     TCollection_AsciiString  XSControl_Utils::ToAString
195   (const Standard_CString strcon) const
196       {  return TCollection_AsciiString(strcon);  }
197
198 //  #######         STRING : Extended de base         #######
199
200     Standard_ExtString  XSControl_Utils::ToEString
201   (const Handle(TCollection_HExtendedString)& strval) const
202       {  return (strval.IsNull() ? voidext : strval->ToExtString());  }
203
204     Standard_ExtString  XSControl_Utils::ToEString
205   (const TCollection_ExtendedString& strval) const
206       {  return strval.ToExtString();  }
207
208     Handle(TCollection_HExtendedString)  XSControl_Utils::ToHString
209   (const Standard_ExtString strcon) const
210       {  return new TCollection_HExtendedString(strcon);  }
211
212     TCollection_ExtendedString  XSControl_Utils::ToXString
213   (const Standard_ExtString strcon) const
214       {  return TCollection_ExtendedString(strcon);  }
215
216 //  #######        STRING : Ascii <-> Extended        #######
217
218     Standard_ExtString  XSControl_Utils::AsciiToExtended (const Standard_CString str) const
219 {
220   bufext.Clear();  bufext = TCollection_ExtendedString (str);
221   return bufext.ToExtString();
222 }
223
224     Standard_Boolean  XSControl_Utils::IsAscii (const Standard_ExtString str) const
225 {
226   bufext.Clear();  bufext.AssignCat (str);
227   return bufext.IsAscii();
228 }
229
230     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
245     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
292     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
318     Handle(TColStd_HSequenceOfHAsciiString) XSControl_Utils::NewSeqCStr () const
319       {  return  new TColStd_HSequenceOfHAsciiString();  }
320
321     void  XSControl_Utils::AppendCStr
322   (const Handle(TColStd_HSequenceOfHAsciiString)& seqval,
323    const Standard_CString strval) const
324       {  seqval->Append (new TCollection_HAsciiString(strval));  }
325
326     Handle(TColStd_HSequenceOfHExtendedString) XSControl_Utils::NewSeqEStr () const
327       {  return  new TColStd_HSequenceOfHExtendedString();  }
328
329     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
338     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
349     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
372     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 expl (shape,type); expl.More(); expl.Next()) {
448     nb ++;  sh = expl.Current();
449     BB.Add (CC,sh);
450   }
451   if (nb == 0) CC.Nullify();
452   else if (nb == 1) return sh;
453   return CC;
454 }
455
456
457 //  #######               SHAPES : Liste               #######
458
459     TopoDS_Shape  XSControl_Utils::ShapeValue
460   (const Handle(TopTools_HSequenceOfShape)& seqval, const Standard_Integer num) const
461 {
462   TopoDS_Shape shape;
463   if (seqval.IsNull()) return shape;
464   if (num > 0 && num <= seqval->Length()) shape = seqval->Value(num);
465   return shape;
466 }
467
468     Handle(TopTools_HSequenceOfShape) XSControl_Utils::NewSeqShape () const
469       {  return  new TopTools_HSequenceOfShape();  }
470
471     void  XSControl_Utils::AppendShape
472   (const Handle(TopTools_HSequenceOfShape)& seqval, const TopoDS_Shape& shape) const
473       {  seqval->Append (shape);  }
474
475 //  #######            SHAPES <-> Transient            #######
476
477     Handle(Standard_Transient)  XSControl_Utils::ShapeBinder
478   (const TopoDS_Shape& shape, const Standard_Boolean hs) const
479       {  if (hs) return new TopoDS_HShape            (shape);
480          else    return new TransferBRep_ShapeBinder (shape);  }
481
482     TopoDS_Shape  XSControl_Utils::BinderShape
483   (const Handle(Standard_Transient)& tr) const
484 {
485   TopoDS_Shape sh;
486   DeclareAndCast(Transfer_Binder,sb,tr);
487   if (!sb.IsNull()) return TransferBRep::ShapeResult(sb);
488   DeclareAndCast(TransferBRep_ShapeMapper,sm,tr);
489   if (!sm.IsNull()) return sm->Value();
490   DeclareAndCast(TopoDS_HShape,hs,tr);
491   if (!hs.IsNull()) return hs->Shape();
492   return sh;
493 }
494
495
496 //  ##########################################################
497 //  #######        LISTES : Fonctions Generales        #######
498
499     Standard_Integer  XSControl_Utils::SeqLength
500   (const Handle(Standard_Transient)& seqval) const
501 {
502   if (seqval.IsNull()) return 0;
503   DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
504   if (!seqs.IsNull()) return seqs->Length();
505   DeclareAndCast(TColStd_HSequenceOfAsciiString,seqa,seqval);
506   if (!seqa.IsNull()) return seqa->Length();
507   DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqe,seqval);
508   if (!seqe.IsNull()) return seqe->Length();
509   DeclareAndCast(TColStd_HSequenceOfHExtendedString,seqx,seqval);
510   if (!seqx.IsNull()) return seqx->Length();
511
512   DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
513   if (!seqt.IsNull()) return seqt->Length();
514   DeclareAndCast(TopTools_HSequenceOfShape,seqh,seqval);
515   if (!seqh.IsNull()) return seqh->Length();
516   DeclareAndCast(TColStd_HSequenceOfInteger,seqi,seqval);
517   if (!seqi.IsNull()) return seqi->Length();
518 //  Standard_TypeMismatch::Raise("XSControl_Utils::SeqLength");
519   return 0;
520 }
521
522     Handle(Standard_Transient)  XSControl_Utils::SeqToArr
523   (const Handle(Standard_Transient)& seqval, const Standard_Integer first) const
524 {
525   Standard_Integer i,lng;
526   Handle(Standard_Transient) val;
527   if (seqval.IsNull()) return val;
528   DeclareAndCast(TColStd_HSequenceOfHAsciiString,seqs,seqval);
529   if (!seqs.IsNull()) {
530     lng = seqs->Length();
531     Handle(Interface_HArray1OfHAsciiString) arrs =
532       new Interface_HArray1OfHAsciiString(first,lng-first+1);
533     for (i = 1; i <= lng; i ++)  arrs->SetValue (i-first+1,seqs->Value(i));
534     return arrs;
535   }
536   DeclareAndCast(TColStd_HSequenceOfTransient,seqt,seqval);
537   if (!seqt.IsNull()) {
538     lng = seqt->Length();
539     Handle(TColStd_HArray1OfTransient) arrt =
540       new TColStd_HArray1OfTransient(first,lng-first+1);
541     for (i = 1; i <= lng; i ++)  arrt->SetValue (i-first+1,seqt->Value(i));
542     return arrt;
543   }
544   Standard_TypeMismatch::Raise("XSControl_Utils::SeqToArr");
545   return val;
546 }
547
548
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   Standard_TypeMismatch::Raise("XSControl_Utils::ArrToSeq");
574   return val;
575 }
576
577
578     Standard_Integer  XSControl_Utils::SeqIntValue
579   (const Handle(TColStd_HSequenceOfInteger)& seqval,
580    const Standard_Integer num) const
581 {
582   if (seqval.IsNull()) return 0;
583   return seqval->Value(num);
584 }