0020716: Eliminate usage of "config.h" header file
[occt.git] / src / PCollection / PCollection_HExtendedString.cxx
CommitLineData
b311480e 1// Copyright (c) 1998-1999 Matra Datavision
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
b311480e 5//
d5f74e42 6// This library is free software; you can redistribute it and/or modify it under
7// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 8// by the Free Software Foundation, with special exception defined in the file
9// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10// distribution for complete text of the license and disclaimer of any warranty.
b311480e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
7fd59977 14
15#include <PCollection_HExtendedString.ixx>
16#include <PCollection_HAsciiString.hxx>
17#include <Standard_ExtString.hxx>
18#include <Standard_NumericError.hxx>
19#include <Standard_NegativeValue.hxx>
20#include <Standard_OutOfRange.hxx>
21
7fd59977 22#include <stdio.h>
7fd59977 23
24//------------------------------------------------------------------------
25// Create from an ExtendedString of TCollection
26//------------------------------------------------------------------------
27PCollection_HExtendedString::PCollection_HExtendedString
28 (const TCollection_ExtendedString& S):Data(S.Length())
29{
30 for( Standard_Integer i = 1; i <= Data.Length() ; i++)
31 Data.SetValue(i-1, S.Value(i)) ;
32}
33
34//------------------------------------------------------------------------
35// Create from a ExtCharacter
36//------------------------------------------------------------------------
37PCollection_HExtendedString::PCollection_HExtendedString
38 (const Standard_ExtCharacter C): Data(1)
39{
40 Data.SetValue(0, C);
41}
42
43//------------------------------------------------------------------------
44// Create from a range of an HExtendedString of PCollection
45//------------------------------------------------------------------------
46PCollection_HExtendedString::PCollection_HExtendedString
47 (const Handle(PCollection_HExtendedString)& S,
48 const Standard_Integer FromIndex, const Standard_Integer ToIndex) : Data(ToIndex-FromIndex+1)
49{
50 for( Standard_Integer i = 0 , k = FromIndex; i < Data.Length() ; i++, k++)
51 Data.SetValue(i, S->Value(k));
52}
53
54//-----------------------------------------------------------------------
55// Create : from a CString
56//-----------------------------------------------------------------------
57PCollection_HExtendedString::PCollection_HExtendedString(const Standard_CString S)
60be1f9b 58 : Data((Standard_Integer) strlen(S))
7fd59977 59{
60 for( Standard_Integer i = 0 ; i < Data.Length() ; i++) {
61 Standard_ExtCharacter val = ToExtCharacter(S[i]);
62 Data.SetValue(i, val) ;
63 }
64}
65
66//------------------------------------------------------------------------
67// Create from an HAsciiString from PCollection
68//------------------------------------------------------------------------
69PCollection_HExtendedString::PCollection_HExtendedString
70 (const Handle(PCollection_HAsciiString)& S) : Data(S->Length())
71 {
72 for( Standard_Integer i = 1; i <= Data.Length() ; i++) {
73// convert the character i of S
74 Standard_ExtCharacter val = ToExtCharacter(S->Value(i)) ;
75 Data.SetValue(i-1,val );
76 }
77}
78
79//------------------------------------------------------------------------
80// Append
81//------------------------------------------------------------------------
82void PCollection_HExtendedString::Append
83 (const Handle(PCollection_HExtendedString)& S)
84{
85 InsertAfter(Length(),S);
86}
87
88//------------------------------------------------------------------------
89// Center
90//------------------------------------------------------------------------
91void PCollection_HExtendedString::Center
92 (const Standard_Integer Width, const Standard_ExtCharacter Filler)
93{
94 if (Width < 0) Standard_NegativeValue::Raise();
95 Standard_Integer size1 = Length();
96 if(Width > size1) {
97 Standard_Integer size2 = size1 + ((Width - size1)/2);
98 LeftJustify(size2,Filler);
99 RightJustify(Width,Filler);
100 }
101}
102
103//------------------------------------------------------------------------
104// ChangeAll
105//------------------------------------------------------------------------
106void PCollection_HExtendedString::ChangeAll
107 (const Standard_ExtCharacter C, const Standard_ExtCharacter NewC)
108{
109 for( Standard_Integer i = 0 ; i < Data.Length(); i++) {
110 if(Data(i) == C) Data.SetValue(i, NewC);
111 }
112}
113
114//------------------------------------------------------------------------
115// Clear
116//------------------------------------------------------------------------
117void PCollection_HExtendedString::Clear ()
118{
119 Data.Resize(0);
120}
121
122//------------------------------------------------------------------------
123// Convert
124//------------------------------------------------------------------------
125TCollection_ExtendedString PCollection_HExtendedString::Convert() const
126{
127 Standard_Integer L = Length();
128 TCollection_ExtendedString TString (L,' ');
129 for (Standard_Integer i = 1 ; i <= L ; i++) {
130 TString.SetValue(i,Value(i));
131 }
132 return TString;
133}
134
135//------------------------------------------------------------------------
136// FirstLocationInSet
137//------------------------------------------------------------------------
138Standard_Integer PCollection_HExtendedString::FirstLocationInSet
139 (const Handle(PCollection_HExtendedString)& Set,
140 const Standard_Integer FromIndex,
141 const Standard_Integer ToIndex) const
142{
143 if (Length() == 0 || Set->Length() == 0) return 0;
144 if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex )
145 Standard_OutOfRange::Raise();
146 for(Standard_Integer i = FromIndex-1 ; i <= ToIndex-1; i++)
147 for(Standard_Integer j = 1; j <= Set->Length(); j++)
148 if(Data(i) == Set->Value(j)) return (i+1);
149 return 0;
150}
151
152//------------------------------------------------------------------------
153// FirstLocationNotInset
154//------------------------------------------------------------------------
155Standard_Integer PCollection_HExtendedString::FirstLocationNotInSet
156 (const Handle(PCollection_HExtendedString)& Set, const Standard_Integer FromIndex,
157 const Standard_Integer ToIndex) const
158{
159 if (Length() == 0 || Set->Length() == 0) return 0;
160 if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex )
161 Standard_OutOfRange::Raise();
162 Standard_Boolean find;
163 for(Standard_Integer i = FromIndex-1 ; i <= ToIndex-1; i++) {
164 find = Standard_False;
165 for(Standard_Integer j = 1; j <= Set->Length(); j++) {
166 if (Data(i) == Set->Value(j)) find = Standard_True;
167 }
168 if (!find) return (i+1);
169 }
170 return 0;
171}
172
173//------------------------------------------------------------------------
174// InsertAfter
175//------------------------------------------------------------------------
176void PCollection_HExtendedString::InsertAfter
177 (const Standard_Integer Index, const Handle(PCollection_HExtendedString)& S)
178{
179 Standard_Integer i ;
180 Standard_Integer size1 = Length();
181 Standard_Integer size2 = S->Length();
182#ifndef NOBOUNDCHECK
183 if (Index < 0 || Index > size1) Standard_OutOfRange::Raise();
184#endif
185 Data.Resize(size1+size2);
186 for( i = size1-1 ; i >= Index; i--) Data.SetValue(size2+i,Data(i));
187 for( i = 1 ; i <= size2; i++) Data.SetValue(Index+i-1,S->Value(i));
188}
189
190//------------------------------------------------------------------------
191// InsertBefore
192//------------------------------------------------------------------------
193void PCollection_HExtendedString::InsertBefore
194 (const Standard_Integer Index, const Handle(PCollection_HExtendedString)& S)
195{
196 Standard_Integer i ;
197 Standard_Integer size1 = Length();
198 Standard_Integer size2 = S->Length();
199#ifndef NOBOUNDCHECK
200 if (Index < 0 || Index > size1) Standard_OutOfRange::Raise();
201#endif
202 Data.Resize(size1+size2);
203 for( i = size1-1 ; i >= Index-1 ; i--)
204 Data.SetValue(size2+i,Data(i));
205 for( i = 1 ; i <= size2; i++) Data.SetValue(Index+i-2, S->Value(i));
206}
207
208//------------------------------------------------------------------------
209// IsAscii
210//------------------------------------------------------------------------
211Standard_Boolean PCollection_HExtendedString::IsAscii() const
212{
213 for( Standard_Integer i = 0; i < Data.Length() ; i++) {
214 if (!IsAnAscii(Data(i))) return Standard_False;
215 }
216 return Standard_True;
217}
218
219//------------------------------------------------------------------------
220// IsDifferent
221//------------------------------------------------------------------------
222Standard_Boolean PCollection_HExtendedString::IsDifferent
223 (const Handle(PCollection_HExtendedString)& S) const
224{
225 Standard_Integer size = Length();
226 if( size != S->Length()) return Standard_True;
227 Standard_Integer i = 1 ;
228 Standard_Boolean different = Standard_False;
229 while (i <= size && !different) {
230 if (Data(i-1) != S->Value(i)) different = Standard_True;
231 i++;
232 }
233 return different;
234}
235
236//------------------------------------------------------------------------
237// IsEmpty
238//------------------------------------------------------------------------
239Standard_Boolean PCollection_HExtendedString::IsEmpty () const
240{
241 return (Data.Length() == 0);
242}
243
244// ----------------------------------------------------------------------------
245// IsLess
246// ----------------------------------------------------------------------------
247Standard_Boolean PCollection_HExtendedString::IsLess(
248 const Handle(PCollection_HExtendedString)& other) const
249{
250 Standard_Integer mysize = Data.Length();
251 Standard_Integer size = other->Length();
252 Standard_Integer i = 0;
253 Standard_Integer j = 1;
254 while (i < mysize && j <= size) {
255 if (Data(i) < other->Value(j)) return (Standard_True);
256 if (Data(i) > other->Value(j)) return (Standard_False);
257 i++;
258 j++;
259 }
260 if (i == mysize && j <= size) return (Standard_True);
261 return (Standard_False);
262}
263
264// ----------------------------------------------------------------------------
265// IsGreater
266// ----------------------------------------------------------------------------
267Standard_Boolean PCollection_HExtendedString::IsGreater
268 (const Handle(PCollection_HExtendedString)& other) const
269{
270 Standard_Integer mysize = Data.Length();
271 Standard_Integer size = other->Length();
272 Standard_Integer i = 0;
273 Standard_Integer j = 1;
274 while (i < mysize && j <= size) {
275 if (Data(i) < other->Value(j)) return (Standard_False);
276 if (Data(i) > other->Value(j)) return (Standard_True);
277 i++;
278 j++;
279 }
280 if (j == size && j < mysize) return (Standard_True);
281 return (Standard_False);
282}
283
284//------------------------------------------------------------------------
285// IsSameString
286//------------------------------------------------------------------------
287Standard_Boolean PCollection_HExtendedString::IsSameString
288 (const Handle(PCollection_HExtendedString)& S) const
289{
290 Standard_Integer size1 = Length();
291 if( size1 != S->Length()) return Standard_False;
292 for( Standard_Integer i = 1 ; i <= size1; i++) {
293 if(Data(i-1) != S->Value(i)) return Standard_False;
294 }
295 return Standard_True;
296}
297
298//------------------------------------------------------------------------
299// LeftAdjust
300//------------------------------------------------------------------------
301void PCollection_HExtendedString::LeftAdjust ()
302{
303 Standard_Integer i ;
304
305 if (!IsAscii()) Standard_OutOfRange::Raise();
306 for ( i = 1 ; i <= Length() ; i ++) {
307 if (!IsSpace((Standard_Character)Value(i))) break;
308 }
309 if( i > 1 ) Remove(1,i-1);
310}
311
312//------------------------------------------------------------------------
313// LeftJustify
314//------------------------------------------------------------------------
315void PCollection_HExtendedString::LeftJustify
316 (const Standard_Integer Width, const Standard_ExtCharacter Filler)
317{
318 if (Width < 0) Standard_NegativeValue::Raise();
319 Standard_Integer size1 = Length();
320 if(Width > size1) {
321 Data.Resize(Width);
322 for(Standard_Integer i = size1; i < Width ; i++) Data.SetValue(i, Filler);
323 }
324}
325
326//------------------------------------------------------------------------
327// Length
328//------------------------------------------------------------------------
329Standard_Integer PCollection_HExtendedString::Length () const
330{
331 return Data.Length();
332}
333
334//------------------------------------------------------------------------
335// Location
336//------------------------------------------------------------------------
337Standard_Integer PCollection_HExtendedString::Location
338 (const Standard_Integer N, const Standard_ExtCharacter C,
339 const Standard_Integer FromIndex, const Standard_Integer ToIndex) const
340{
341 if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex )
342 Standard_OutOfRange::Raise();
f24125b9 343 for(Standard_Integer i = FromIndex-1, icount = 0; i <= ToIndex-1; i++)
7fd59977 344 if(Data(i) == C) {
f24125b9 345 icount++;
346 if ( icount == N ) return (i+1);
7fd59977 347 }
348 return 0 ;
349}
350
351//------------------------------------------------------------------------
352// Location
353//------------------------------------------------------------------------
354Standard_Integer PCollection_HExtendedString::Location
355 (const Handle(PCollection_HExtendedString)& S, const Standard_Integer FromIndex,
356 const Standard_Integer ToIndex) const
357{
358 if (Length() == 0 || S->Length() == 0) return 0;
359 if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex )
360 Standard_OutOfRange::Raise();
361 for(Standard_Integer i = FromIndex-1, k = 1, l = FromIndex-2; i < ToIndex; i++){
362 if(Data(i) == S->Value(k)) {
363 k++;
364 if ( k > S->Length()) return l + 2;
365 }
366 else {
367 k = 1;
368 l = i;
369 }
370 }
371 return 0;
372}
373
374//------------------------------------------------------------------------
375// Prepend
376//------------------------------------------------------------------------
377void PCollection_HExtendedString::Prepend
378 (const Handle(PCollection_HExtendedString)& S)
379{
380 InsertAfter(0,S);
381}
382
383
384//------------------------------------------------------------------------
385// Print
386//------------------------------------------------------------------------
387void PCollection_HExtendedString::Print (Standard_OStream& S) const
388{
389 Standard_Integer len = Data.Length() ;
390 for(Standard_Integer i = 0; i < len ; i++) {
391 S.width(4);
392 S.fill('0');
393 S << hex << Data(i);
394 }
395}
396
397//------------------------------------------------------------------------
398// Remove
399//------------------------------------------------------------------------
400void PCollection_HExtendedString::Remove (const Standard_Integer Index)
401{
402 if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
403 Remove(Index,Index);
404}
405
406//------------------------------------------------------------------------
407// Remove
408//------------------------------------------------------------------------
409void PCollection_HExtendedString::Remove
410 (const Standard_Integer FromIndex, const Standard_Integer ToIndex)
411{
412 if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex )
413 Standard_OutOfRange::Raise();
414 Standard_Integer size1 = Length();
415 for( Standard_Integer i = ToIndex, j = FromIndex-1; i < size1 ; i++, j++)
416 Data.SetValue(j,Data(i));
417 Data.Resize(size1-(ToIndex-FromIndex+1));
418}
419
420//------------------------------------------------------------------------
421// RemoveAll
422//------------------------------------------------------------------------
423void PCollection_HExtendedString::RemoveAll (const Standard_ExtCharacter C)
424{
425 Standard_Integer i ;
426 Standard_Integer j ;
427 Standard_Integer size1 = Length();
428 for( i = 0, j = 0; i < size1 ; i++) {
429 if (Data(i) == C) continue;
430 Data.SetValue(j++, Data(i));
431 }
432 Data.Resize(j);
433}
434
435//------------------------------------------------------------------------
436// RightAdjust
437//------------------------------------------------------------------------
438void PCollection_HExtendedString::RightAdjust ()
439{
440 Standard_Integer i ;
441 if (! IsAscii()) Standard_OutOfRange::Raise();
442 for ( i = Length() ; i >= 1 ; i --) {
443 if (!IsSpace((Standard_Character)Value(i))) break;
444 }
445 if( i < Length() ) Remove(i+1,Length());
446}
447
448//------------------------------------------------------------------------
449// RightJustify
450//------------------------------------------------------------------------
451void PCollection_HExtendedString::RightJustify
452 (const Standard_Integer Width, const Standard_ExtCharacter Filler)
453{
454 Standard_Integer i ;
455 Standard_Integer k ;
456 if (Width < 0) Standard_NegativeValue::Raise();
457 Standard_Integer size1 = Length();
458 if(Width > size1) {
459 Data.Resize(Width);
460 for ( i = size1-1, k = Width-1 ; i >= 0 ; i--, k--)
461 Data.SetValue(k, Data(i));
462 for(; k >= 0 ; k--) Data.SetValue(k, Filler);
463 }
464}
465
466//------------------------------------------------------------------------
467// SetValue
468//------------------------------------------------------------------------
469void PCollection_HExtendedString::SetValue
470 (const Standard_Integer Index, const Standard_ExtCharacter C)
471{
472 if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
473 Data(Index-1) = C;
474}
475
476//------------------------------------------------------------------------
477// SetValue
478//------------------------------------------------------------------------
479void PCollection_HExtendedString::SetValue
480 (const Standard_Integer Index, const Handle(PCollection_HExtendedString)& S)
481{
482
483 Standard_Integer size1 = Length();
484 Standard_Integer size2 = S->Length();
485 Standard_Integer size3 = size2 + Index - 1;
486#ifndef NOBOUNDCHECK
487 if (Index < 0 || Index > size1) Standard_OutOfRange::Raise();
488#endif
489 if(size1 != size3) Data.Resize(size3);
490 for( Standard_Integer i = 1 ; i <= size2; i++) Data.SetValue(Index+i-2, S->Value(i));
491}
492
493//------------------------------------------------------------------------
494// Split
495//------------------------------------------------------------------------
496Handle(PCollection_HExtendedString) PCollection_HExtendedString::Split
497 (const Standard_Integer Index)
498{
499 if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
500 Handle(PCollection_HExtendedString) S2;
501 if (Index != Length()) {
502 S2 = SubString(Index+1,Length());
503 Data.Resize(Index);
504 }
505 else {
506#ifndef OBJS
507 Handle(PCollection_HAsciiString) s = new PCollection_HAsciiString("");
508 S2 = new PCollection_HExtendedString(s);
509#else
510 Handle(PCollection_HAsciiString) s = new (os_segment::of(this)) PCollection_HAsciiString("");
511 S2 = new (os_segment::of(this)) PCollection_HExtendedString(s);
512#endif
513 }
514 return S2;
515}
516
517//------------------------------------------------------------------------
518// SubString
519//------------------------------------------------------------------------
520Handle(PCollection_HExtendedString) PCollection_HExtendedString::SubString
521 (const Standard_Integer FromIndex, const Standard_Integer ToIndex) const
522{
523 if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex )
524 Standard_OutOfRange::Raise();
525 Handle(PCollection_HExtendedString) S1;
526 Handle(PCollection_HExtendedString) S2;
527 S2 = this;
528#ifndef OBJS
529 S1 = new PCollection_HExtendedString(S2,FromIndex,ToIndex);
530#else
531 S1 = new (os_segment::of(this)) PCollection_HExtendedString(S2,FromIndex,ToIndex);
532#endif
533 return S1;
534}
535
536//------------------------------------------------------------------------
537// UsefullLength
538//------------------------------------------------------------------------
539Standard_Integer PCollection_HExtendedString::UsefullLength () const
540{
541 Standard_Integer i ;
542 if (! IsAscii()) Standard_OutOfRange::Raise();
543 for( i = Length() ; i >= 1 ; i--)
544 if (IsGraphic((Standard_Character)Value(i))) break;
545 return (i);
546}
547
548//------------------------------------------------------------------------
549// value
550//------------------------------------------------------------------------
551Standard_ExtCharacter PCollection_HExtendedString::Value
552 (const Standard_Integer Index) const
553{
554 if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
555 return Data(Index-1);
556}
557
558//------------------------------------------------------------------------
7fd59977 559// Assign
560//------------------------------------------------------------------------
561void PCollection_HExtendedString::Assign
562 (const DBC_VArrayOfExtCharacter& TheField)
563
564{
565 Data = TheField;
566}
567
568
569
570
571
572
573