0024186: Eliminate remaining compiler warnings in MSVC++ 2010 64 bit with warning...
[occt.git] / src / PCollection / PCollection_HAsciiString.cxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
3 //
4 // The content of this file is subject to the Open CASCADE Technology Public
5 // License Version 6.5 (the "License"). You may not use the content of this file
6 // except in compliance with the License. Please obtain a copy of the License
7 // at http://www.opencascade.org and read it completely before using this file.
8 //
9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11 //
12 // The Original Code and all software distributed under the License is
13 // distributed on an "AS IS" basis, without warranty of any kind, and the
14 // Initial Developer hereby disclaims all such warranties, including without
15 // limitation, any warranties of merchantability, fitness for a particular
16 // purpose or non-infringement. Please see the License for the specific terms
17 // and conditions governing the rights and limitations under the License.
18
19
20 #include <PCollection_HAsciiString.ixx>
21 #include <PCollection_HExtendedString.hxx>
22 #include <TCollection_HAsciiString.hxx>
23 #include <Standard_NumericError.hxx>
24 #include <Standard_NegativeValue.hxx>
25 #include <Standard_OutOfRange.hxx>
26
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30 #if defined(HAVE_STRING_H)
31 # include <string.h>
32 #endif
33 #include <stdio.h>
34 #if defined(HAVE_STDLIB_H)
35 # include <stdlib.h>
36 #endif
37 #if defined(HAVE_LIBC_H)
38 # include <libc.h>
39 #endif
40
41 //------------------------------------
42 //  Conversion functions and variables
43 //------------------------------------
44
45 #define MAXLENGTH 80
46 static char cnvbuf[MAXLENGTH];
47 static Standard_Integer cnvint;
48 static Standard_Real cnvreal;
49
50 //-----------------------------------------------------------------------
51 // intstr
52 //-----------------------------------------------------------------------
53 static int intstr(Standard_Integer V,Standard_CString F)
54 {
55   sprintf(cnvbuf,F,V);
56   return (int)strlen(cnvbuf);
57 }
58
59 //-----------------------------------------------------------------------
60 // realstr
61 //----------------------------------------------------------------------
62 static int realstr(Standard_Real V, Standard_CString F)
63 {
64   sprintf(cnvbuf,F,V);
65   return (int)strlen(cnvbuf);
66 }
67   
68 //-----------------------------------------------------------------------
69 // Create : from a CString
70 //-----------------------------------------------------------------------
71 PCollection_HAsciiString::PCollection_HAsciiString(const Standard_CString S)
72                                                : Data((Standard_Integer) strlen(S))
73 {
74    for( Standard_Integer i = 0 ; i < Data.Length() ; i++) 
75                             Data.SetValue(i, S[i]) ;
76 }
77
78 //------------------------------------------------------------------------
79 //  Create from an AsciiString of TCollection
80 //------------------------------------------------------------------------
81 PCollection_HAsciiString::PCollection_HAsciiString
82                   (const TCollection_AsciiString& S):Data(S.Length())
83 {
84    for( Standard_Integer i = 1; i <= Data.Length() ; i++) 
85                             Data.SetValue(i-1, S.Value(i)) ;   
86 }
87
88 //------------------------------------------------------------------------
89 //  Create from a Character
90 //------------------------------------------------------------------------
91 PCollection_HAsciiString::PCollection_HAsciiString(const Standard_Character C)
92                                                : Data(1)
93 {
94    Data.SetValue(0, C);
95 }
96
97 //------------------------------------------------------------------------
98 //  Create from a range of an HAsciiString of PCollection
99 //------------------------------------------------------------------------
100 PCollection_HAsciiString::PCollection_HAsciiString 
101   (const Handle(PCollection_HAsciiString)& S, 
102    const Standard_Integer FromIndex, const Standard_Integer ToIndex) : Data(ToIndex-FromIndex+1)
103 {
104    for( Standard_Integer i = 0 , k = FromIndex; i < Data.Length() ; i++, k++) 
105                         Data.SetValue(i, S->Value(k));
106 }
107
108 //------------------------------------------------------------------------
109 //  Create from an HExtendedString from PCollection
110 //------------------------------------------------------------------------
111 PCollection_HAsciiString::PCollection_HAsciiString 
112           (const Handle(PCollection_HExtendedString)& S) : Data(S->Length())
113 {
114    if (!S->IsAscii()) Standard_OutOfRange::Raise();
115    for( Standard_Integer i = 1; i <= Data.Length() ; i++)  {
116 //     convert the character i of S 
117        Standard_Character val = ToCharacter(S->Value(i)) ;
118        Data.SetValue(i-1,val ) ;   
119    }   
120 }
121
122 //------------------------------------------------------------------------
123 //  Create from a Real by converting it
124 //------------------------------------------------------------------------
125 PCollection_HAsciiString::PCollection_HAsciiString 
126                 (const Standard_Real R , const Standard_CString F) : Data(realstr(R,F))
127 {
128    for( Standard_Integer i =0 ; i < Data.Length() ; i++) 
129                             Data.SetValue(i,cnvbuf[i] );
130 }
131
132 //------------------------------------------------------------------------
133 //  Create from an Integer by converting it
134 //------------------------------------------------------------------------
135 PCollection_HAsciiString::PCollection_HAsciiString 
136         (const Standard_Integer I, const Standard_CString F) : Data(intstr(I,F))
137 {
138    for( Standard_Integer i = 0 ; i < Data.Length() ; i++) 
139                             Data.SetValue(i,cnvbuf[i]) ;
140 }
141
142
143 //------------------------------------------------------------------------
144 //  Append
145 //------------------------------------------------------------------------
146 void PCollection_HAsciiString::Append 
147                    (const Handle(PCollection_HAsciiString)& S)
148 {
149    InsertAfter(Length(),S);
150 }
151
152 //------------------------------------------------------------------------
153 //  Capitalize
154 //------------------------------------------------------------------------
155 void PCollection_HAsciiString::Capitalize ()
156 {
157    for (Standard_Integer i = 0 ; i < Length() ; i++) {
158       if( i == 0) Data.SetValue(i, UpperCase(Data(i)) );
159       else Data.SetValue(i, LowerCase(Data(i)) );
160    }
161 }
162
163 //------------------------------------------------------------------------
164 //  Center
165 //------------------------------------------------------------------------
166 void PCollection_HAsciiString::Center 
167            (const Standard_Integer Width, const Standard_Character Filler)
168 {
169    if (Width < 0) Standard_NegativeValue::Raise();
170    Standard_Integer size1 = Length();
171    if(Width > size1) {
172       Standard_Integer size2 = size1 + ((Width - size1)/2);
173       LeftJustify(size2,Filler);
174       RightJustify(Width,Filler);
175    }
176 }
177
178 //------------------------------------------------------------------------
179 //  ChangeAll
180 //------------------------------------------------------------------------
181 void PCollection_HAsciiString::ChangeAll 
182      (const Standard_Character C, const Standard_Character NewC, const Standard_Boolean CaseSensitive)
183 {
184    for( Standard_Integer i = 0 ; i < Data.Length(); i++) {
185       if (CaseSensitive) {
186           if(Data(i) == C) Data.SetValue(i, NewC);
187       }
188       else {
189           if(UpperCase(Data(i)) == UpperCase(C)) Data.SetValue(i, NewC);
190       }
191    }
192 }
193
194 //------------------------------------------------------------------------
195 //  Clear
196 //------------------------------------------------------------------------
197 void PCollection_HAsciiString::Clear ()
198 {
199    Data.Resize(0);
200 }
201
202 //------------------------------------------------------------------------
203 //  Convert
204 //------------------------------------------------------------------------
205 TCollection_AsciiString PCollection_HAsciiString::Convert() const
206 {
207    Standard_Integer L = Length();
208    TCollection_AsciiString TString (L,' ');
209    for (Standard_Integer i = 1 ; i <= L ; i++) {
210       TString.SetValue(i,Value(i));
211    }
212    return TString;
213 }
214
215 //------------------------------------------------------------------------
216 //  FirstLocationInSet
217 //------------------------------------------------------------------------
218 Standard_Integer PCollection_HAsciiString::FirstLocationInSet 
219               (const Handle(PCollection_HAsciiString)& Set, 
220                const Standard_Integer FromIndex, 
221                const Standard_Integer ToIndex) const
222 {
223    if (Length() == 0 || Set->Length() == 0) return 0;
224    if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex ) 
225                      Standard_OutOfRange::Raise();
226    for(Standard_Integer i = FromIndex-1 ; i <= ToIndex-1; i++)
227      for(Standard_Integer j = 1; j <= Set->Length(); j++) 
228        if(Data(i) == Set->Value(j)) return (i+1);
229    return 0;
230 }
231
232 //------------------------------------------------------------------------
233 //  FirstLocationNotInset
234 //------------------------------------------------------------------------
235 Standard_Integer PCollection_HAsciiString::FirstLocationNotInSet 
236       (const Handle(PCollection_HAsciiString)& Set, const Standard_Integer FromIndex, 
237        const Standard_Integer ToIndex) const
238 {
239    if (Length() == 0 || Set->Length() == 0) return 0;
240    if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex ) 
241                      Standard_OutOfRange::Raise();
242    Standard_Boolean find;
243    for(Standard_Integer i = FromIndex-1 ; i <= ToIndex-1; i++) {
244      find = Standard_False;
245      for(Standard_Integer j = 1; j <= Set->Length(); j++) { 
246        if (Data(i) == Set->Value(j)) find = Standard_True;
247      }
248      if (!find)  return (i+1);
249    }
250    return 0;
251 }
252
253 //------------------------------------------------------------------------
254 //  InsertAfter
255 //------------------------------------------------------------------------
256 void PCollection_HAsciiString::InsertAfter 
257            (const Standard_Integer Index, const Handle(PCollection_HAsciiString)& S)
258 {
259    Standard_Integer i ;
260    Standard_Integer size1 = Length();
261    Standard_Integer size2 = S->Length();
262 #ifndef NOBOUNDCHECK
263    if (Index < 0 || Index > size1) Standard_OutOfRange::Raise();
264 #endif
265    Data.Resize(size1+size2);
266    for( i = size1-1 ; i >= Index; i--) Data.SetValue(size2+i,Data(i));
267    for( i = 1 ; i <= size2; i++) Data.SetValue(Index+i-1,S->Value(i));
268 }
269
270 //------------------------------------------------------------------------
271 //  InsertBefore
272 //------------------------------------------------------------------------
273 void PCollection_HAsciiString::InsertBefore 
274            (const Standard_Integer Index, const Handle(PCollection_HAsciiString)& S)
275 {
276    Standard_Integer i ;
277    Standard_Integer size1 = Length();
278    Standard_Integer size2 = S->Length();
279 #ifndef NOBOUNDCHECK
280    if (Index < 0 || Index > size1) Standard_OutOfRange::Raise();
281 #endif
282    Data.Resize(size1+size2);
283    for( i = size1-1 ; i >= Index-1 ; i--) 
284                                         Data.SetValue(size2+i,Data(i));
285   for( i = 1 ; i <= size2; i++) Data.SetValue(Index+i-2, S->Value(i));
286 }
287
288 //------------------------------------------------------------------------
289 //  IntegerValue
290 //------------------------------------------------------------------------
291 Standard_Integer PCollection_HAsciiString::IntegerValue () const
292 {
293    if (!IsIntegerValue()) Standard_NumericError::Raise();
294    return cnvint;
295 }
296
297 //------------------------------------------------------------------------
298 //  IsDifferent
299 //------------------------------------------------------------------------
300 Standard_Boolean PCollection_HAsciiString::IsDifferent 
301                             (const Handle(PCollection_HAsciiString)& S) const
302 {
303    Standard_Integer size = Length();
304    if( size != S->Length()) return Standard_True;
305    Standard_Integer i = 1 ;
306    Standard_Boolean different = Standard_False;
307    while (i <= size && !different) {
308       if (Data(i-1) != S->Value(i)) different = Standard_True;
309       i++;
310    }
311    return different;
312 }
313
314 //------------------------------------------------------------------------
315 //  IsEmpty
316 //------------------------------------------------------------------------
317 Standard_Boolean PCollection_HAsciiString::IsEmpty () const
318 {
319    return (Data.Length() == 0);
320 }
321
322 //------------------------------------------------------------------------
323 //  IsGreater
324 //------------------------------------------------------------------------
325 Standard_Boolean PCollection_HAsciiString::IsGreater
326                             (const Handle(PCollection_HAsciiString)& S) const
327 {
328    TCollection_AsciiString TMe = Convert();
329    TCollection_AsciiString TS  = S->Convert();
330    return TMe.IsGreater(TS);
331 }
332
333 //------------------------------------------------------------------------
334 //  IsIntegervalue
335 //------------------------------------------------------------------------
336 Standard_Boolean PCollection_HAsciiString::IsIntegerValue () const
337 {
338    Standard_Integer i ;
339 #if defined(__osf__) || defined(DECOSF1)
340 #ifdef OBJS
341  #pragma pointer_size (save)
342  #pragma pointer_size (long)
343    char *ptr;
344  #pragma pointer_size (restore)
345 #else
346    char *ptr;
347 #endif
348 #else
349    char *ptr;
350 #endif
351 #ifndef NOBOUNDCHECK
352    if ( Data.Length() > MAXLENGTH ) return Standard_False;
353 #endif
354    Handle(TCollection_HAsciiString) astring;
355    astring  = new TCollection_HAsciiString (this->Convert());
356    astring->LeftAdjust();
357    astring->RightAdjust(); 
358    for(i = 0; i < astring->Length(); i++) 
359                             cnvbuf[i] = astring->Value(i+1);
360    cnvbuf[i] = 0;
361    cnvint = strtol(cnvbuf,&ptr,10);
362    if (ptr < cnvbuf+astring->Length()) return Standard_False;
363    else                                return Standard_True;
364 }
365
366 //------------------------------------------------------------------------
367 //  Isless
368 //------------------------------------------------------------------------
369 Standard_Boolean PCollection_HAsciiString::IsLess 
370                             (const Handle(PCollection_HAsciiString)& S) const
371 {
372    TCollection_AsciiString TMe = Convert();
373    TCollection_AsciiString TS  = S->Convert();
374    return TMe.IsLess(TS);
375 }
376
377 //------------------------------------------------------------------------
378 //  IsRealValue
379 //------------------------------------------------------------------------
380 Standard_Boolean PCollection_HAsciiString::IsRealValue () const
381 {
382    Standard_Integer i ;
383 #if defined(__osf__) || defined(DECOSF1)
384 #ifdef OBJS
385  #pragma pointer_size (save)
386  #pragma pointer_size (long)
387    char *ptr;
388  #pragma pointer_size (restore)
389 #else
390    char *ptr;
391 #endif
392 #else
393    char *ptr;
394 #endif
395 #ifndef NOBOUNDCHECK
396    if ( Data.Length() > MAXLENGTH ) return Standard_False;
397 #endif
398    Handle(TCollection_HAsciiString) astring;
399    astring  = new TCollection_HAsciiString (this->Convert());
400    astring->LeftAdjust();
401    astring->RightAdjust(); 
402    for(i = 0; i < astring->Length(); i++)
403                             cnvbuf[i] = astring->Value(i+1);
404    cnvbuf[i] = 0;
405    cnvreal = Strtod(cnvbuf,&ptr);
406    if (ptr < cnvbuf+astring->Length()) return Standard_False;
407    else                                return Standard_True;
408 }
409
410 //------------------------------------------------------------------------
411 //  IsSameString
412 //------------------------------------------------------------------------
413 Standard_Boolean PCollection_HAsciiString::IsSameString 
414                         (const Handle(PCollection_HAsciiString)& S) const
415 {
416    Standard_Integer i ;
417    Standard_Integer size1 = Length();
418    if( size1 != S->Length()) return Standard_False;
419    for( i = 1 ; i <= size1; i++) {
420      if(Data(i-1) != S->Value(i)) return Standard_False;
421    }
422    return Standard_True;
423 }
424
425 //------------------------------------------------------------------------
426 //  IsSameString
427 //------------------------------------------------------------------------
428 Standard_Boolean PCollection_HAsciiString::IsSameString 
429   (const Handle(PCollection_HAsciiString)& S, const Standard_Boolean CaseSensitive) const
430 {
431    Standard_Integer size1 = Length();
432    if( size1 != S->Length()) return Standard_False;
433    for( Standard_Integer i = 1 ; i <= size1; i++) {
434      if(CaseSensitive){
435        if(Data(i-1) != S->Value(i)) return Standard_False;
436      }
437      else {
438        if(UpperCase(Data(i-1)) != UpperCase(S->Value(i))) return Standard_False;
439      }
440    }
441    return Standard_True;
442 }
443
444 //------------------------------------------------------------------------
445 //  LeftAdjust
446 //------------------------------------------------------------------------
447 void PCollection_HAsciiString::LeftAdjust ()
448 {
449    Standard_Integer i ;
450    for(i = 0 ; i < Data.Length() ; i ++) if(!IsSpace(Data(i))) break;
451    if( i > 0 ) Remove(1,i);
452 }
453
454 //------------------------------------------------------------------------
455 //  LeftJustify
456 //------------------------------------------------------------------------
457 void PCollection_HAsciiString::LeftJustify 
458      (const Standard_Integer Width, const Standard_Character Filler)
459 {
460    if (Width < 0) Standard_NegativeValue::Raise();
461    Standard_Integer size1 = Length();
462    if(Width > size1) {
463      Data.Resize(Width);
464      for(Standard_Integer i = size1; i < Width ; i++) Data.SetValue(i, Filler);
465    }
466 }
467
468 //------------------------------------------------------------------------
469 //  Length
470 //------------------------------------------------------------------------
471 Standard_Integer PCollection_HAsciiString::Length () const
472 {
473    return Data.Length();
474 }
475
476 //------------------------------------------------------------------------
477 //  Location
478 //------------------------------------------------------------------------
479 Standard_Integer PCollection_HAsciiString::Location 
480    (const Standard_Integer N, const Standard_Character C, 
481     const Standard_Integer FromIndex, const Standard_Integer ToIndex) const
482 {
483    if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex ) 
484                       Standard_OutOfRange::Raise();
485    for(Standard_Integer i = FromIndex-1, count = 0; i <= ToIndex-1; i++) 
486               if(Data(i) == C) {
487                 count++;
488                 if ( count == N ) return (i+1);
489               }
490    return 0 ;
491 }
492
493 //------------------------------------------------------------------------
494 //  Location
495 //------------------------------------------------------------------------
496 Standard_Integer PCollection_HAsciiString::Location 
497         (const Handle(PCollection_HAsciiString)& S, const Standard_Integer FromIndex, 
498          const Standard_Integer ToIndex) const
499 {
500    if (Length() == 0 || S->Length() == 0) return 0;
501    if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex ) 
502                       Standard_OutOfRange::Raise();
503    for(Standard_Integer i = FromIndex-1, k = 1, l = FromIndex-2; i < ToIndex; i++){
504      if(Data(i) == S->Value(k)) {
505        k++;
506        if ( k > S->Length()) return l + 2;
507      }
508      else {
509        k = 1;
510        l = i;
511      }
512   }
513   return 0;
514 }
515
516 //------------------------------------------------------------------------
517 //  Lowercase
518 //------------------------------------------------------------------------
519 void PCollection_HAsciiString::Lowercase ()
520 {
521    for( Standard_Integer i = 0 ; i < Data.Length() ; i++) {
522      Data.SetValue(i, LowerCase(Data(i)));
523    }
524 }
525
526 //------------------------------------------------------------------------
527 //  Prepend
528 //------------------------------------------------------------------------
529 void PCollection_HAsciiString::Prepend 
530                     (const Handle(PCollection_HAsciiString)& S)
531 {
532    InsertAfter(0,S);
533 }
534
535
536 //------------------------------------------------------------------------
537 //  Print
538 //------------------------------------------------------------------------
539 void PCollection_HAsciiString::Print (Standard_OStream& S) const
540 {
541    Standard_Integer len = Data.Length() ;
542    for(Standard_Integer i = 0; i < len ; i++) {
543        S << Data(i);
544    }
545 }
546
547 //------------------------------------------------------------------------
548 //  RealValue
549 //------------------------------------------------------------------------
550 Standard_Real PCollection_HAsciiString::RealValue () const
551 {
552    if(!IsRealValue()) Standard_NumericError::Raise();
553    return cnvreal;
554 }
555
556 //------------------------------------------------------------------------
557 //  Remove
558 //------------------------------------------------------------------------
559 void PCollection_HAsciiString::Remove (const Standard_Integer Index)
560 {
561    if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
562    Remove(Index,Index);
563 }
564
565 //------------------------------------------------------------------------
566 //  Remove
567 //------------------------------------------------------------------------
568 void PCollection_HAsciiString::Remove 
569     (const Standard_Integer FromIndex, const Standard_Integer ToIndex)
570 {
571    if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex ) 
572                      Standard_OutOfRange::Raise();
573    Standard_Integer size1 = Length();
574    for( Standard_Integer i = ToIndex, j = FromIndex-1; i < size1 ; i++, j++)
575      Data.SetValue(j,Data(i));
576    Data.Resize(size1-(ToIndex-FromIndex+1));
577 }
578
579 //------------------------------------------------------------------------
580 //  RemoveAll
581 //------------------------------------------------------------------------
582 void PCollection_HAsciiString::RemoveAll 
583     (const Standard_Character C, const Standard_Boolean CaseSensitive)
584 {
585    Standard_Integer i ;
586    Standard_Integer j ;
587    Standard_Integer size1 = Length();
588    for( i = 0, j = 0; i < size1 ; i++){
589      if(CaseSensitive){
590        if(Data(i) == C) continue;
591      }
592      else {
593        if(UpperCase(Data(i)) == UpperCase(C))  continue;
594      }
595      Data.SetValue(j++, Data(i));
596     }
597     Data.Resize(j);
598 }
599
600 //------------------------------------------------------------------------
601 //  RightAdjust
602 //------------------------------------------------------------------------
603 void PCollection_HAsciiString::RightAdjust ()
604 {
605    Standard_Integer i ;
606    for( i = Data.Length()-1 ; i >= 0 ; i--) if(!IsSpace(Data(i))) break;
607    if( i < Data.Length()-1 ) Remove(i+2,Data.Length());
608 }
609
610 //------------------------------------------------------------------------
611 //  RightJustify
612 //------------------------------------------------------------------------
613 void PCollection_HAsciiString::RightJustify 
614            (const Standard_Integer Width, const Standard_Character Filler)
615 {
616    Standard_Integer i ;
617    Standard_Integer k ;
618    if (Width < 0) Standard_NegativeValue::Raise();
619    Standard_Integer size1 = Length();
620    if(Width > size1) {
621       Data.Resize(Width);
622       for ( i = size1-1, k = Width-1 ; i >= 0 ; i--, k--) 
623                Data.SetValue(k, Data(i));
624       for(; k >= 0 ; k--) Data.SetValue(k, Filler);
625    }
626 }
627
628 //------------------------------------------------------------------------
629 //  SetValue
630 //------------------------------------------------------------------------
631 void PCollection_HAsciiString::SetValue 
632            (const Standard_Integer Index, const Handle(PCollection_HAsciiString)& S)
633 {
634
635    Standard_Integer size1 = Length();
636    Standard_Integer size2 = S->Length();
637    Standard_Integer size3 = size2 + Index - 1;
638 #ifndef NOBOUNDCHECK
639    if (Index < 0 || Index > size1) Standard_OutOfRange::Raise();
640 #endif
641    if(size1 != size3) Data.Resize(size3);
642    for( Standard_Integer i = 1 ; i <= size2; i++) Data.SetValue(Index+i-2, S->Value(i));
643 }
644
645 //------------------------------------------------------------------------
646 //  SetValue
647 //------------------------------------------------------------------------
648 void PCollection_HAsciiString::SetValue 
649                 (const Standard_Integer Index, const Standard_Character C)
650 {
651    if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
652    Data(Index-1) = C;
653 }
654
655 //------------------------------------------------------------------------
656 //  Split
657 //------------------------------------------------------------------------
658 Handle(PCollection_HAsciiString) PCollection_HAsciiString::Split 
659              (const Standard_Integer Index)
660 {
661    if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
662    Handle(PCollection_HAsciiString) S2;
663    if (Index != Length()) { 
664       S2 = SubString(Index+1,Length());
665       Data.Resize(Index);
666    }
667    else {
668 #ifndef OBJS
669       S2 = new PCollection_HAsciiString("");
670 #else
671       S2 = new (os_segment::of(this)) PCollection_HAsciiString("");
672 #endif
673    }
674    return S2;
675 }
676
677 //------------------------------------------------------------------------
678 //  SubString
679 //------------------------------------------------------------------------
680 Handle(PCollection_HAsciiString) PCollection_HAsciiString::SubString 
681              (const Standard_Integer FromIndex, const Standard_Integer ToIndex) const
682 {
683    if (ToIndex > Length() || FromIndex <= 0 || FromIndex > ToIndex ) 
684                       Standard_OutOfRange::Raise();
685    Handle(PCollection_HAsciiString) S1;
686    Handle(PCollection_HAsciiString) S2;
687    S2 = this;
688 #ifndef OBJS
689    S1 = new PCollection_HAsciiString(S2,FromIndex,ToIndex);
690 #else
691    S1 = new (os_segment::of(this)) PCollection_HAsciiString(S2,FromIndex,ToIndex);
692
693 #endif
694    return S1;
695 }
696
697 //------------------------------------------------------------------------
698 //  Token
699 //------------------------------------------------------------------------
700 Handle(PCollection_HAsciiString) PCollection_HAsciiString::Token 
701                                    (const Standard_CString separators , 
702                                     const Standard_Integer whichone) const
703 {
704    TCollection_AsciiString TMe = Convert();
705    Handle(PCollection_HAsciiString) 
706 #ifndef OBJS
707        TheToken = new PCollection_HAsciiString(TMe.Token(separators,whichone));
708 #else
709        TheToken = new (os_segment::of(this)) PCollection_HAsciiString(TMe.Token(separators,whichone));
710 #endif
711    return TheToken;
712 }
713
714 //------------------------------------------------------------------------
715 //  Uppercase
716 //------------------------------------------------------------------------
717 void PCollection_HAsciiString::Uppercase ()
718 {
719    for( Standard_Integer i = 0 ; i < Data.Length() ; i++) 
720        Data.SetValue(i, UpperCase(Data(i)));
721 }
722
723 //------------------------------------------------------------------------
724 //  UsefullLength
725 //------------------------------------------------------------------------
726 Standard_Integer PCollection_HAsciiString::UsefullLength () const
727 {
728    Standard_Integer i ;
729    for( i = Data.Length() -1 ; i >= 0 ; i--) 
730       if(IsGraphic(Data(i))) break;
731    return (i+1) ;
732 }
733
734 //------------------------------------------------------------------------
735 //  value
736 //------------------------------------------------------------------------
737 Standard_Character PCollection_HAsciiString::Value (const Standard_Integer Index) const
738 {
739    if (Index < 0 || Index > Length()) Standard_OutOfRange::Raise();
740    return Data(Index-1);
741 }
742
743
744
745 //------------------------------------------------------------------------
746 //  Assign
747 //------------------------------------------------------------------------
748 void PCollection_HAsciiString::Assign(const DBC_VArrayOfCharacter& TheField)
749
750 {
751    Data = TheField;
752 }
753
754 //------------------------------------------------------------------------
755 //  ShallowDump
756 //------------------------------------------------------------------------
757 void PCollection_HAsciiString::ShallowDump(Standard_OStream& S) const
758 {
759    S << "begin class HAsciiString " << endl;
760    ::ShallowDump(Data, S);
761    S << "end class HAsciiString" << endl;
762 }