cosv/source/strings/streamstr.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: streamstr.cxx,v $
  10  * $Revision: 1.14.10.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <precomp.h>
  32 #include <cosv/streamstr.hxx>
  33
  34 // NOT FULLY DECLARED SERVICES
  35 #include <string.h>
  36 #include <stdio.h>
  37 #include <stdarg.h> // both are needed to satisfy all compilers
  38 #include <cstdarg>      // std::va_list and friends
  39
  40 #include <cosv/comfunc.hxx>
  41 #include <cosv/tpl/swelist.hxx>
  42
  43
  44
  45 namespace csv
  46 {
  47
  48
  49 // Maximal sizes of resulting integers in text form:
  50 const uintt C_short_max_size    = sizeof(short) * 3;
  51 const uintt C_int_max_size      = sizeof(int) * 3;
  52 const uintt C_long_max_size     = sizeof(long) * 3;
  53
  54
  55 inline void
  56 StreamStr::Advance(size_type i_nAddedSize)
  57 { pCur += i_nAddedSize; }
  58
  59
  60
  61 StreamStr::StreamStr( size_type     i_nCapacity )
  62     :   bostream(),
  63         nCapacity1( i_nCapacity + 1 ),
  64         dpData( new char [i_nCapacity + 1] ),
  65         pEnd(dpData),
  66         pCur(dpData),
  67         eMode(str::overwrite)
  68 {
  69     *pEnd = '\0';
  70 }
  71
  72 StreamStr::StreamStr( const char *  i_sInitStr,
  73                       size_type     i_nCapacity )
  74     :   bostream(),
  75         nCapacity1(0),
  76         dpData(0),
  77         pEnd(0),
  78         pCur(0),
  79         eMode(str::overwrite)
  80 {
  81     size_type nLength = strlen(i_sInitStr);
  82     nCapacity1 = csv::max(nLength, i_nCapacity) + 1;
  83     dpData = new char [nCapacity1];
  84     strcpy(dpData, i_sInitStr);     // SAFE STRCPY (#100211# - checked)
  85     pCur = dpData + nLength;
  86     pEnd = pCur;
  87 }
  88
  89 StreamStr::StreamStr( size_type         i_nGuessedCapacity,
  90                       const char *              str1,
  91                       const char *      str2,
  92                                         ... )
  93     :   bostream(),
  94         nCapacity1( i_nGuessedCapacity + 1 ),
  95         dpData( new char [i_nGuessedCapacity + 1] ),
  96         pEnd(dpData),
  97         pCur(dpData),
  98         eMode(str::overwrite)
  99 {
 100     *pEnd = '\0';
 101
 102     operator<<(str1);
 103     operator<<(str2);
 104
 105     ::va_list ap;
 106
 107     va_start(ap, str2);
 108     for ( const char * strAdd = va_arg(ap,const char*);
 109           strAdd != 0;
 110           strAdd = va_arg(ap,const char*) )
 111     {
 112         size_type nLen = strlen(strAdd);
 113         ProvideAddingSize( nLen );
 114         memcpy(pCur, strAdd, nLen);
 115         Advance(nLen);
 116     }  // end for
 117     va_end(ap);
 118 }
 119
 120 StreamStr::StreamStr( const self & i_rOther )
 121     :   bostream(),
 122         nCapacity1( i_rOther.nCapacity1 ),
 123         dpData( new char [i_rOther.nCapacity1] ),
 124         pEnd( dpData + strlen(i_rOther.dpData) ),
 125         pCur( dpData + i_rOther.tellp() ),
 126         eMode(i_rOther.eMode)
 127 {
 128     strcpy( dpData, i_rOther.dpData );      // SAFE STRCPY (#100211# - checked)
 129 }
 130
 131 StreamStr::StreamStr(csv::bstream & i_source)
 132     :   bostream(),
 133         nCapacity1(0),
 134         dpData(0),
 135         pEnd(0),
 136         pCur(0),
 137         eMode(str::overwrite)
 138 {
 139     i_source.seek(0, csv::end);
 140     nCapacity1 = static_cast<size_type>(i_source.position()) + 1;
 141     i_source.seek(0);
 142
 143     dpData = new char[nCapacity1];
 144     i_source.read(dpData, nCapacity1 - 1);
 145     pCur = dpData + nCapacity1 - 1;
 146     pEnd = pCur;
 147     *pCur = '\0';
 148 }
 149
 150 StreamStr::~StreamStr()
 151 {
 152     delete [] dpData;
 153 }
 154
 155
 156 StreamStr &
 157 StreamStr::operator=( const self & i_rOther )
 158 {
 159     delete [] dpData;
 160
 161     nCapacity1 = i_rOther.nCapacity1;
 162     dpData = new char [i_rOther.nCapacity1];
 163     pEnd = dpData + strlen(i_rOther.dpData);
 164     strcpy( dpData, i_rOther.dpData );          // SAFE STRCPY (#100211# - checked)
 165     pCur = dpData + i_rOther.tellp();
 166     eMode = i_rOther.eMode;
 167
 168     return *this;
 169 }
 170
 171 StreamStr &
 172 StreamStr::operator<<( const char * i_s )
 173 {
 174     size_type nLength = strlen(i_s);
 175
 176     ProvideAddingSize( nLength );
 177     memcpy( pCur, i_s, nLength );
 178     Advance(nLength);
 179
 180     return *this;
 181 }
 182
 183 StreamStr &
 184 StreamStr::operator<<( const String & i_s )
 185 {
 186     size_type nLength = i_s.length();
 187
 188     ProvideAddingSize( nLength );
 189     memcpy( pCur, i_s.c_str(), nLength );
 190     Advance(nLength);
 191
 192     return *this;
 193 }
 194
 195 StreamStr &
 196 StreamStr::operator<<( char i_c )
 197 {
 198     ProvideAddingSize( 1 );
 199     *pCur = i_c;
 200     Advance(1);
 201
 202     return *this;
 203 }
 204
 205 StreamStr &
 206 StreamStr::operator<<( unsigned char i_c )
 207 {
 208     return operator<<( char(i_c) );
 209 }
 210
 211 StreamStr &
 212 StreamStr::operator<<( signed char i_c )
 213 {
 214     return operator<<( char(i_c) );
 215 }
 216
 217 StreamStr &
 218 StreamStr::operator<<( short i_n )
 219 {
 220     char buf[C_short_max_size] = "";
 221     sprintf( buf, "%hi", i_n );         // SAFE SPRINTF (#100211# - checked)
 222
 223     size_type nLength = strlen(buf);
 224     ProvideAddingSize( nLength );
 225     memcpy( pCur, buf, nLength );
 226     Advance( nLength );
 227
 228     return *this;
 229 }
 230
 231 StreamStr &
 232 StreamStr::operator<<( unsigned short i_n )
 233 {
 234     char buf[C_short_max_size] = "";
 235     sprintf( buf, "%hu", i_n );         // SAFE SPRINTF (#100211# - checked)
 236
 237     size_type nLength = strlen(buf);
 238     ProvideAddingSize( nLength );
 239     memcpy( pCur, buf, nLength );
 240     Advance( nLength );
 241
 242     return *this;
 243 }
 244
 245 StreamStr &
 246 StreamStr::operator<<( int i_n )
 247 {
 248     char buf[C_int_max_size] = "";
 249     sprintf( buf, "%i", i_n );          // SAFE SPRINTF (#100211# - checked)
 250
 251     size_type nLength = strlen(buf);
 252     ProvideAddingSize( nLength );
 253     memcpy( pCur, buf, nLength );
 254     Advance( nLength );
 255
 256     return *this;
 257 }
 258
 259 StreamStr &
 260 StreamStr::operator<<( unsigned int i_n )
 261 {
 262     char buf[C_int_max_size] = "";
 263     sprintf( buf, "%u", i_n );          // SAFE SPRINTF (#100211# - checked)
 264
 265     size_type nLength = strlen(buf);
 266     ProvideAddingSize( nLength );
 267     memcpy( pCur, buf, nLength );
 268     Advance( nLength );
 269
 270     return *this;
 271 }
 272
 273 StreamStr &
 274 StreamStr::operator<<( long i_n )
 275 {
 276     char buf[C_long_max_size] = "";
 277     sprintf( buf, "%li", i_n );         // SAFE SPRINTF (#100211# - checked)
 278
 279     size_type nLength = strlen(buf);
 280     ProvideAddingSize( nLength );
 281     memcpy( pCur, buf, nLength );
 282     Advance( nLength );
 283
 284     return *this;
 285 }
 286
 287 StreamStr &
 288 StreamStr::operator<<( unsigned long i_n )
 289 {
 290     char buf[C_long_max_size] = "";
 291     sprintf( buf, "%lu", i_n );         // SAFE SPRINTF (#100211# - checked)
 292
 293     size_type nLength = strlen(buf);
 294     ProvideAddingSize( nLength );
 295     memcpy( pCur, buf, nLength );
 296     Advance( nLength );
 297
 298     return *this;
 299 }
 300
 301 StreamStr &
 302 StreamStr::operator<<( float i_n )
 303 {
 304     const int C_float_max_size = 20;
 305     char buf[C_float_max_size] = "";
 306     sprintf( buf, "%.*g", C_float_max_size-8, i_n );    // SAFE SPRINTF (#100211# - checked)
 307
 308     size_type nLength = strlen(buf);
 309     ProvideAddingSize( nLength );
 310     memcpy( pCur, buf, nLength );
 311     Advance( nLength );
 312
 313     return *this;
 314 }
 315
 316 StreamStr &
 317 StreamStr::operator<<( double i_n )
 318 {
 319     const int C_double_max_size = 30;
 320     char buf[C_double_max_size] = "";
 321     sprintf( buf, "%.*lg", C_double_max_size-8, i_n );  // SAFE SPRINTF (#100211# - checked)
 322
 323     size_type nLength = strlen(buf);
 324     ProvideAddingSize( nLength );
 325     memcpy( pCur, buf, nLength );
 326     Advance( nLength );
 327
 328     return *this;
 329 }
 330
 331 const char &
 332 StreamStr::operator[]( position_type i_nPosition ) const
 333 {
 334     static const char aNull_ = '\0';
 335
 336     if ( position_type(pEnd - dpData) > i_nPosition )
 337         return dpData[i_nPosition];
 338     return aNull_;
 339 }
 340
 341 char &
 342 StreamStr::operator[]( position_type i_nPosition )
 343 {
 344     static char aDummy_ = '\0';
 345
 346     if ( position_type(pEnd - dpData) > i_nPosition )
 347         return dpData[i_nPosition];
 348     return aDummy_;
 349 }
 350
 351 void
 352 StreamStr::resize( size_type i_nMinimumCapacity )
 353 {
 354     if ( i_nMinimumCapacity <= capacity() )
 355         return;
 356
 357     Resize(i_nMinimumCapacity);
 358 }
 359
 360 void
 361 StreamStr::swap( StreamStr & io_swap )
 362 {
 363     size_type
 364         n = io_swap.nCapacity1;
 365     io_swap.nCapacity1 = nCapacity1;
 366     nCapacity1 = n;
 367
 368     char *
 369         p = io_swap.dpData;
 370     io_swap.dpData = dpData;
 371     dpData = p;
 372
 373     p = io_swap.pEnd;
 374     io_swap.pEnd = pEnd;
 375     pEnd = p;
 376
 377     p = io_swap.pCur;
 378     io_swap.pCur = pCur;
 379     pCur = p;
 380
 381     insert_mode
 382         m = io_swap.eMode;
 383     io_swap.eMode = eMode;
 384     eMode = m;
 385 }
 386
 387 StreamStr &
 388 StreamStr::seekp( seek_type           i_nCount,
 389                   seek_dir            i_eDirection )
 390 {
 391     seek_type nLength = seek_type( length() );
 392     seek_type nNewPos = tellp();
 393
 394     switch ( i_eDirection )
 395     {
 396          case ::csv::beg:  nNewPos = i_nCount;
 397                           break;
 398         case ::csv::cur:  nNewPos += i_nCount;
 399                           break;
 400         case ::csv::end:  nNewPos = nLength + i_nCount;
 401                           break;
 402     }
 403
 404     if ( in_range<seek_type>(0, nNewPos, nLength + 1) )
 405     {
 406         pCur = dpData + nNewPos;
 407         if (eMode == str::overwrite)
 408         {
 409              pEnd = pCur;
 410             *pEnd = '\0';
 411         }
 412     }
 413
 414     return *this;
 415 }
 416
 417 StreamStr &
 418 StreamStr::set_insert_mode( insert_mode i_eMode )
 419 {
 420     eMode = i_eMode;
 421     return *this;
 422 }
 423
 424 void
 425 StreamStr::push_front( const char * i_str )
 426 {
 427     insert_mode eOriginalMode = eMode;
 428     char * pOriginalCur = pCur;
 429     eMode = str::insert;
 430     pCur = dpData;
 431
 432     operator<<(i_str);
 433
 434     eMode = eOriginalMode;
 435     pCur = pOriginalCur + strlen(i_str);
 436 }
 437
 438 void
 439 StreamStr::push_front( char i_c )
 440 {
 441     insert_mode eOriginalMode = eMode;
 442     char * pOriginalCur = pCur;
 443     eMode = str::insert;
 444     pCur = dpData;
 445
 446     operator<<(i_c);
 447
 448     eMode = eOriginalMode;
 449     pCur = pOriginalCur + 1;
 450 }
 451
 452 void
 453 StreamStr::push_back( const char * i_str )
 454 {
 455     insert_mode eOriginalMode = eMode;
 456     eMode = str::overwrite;
 457
 458     operator<<(i_str);
 459
 460     eMode = eOriginalMode;
 461 }
 462
 463 void
 464 StreamStr::push_back( char i_c )
 465 {
 466     insert_mode eOriginalMode = eMode;
 467     eMode = str::overwrite;
 468
 469     operator<<(i_c);
 470
 471     eMode = eOriginalMode;
 472 }
 473
 474 void
 475 StreamStr::pop_front( size_type i_nCount )
 476 {
 477     size_type nCount = min(i_nCount, length());
 478
 479     MoveData( dpData + nCount, pEnd, -(seek_type(nCount)) );
 480
 481     pCur -= nCount;
 482     pEnd -= nCount;
 483     *pEnd = '\0';
 484 }
 485
 486 void
 487 StreamStr::pop_back( size_type i_nCount )
 488 {
 489     size_type nCount = min(i_nCount, length());
 490     pEnd -= nCount;
 491     if (pCur > pEnd)
 492         pCur = pEnd;
 493     *pEnd = '\0';
 494 }
 495
 496 StreamStr &
 497 StreamStr::operator_join( std::vector<String>::const_iterator i_rBegin,
 498                           std::vector<String>::const_iterator i_rEnd,
 499                           const char *                        i_sLink )
 500 {
 501     std::vector<String>::const_iterator it = i_rBegin;
 502     if ( it != i_rEnd )
 503     {
 504         operator<<(*it);
 505         for ( ++it; it != i_rEnd; ++it )
 506         {
 507             operator<<(i_sLink);
 508             operator<<(*it);
 509         }
 510     }
 511     return *this;
 512 }
 513
 514 StreamStr &
 515 StreamStr::operator_add_substr( const char *        i_sText,
 516                                 size_type           i_nLength )
 517 {
 518     size_type nLength = csv::min<size_type>(i_nLength, strlen(i_sText));
 519
 520     ProvideAddingSize( nLength );
 521     memcpy( pCur, i_sText, nLength );
 522     Advance(nLength);
 523
 524     return *this;
 525 }
 526
 527 StreamStr &
 528 StreamStr::operator_add_token( const char *        i_sText,
 529                                char                i_cDelimiter )
 530 {
 531     const char * pTokenEnd = strchr(i_sText, i_cDelimiter);
 532     if (pTokenEnd == 0)
 533         operator<<(i_sText);
 534     else
 535         operator_add_substr(i_sText, pTokenEnd-i_sText);
 536     return *this;
 537 }
 538
 539 StreamStr &
 540 StreamStr::operator_read_line( bstream & i_src )
 541 {
 542     char c = 0;
 543     intt nCount = 0;
 544     for ( nCount = i_src.read(&c, 1);
 545           nCount == 1 AND c != 13 AND c != 10;
 546           nCount = i_src.read(&c, 1) )
 547     {
 548         operator<<(c);
 549     }
 550
 551     bool bEndOfStream = nCount == 0;
 552     // Check for line-end:
 553     if ( NOT bEndOfStream AND c != 0 )
 554     {
 555         char oldc = c;
 556           if (i_src.read(&c, 1) == 1)
 557         {
 558             if ( (c != 13 AND c != 10) OR c == oldc)
 559                 i_src.seek(-1,::csv::cur);
 560         }
 561     }
 562     return *this;
 563 }
 564
 565 void
 566 StreamStr::strip_front(char i_cToRemove)
 567 {
 568     const_iterator it = begin();
 569     for ( ;
 570           it != end() ? *it == i_cToRemove : false;
 571           ++it ) ;
 572     pop_front(it - begin());
 573 }
 574
 575 void
 576 StreamStr::strip_back(char i_cToRemove)
 577 {
 578     const_iterator it = end();
 579     for ( ;
 580           it != begin() ? *(it-1) == i_cToRemove : false;
 581           --it ) ;
 582     pop_back(end() - it);
 583 }
 584
 585 void
 586 StreamStr::strip_frontback(char i_cToRemove)
 587 {
 588     strip_front(i_cToRemove);
 589     strip_back(i_cToRemove);
 590 }
 591
 592 void
 593 StreamStr::strip_front_whitespace()
 594 {
 595     const_iterator it = begin();
 596     for ( ;
 597           it != end() ? *it < 33 : false;
 598           ++it ) ;
 599     pop_front(it - begin());
 600 }
 601
 602 void
 603 StreamStr::strip_back_whitespace()
 604 {
 605     const_iterator it = end();
 606     for ( ;
 607           it != begin() ? *(it-1) < 33 : false;
 608           --it ) ;
 609     pop_back(end() - it);
 610 }
 611
 612 void
 613 StreamStr::strip_frontback_whitespace()
 614 {
 615     strip_front_whitespace();
 616     strip_back_whitespace();
 617 }
 618
 619 void
 620 StreamStr::remove(  iterator            i_begin,
 621                     iterator            i_end )
 622 {
 623     csv_assert(i_begin >= dpData AND i_begin <= pEnd);
 624     csv_assert(i_end >= dpData AND i_end <= pEnd);
 625     csv_assert(i_end >= i_begin);
 626     MoveData(i_end, pEnd, i_begin - i_end);
 627     pCur = pEnd;
 628 }
 629
 630 void
 631 StreamStr::replace( position_type       i_nStart,
 632                     size_type           i_nSize,
 633                     Area                i_aReplacement )
 634 {
 635     if (i_nStart >= length() OR i_nSize < 1)
 636       return;
 637
 638     insert_mode eOldMode = eMode;
 639     eMode = str::insert;
 640     pCur = dpData + i_nStart;
 641
 642     size_type anz = min( length() - i_nStart, i_nSize );
 643
 644     if ( anz < i_aReplacement.nLength )
 645     {
 646         ProvideAddingSize( i_aReplacement.nLength - anz );
 647     }
 648     else if ( anz > i_aReplacement.nLength )
 649     {
 650         seek_type nMove = seek_type(anz - i_aReplacement.nLength);
 651
 652         MoveData( dpData + i_nStart + anz,
 653                   pEnd,
 654                   -nMove );
 655         pEnd -= nMove;
 656         *pEnd = '\0';
 657     }
 658
 659     if (i_aReplacement.nLength > 0)
 660     {
 661         memcpy( dpData + i_nStart, i_aReplacement.sStr, i_aReplacement.nLength );
 662         Advance(i_aReplacement.nLength);
 663     }
 664
 665     eMode = eOldMode;
 666     pCur = pEnd;
 667 }
 668
 669 void
 670 StreamStr::replace_all( char i_cCarToSearch,
 671                         char i_cReplacement )
 672 {
 673    for ( char * p = dpData; p != pEnd; ++p )
 674    {
 675         if (*p == i_cCarToSearch)
 676             *p = i_cReplacement;
 677    }
 678 }
 679
 680 void
 681 StreamStr::replace_all( Area                i_aStrToSearch,
 682                         Area                i_aReplacement )
 683 {
 684     position_type p = 0;
 685     const char *  pSearch = i_aStrToSearch.sStr;
 686     size_type     nSearch = i_aStrToSearch.nLength;
 687
 688     while ( p <= length() - nSearch )
 689     {
 690         if ( strncmp(dpData+p, pSearch, nSearch) == 0 )
 691         {
 692             replace( p, nSearch, i_aReplacement );
 693             p += i_aReplacement.nLength;
 694         }
 695         else
 696         {
 697             ++p;
 698         }
 699    }    // end while
 700 }
 701
 702 StreamStr &
 703 StreamStr::to_lower( position_type       i_nStart,
 704                      size_type           i_nLength )
 705 {
 706     static char cLower[128] =
 707     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 708      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 709      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 710      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 711      64, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 712     112,113,114,115,116,117,118,119,120,121,122, 91, 92, 93, 94, 95,
 713      96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
 714     112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127 };
 715
 716     if ( i_nStart < length() )
 717     {
 718         char * pStop = i_nStart + i_nLength < length()
 719                             ?   dpData + i_nStart + i_nLength
 720                             :   pEnd;
 721         for ( char * pChange = dpData + i_nStart;
 722               pChange != pStop;
 723               ++pChange )
 724         {
 725             *pChange =  (static_cast< unsigned char >(*pChange) & 0x80) == 0
 726                             ?   cLower[ UINT8(*pChange) ]
 727                             :   *pChange;
 728         }
 729     }
 730     return *this;
 731 }
 732
 733 StreamStr &
 734 StreamStr::to_upper( position_type       i_nStart,
 735                      size_type           i_nLength )
 736 {
 737     static char cUpper[128] =
 738     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 739      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 740      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 741      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 742      64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 743      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
 744      96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 745      80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123,124,125,126,127 };
 746
 747     if ( i_nStart < length() )
 748     {
 749         char * pStop = i_nStart + i_nLength < length()
 750                             ?   dpData + i_nStart + i_nLength
 751                             :   pEnd;
 752         for ( char * pChange = dpData + i_nStart;
 753               pChange != pStop;
 754               ++pChange )
 755         {
 756             *pChange =  (static_cast< unsigned char >(*pChange) & 0x80) == 0
 757                             ?   cUpper[ UINT8(*pChange) ]
 758                             :   *pChange;
 759         }
 760     }
 761     return *this;
 762 }
 763
 764
 765 StreamStr::size_type
 766 StreamStr::token_count( char i_cSplit ) const
 767 {
 768     return count_chars(dpData, i_cSplit) + 1;
 769 }
 770
 771 String
 772 StreamStr::token( position_type i_nNr,
 773                   char          i_cSplit ) const
 774 {
 775     // Find begin:
 776     const char * pTokenBegin = dpData;
 777        for ( position_type nNr = i_nNr;
 778           nNr > 0;
 779           --nNr )
 780     {
 781         pTokenBegin = strchr(pTokenBegin,i_cSplit);
 782         if (pTokenBegin == 0)
 783             return String("");
 784         ++pTokenBegin;
 785     }
 786
 787     // Find end:
 788     const char * pTokenEnd = strchr(pTokenBegin, i_cSplit);
 789     if (pTokenEnd == 0)
 790         pTokenEnd = pEnd;
 791
 792     return String(pTokenBegin, size_type(pTokenEnd-pTokenBegin) );
 793 }
 794
 795 class StreamStrPool
 796 {
 797   public:
 798                         StreamStrPool();
 799                         ~StreamStrPool();
 800   private:
 801     // Non-copyable
 802     StreamStrPool(StreamStrPool &); // not defined
 803     void operator =(StreamStrPool &); // not defined
 804
 805     // Interface to:
 806     friend class StreamStrLock;
 807     static StreamStr &  AcquireFromPool_(
 808                             uintt               i_nMinimalSize );
 809     static void         ReleaseToPool_(
 810                             DYN StreamStr *     let_dpUsedStr );
 811
 812     // DATA
 813     SweList< DYN StreamStr* >
 814                         aPool;
 815 };
 816
 817 StreamStrPool::StreamStrPool()
 818 {
 819 }
 820
 821 StreamStrPool::~StreamStrPool()
 822 {
 823     for ( SweList< DYN StreamStr* >::iterator it = aPool.begin();
 824           it != aPool.end();
 825           ++it )
 826     {
 827          delete (*it);
 828     }
 829 }
 830
 831 namespace
 832 {
 833     static StreamStrPool aPool_;
 834 }
 835
 836
 837 StreamStr &
 838 StreamStrPool::AcquireFromPool_( uintt i_nMinimalSize )
 839 {
 840     if ( aPool_.aPool.empty() )
 841     {
 842         return *new StreamStr(i_nMinimalSize);
 843     }
 844
 845     StreamStr & ret = *aPool_.aPool.front();
 846     aPool_.aPool.pop_front();
 847     ret.resize(i_nMinimalSize);
 848     ret.seekp(0);
 849     ret.set_insert_mode(str::overwrite);
 850     return ret;
 851 }
 852
 853 void
 854 StreamStrPool::ReleaseToPool_( DYN StreamStr * let_dpUsedStr )
 855 {
 856     aPool_.aPool.push_back( let_dpUsedStr );
 857 }
 858
 859 StreamStrLock::StreamStrLock( uintt i_nMinimalSize )
 860     :   pStr( &StreamStrPool::AcquireFromPool_(i_nMinimalSize) )
 861 {
 862 }
 863
 864 StreamStrLock::~StreamStrLock()
 865 {
 866     StreamStrPool::ReleaseToPool_(pStr);
 867 }
 868
 869
 870 UINT32
 871 StreamStr::do_write( const void *    i_pSrc,
 872                      UINT32          i_nNrofBytes )
 873 {
 874     ProvideAddingSize( i_nNrofBytes );
 875     memcpy( pCur, i_pSrc, i_nNrofBytes );
 876     Advance(i_nNrofBytes);
 877
 878     return i_nNrofBytes;
 879 }
 880
 881 void
 882 StreamStr::ProvideAddingSize( size_type i_nSize2Add )
 883 {
 884     size_type nLength = length();
 885     if ( capacity() - nLength < i_nSize2Add )
 886         Resize( nLength + i_nSize2Add );
 887
 888     pEnd += i_nSize2Add;
 889       *pEnd = '\0';
 890
 891     if (eMode == str::insert AND pCur != pEnd)
 892     {
 893         MoveData( pCur, pCur + i_nSize2Add, seek_type(i_nSize2Add) );
 894     }
 895 }
 896
 897 void
 898 StreamStr::Resize( size_type i_nMinimumCapacity )
 899 {
 900     size_type nNewSize = nCapacity1 < 128
 901                             ?   nCapacity1 << 1
 902                             :   (nCapacity1 << 1) - (nCapacity1 >> 1);
 903     nCapacity1 = csv::max( nNewSize, size_type(i_nMinimumCapacity + 1) );
 904
 905     char * pNew = new char[nCapacity1];
 906     strcpy ( pNew, dpData );            // SAFE STRCPY (#100211# - checked)
 907     pEnd = pNew + (pEnd - dpData);
 908     pCur = pNew + (pCur - dpData);
 909
 910     delete [] dpData;
 911     dpData = pNew;
 912 }
 913
 914 void
 915 StreamStr::MoveData( char *        i_pStart,
 916                      char *        i_pEnd,
 917                      seek_type     i_nDiff )
 918 {
 919     if (i_nDiff > 0)
 920     {
 921         register const char * pSrc  = i_pEnd;
 922         register char * pDest = i_pEnd + i_nDiff;
 923         for ( ; pSrc != i_pStart; --pSrc, --pDest )
 924         {
 925             *pDest = *pSrc;
 926         }
 927         *pDest = *pSrc;
 928     }
 929     else if (i_nDiff < 0)
 930     {
 931         const char * pSrc  = i_pStart;
 932         char * pDest = i_pStart + i_nDiff;
 933         for ( ; pSrc != i_pEnd; ++pSrc, ++pDest )
 934         {
 935             *pDest = *pSrc;
 936         }
 937     }
 938 }
 939
 940 // Does nothing, only the name of this function is needed.
 941 void
 942 c_str()
 943 {
 944     // Does nothing.
 945 }
 946
 947
 948
 949 void
 950 Split( std::vector<String> &    o_list,
 951        const char *             i_text )
 952 {
 953     const char *
 954         pCurrentToken = 0;
 955     bool
 956         white = false;
 957     for (const char * p = i_text; *p != '\0'; ++p)
 958     {
 959         white = UINT8(*p) > 32;
 960         if (pCurrentToken != 0)
 961         {
 962             if (white)
 963             {
 964                 o_list.push_back(String(pCurrentToken, p));
 965                 pCurrentToken = 0;
 966             }
 967         }
 968         else
 969         {
 970             if ( NOT white)
 971                 pCurrentToken = p;
 972         }   // endif (bInToken) else
 973     }   // end for
 974
 975     if (pCurrentToken != 0)
 976     {
 977         o_list.push_back(String(pCurrentToken));
 978     }
 979 }
 980
 981
 982
 983
 984 }   // namespace csv