soltools/support/simstr.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: simstr.cxx,v $
  10  * $Revision: 1.5.16.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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_soltools.hxx"
  33
  34
  35 #include <simstr.hxx>
  36
  37 #include <string.h>  // strlen(), memcpy(), memset()
  38 #include <ctype.h>   // tolower()
  39 #include <limits.h>  // INT_MAX
  40
  41 const char NULCH = '\0';
  42 const int  NO_POS = -1;
  43
  44
  45 Simstr::Simstr(const char * s_)
  46 {
  47    if (s_ == 0)
  48       {
  49          len = 0;
  50          sz = new char[1];
  51          *sz = 0;
  52       }
  53    else
  54       {
  55          len = strlen(s_);
  56          sz = new char[len+1];
  57          memcpy(sz,s_,len+1);
  58       }
  59 }
  60
  61 Simstr::Simstr(const char * anybytes, int  nrOfBytes)
  62 {
  63     if (anybytes == 0)
  64     {
  65         len = 0;
  66         sz = new char[1];
  67         *sz = 0;
  68         return;
  69     }
  70
  71     int slen = static_cast<int>( strlen(anybytes) );
  72
  73     len =  slen < nrOfBytes
  74                   ? slen
  75                   : nrOfBytes;
  76     sz = new char[len+1];
  77     memcpy( sz, anybytes, len );
  78     *( sz + len ) = 0;
  79 }
  80
  81 Simstr::Simstr(char c, int anzahl)
  82 {
  83    if (anzahl < 1)
  84       {
  85          len = 0;
  86          sz = new char[1];
  87          *sz = 0;
  88       }
  89    else
  90       {
  91          len = anzahl;
  92          sz = new char[len+1];
  93          memset(sz,c,anzahl);
  94          sz[len] = 0;
  95       }
  96 }
  97
  98 Simstr::Simstr( const char *   anybytes,
  99                 int            firstBytesPos,
 100                 int            nrOfBytes)
 101 {
 102    unsigned slen = strlen(anybytes);
 103    if (anybytes == 0 || slen <= unsigned(firstBytesPos))
 104       {
 105          len = 0;
 106          sz = new char[1];
 107          *sz = 0;
 108       }
 109    else
 110       {
 111          int maxLen = slen - unsigned(firstBytesPos);
 112          len =  maxLen < nrOfBytes
 113                   ? maxLen
 114                   : nrOfBytes;
 115          sz = new char[len+1];
 116          memcpy(sz,anybytes+firstBytesPos,len);
 117          *(sz+len) = 0;
 118       }
 119 }
 120
 121
 122 Simstr::Simstr(const Simstr & S)
 123 {
 124    len = S.len;
 125    sz = new char[len+1];
 126    memcpy(sz,S.sz,len+1);
 127 }
 128
 129 Simstr & Simstr::operator=(const Simstr & S)
 130 {
 131    if (sz == S.sz)
 132       return *this;
 133
 134    delete [] sz;
 135
 136    len = S.len;
 137    sz = new char[len+1];
 138    memcpy(sz,S.sz,len+1);
 139
 140    return *this;
 141 }
 142
 143 Simstr::~Simstr()
 144 {
 145    delete [] sz;
 146 }
 147
 148 char &
 149 Simstr::ch(int  n)
 150 {
 151    static char nullCh = NULCH;
 152    nullCh = NULCH;
 153    if (n >= long(len) || n < 0)
 154       return nullCh;
 155    else
 156       return sz[unsigned(n)];
 157 }
 158
 159 const Simstr &
 160 Simstr::null_()
 161 {
 162     static Simstr aNull_;
 163     return aNull_;
 164 }
 165
 166
 167 Simstr
 168 Simstr::operator+(const Simstr & S) const
 169 {
 170    Simstr ret = sz;
 171    ret.push_back(S);
 172    return ret;
 173 }
 174
 175 Simstr &
 176 Simstr::operator+=(const Simstr & S)
 177 {
 178    push_back(S);
 179    return *this;
 180 }
 181
 182 Simstr &
 183 Simstr::operator+=(const char * s_)
 184 {
 185     Simstr a(s_);
 186     push_back(a);
 187     return *this;
 188 }
 189
 190
 191 // REL
 192
 193 bool
 194 Simstr::operator==(const Simstr & S) const
 195 { return !strcmp(sz,S.sz) ? true : false; }
 196
 197 bool
 198 Simstr::operator!=(const Simstr & S) const
 199 { return strcmp(sz,S.sz) ? true : false; }
 200
 201 bool
 202 Simstr::operator<(const Simstr & S) const
 203 { return (strcmp(sz,S.sz) < 0) ? true : false; }
 204
 205 bool
 206 Simstr::operator>(const Simstr & S) const
 207 { return (strcmp(sz,S.sz) > 0) ? true : false; }
 208
 209 bool
 210 Simstr::operator<=(const Simstr & S) const
 211 { return (strcmp(sz,S.sz) <= 0) ? true : false; }
 212
 213 bool
 214 Simstr::operator>=(const Simstr & S) const
 215 { return (strcmp(sz,S.sz) >= 0) ? true : false; }
 216
 217
 218
 219
 220 // **************          LIST - Funktionen        *****************
 221
 222
 223 // Einzelzugriff
 224
 225 char
 226 Simstr::get(int  n) const     { return (n >= len || n < 0) ? 0 : sz[n]; }
 227
 228 char
 229 Simstr::get_front() const        { return sz[0]; }
 230
 231 char
 232 Simstr::get_back() const        { return  len ? sz[len-1] : 0; }
 233
 234 Simstr
 235 Simstr::get(int  startPos, int  anzahl) const
 236 {
 237    if (startPos >= len || startPos < 0 || anzahl < 1)
 238       return "";
 239
 240    int anz = len - startPos < anzahl ? len - startPos : anzahl;
 241
 242    Simstr ret(' ',anz);
 243    memcpy(ret.sz, sz+startPos, anz);
 244    return ret;
 245 }
 246
 247 Simstr
 248 Simstr::get_front(int  anzahl) const
 249 {
 250    int anz = len < anzahl ? len : anzahl;
 251    if (anz < 1)
 252       return "";
 253
 254    Simstr ret(' ',anz);
 255    memcpy(ret.sz, sz, anz);
 256    return ret;
 257 }
 258
 259 Simstr
 260 Simstr::get_back(int  anzahl) const
 261 {
 262    int anz = len < anzahl ? len : anzahl;
 263    if (anz < 1)
 264       return "";
 265    int start = len-anz;
 266
 267    Simstr ret(' ',anz);
 268    memcpy(ret.sz, sz+start, anz);
 269    return ret;
 270 }
 271
 272 Simstr
 273 Simstr::get_first_token(char c) const
 274 {
 275    int posc = pos_first(c);
 276    if (posc != NO_POS)
 277       return get_front(posc);
 278    else
 279       return sz;
 280 }
 281
 282 Simstr
 283 Simstr::get_last_token(char c) const
 284 {
 285    int posc = pos_last(c);
 286    if (posc != NO_POS)
 287       return get_back(len-posc-1);
 288    else
 289       return sz;
 290 }
 291
 292
 293
 294 // Insert
 295
 296 void
 297 Simstr::insert(int  pos, char c)
 298 {
 299    if (pos < 0 || pos > len)
 300       return;
 301
 302    char * result = new char[len+2];
 303
 304    memcpy(result,sz,pos);
 305    result[pos] = c;
 306    memcpy(result+pos+1,sz+pos,len-pos+1);
 307
 308    delete [] sz;
 309    sz = result;
 310    len++;
 311 }
 312
 313 void
 314 Simstr::push_front(char c)
 315 {
 316    char * result = new char[len+2];
 317
 318    result[0] = c;
 319    memcpy(result+1,sz,len+1);
 320
 321    delete [] sz;
 322    sz = result;
 323    len++;
 324 }
 325
 326 void
 327 Simstr::push_back(char c)
 328 {
 329    char * result = new char[len+2];
 330
 331    memcpy(result,sz,len);
 332    result[len] = c;
 333    result[len+1] = 0;
 334
 335    delete [] sz;
 336    sz = result;
 337    len++;
 338 }
 339
 340 void
 341 Simstr::insert(int  pos, const Simstr & S)
 342 {
 343    if (pos < 0 || pos > len)
 344       return;
 345
 346    char * result = new char[len+1+S.len];
 347
 348    memcpy(result,sz,pos);
 349    memcpy(result+pos,S.sz,S.len);
 350    memcpy(result+pos+S.len,sz+pos,len-pos+1);
 351
 352    delete [] sz;
 353    sz = result;
 354    len += S.len;
 355 }
 356
 357 void
 358 Simstr::push_front(const Simstr & S)
 359 {
 360    char * result = new char[len+1+S.len];
 361
 362    memcpy(result,S.sz,S.len);
 363    memcpy(result+S.len,sz,len+1);
 364
 365    delete [] sz;
 366    sz = result;
 367    len += S.len;
 368 }
 369
 370 void
 371 Simstr::push_back(const Simstr & S)
 372 {
 373    char * result = new char[len+1+S.len];
 374
 375    memcpy(result,sz,len);
 376    memcpy(result+len,S.sz,S.len+1);
 377
 378    delete [] sz;
 379    sz = result;
 380    len += S.len;
 381 }
 382
 383
 384 // Remove
 385
 386 void
 387 Simstr::remove(int  pos, int  anzahl)
 388 {
 389    if (pos >= len || pos < 0 || anzahl < 1)
 390       return;
 391
 392     int anz = len - pos < anzahl ? len - pos : anzahl;
 393
 394     char * result = new char[len-anz+1];
 395
 396     memcpy(result,sz,pos);
 397    memcpy(result+pos,sz+pos+anz,len-pos-anz+1);
 398
 399    delete [] sz;
 400    sz = result;
 401    len -= anz;
 402 }
 403
 404 void
 405 Simstr::remove_trailing_blanks()
 406 {
 407     int newlen = len-1;
 408     for ( ; newlen > 1 && sz[newlen] <= 32; --newlen ) {}
 409
 410     if (newlen < len-1)
 411         remove ( newlen+1, len-newlen);
 412 }
 413
 414 void
 415 Simstr::pop_front(int  anzahl)
 416 {
 417    if (anzahl < 1)
 418       return;
 419    int anz = len < anzahl ? len : anzahl;
 420
 421    char * result = new char[len-anz+1];
 422
 423    memcpy(result,sz+anz,len-anz+1);
 424
 425    delete [] sz;
 426    sz = result;
 427    len -= anz;
 428 }
 429
 430 void
 431 Simstr::pop_back(int  anzahl)
 432 {
 433    if (anzahl < 1)
 434       return;
 435
 436    int anz = len < anzahl ? len : anzahl;
 437
 438    char * result = new char[len-anz+1];
 439
 440    memcpy(result,sz,len-anz);
 441    result[len-anz] = 0;
 442
 443    delete [] sz;
 444    sz = result;
 445    len -= anz;
 446 }
 447
 448 void
 449 Simstr::rem_back_from(int  removeStartPos)
 450 {
 451    if (removeStartPos != NO_POS)
 452       pop_back(len-removeStartPos);
 453 }
 454
 455 void
 456 Simstr::remove_all(char c)
 457 {
 458    if (!len)
 459       return;
 460    char * result = new char[len];
 461    int i,j=0;
 462    for (i = 0; i < len; i++)
 463        if (sz[i] != c)
 464           result[j++] = sz[i];
 465
 466    delete [] sz;
 467    sz = new char[j+1];
 468    memcpy(sz,result,j);
 469    sz[j] = 0;
 470    len = j;
 471    delete [] result;
 472 }
 473
 474 void
 475 Simstr::remove_all(const Simstr & S)
 476 {
 477    int  pos;
 478    while ( (pos=pos_first(S)) != NO_POS )
 479       remove(pos,S.len);
 480 }
 481
 482 void
 483 Simstr::strip(char c)
 484 {
 485     int start = 0;
 486    if (c == ' ')
 487    {  // Sonderbehandlung: SPC entfernt auch TABs:
 488        while ( start < len
 489                  ?  sz[start] == ' '
 490                     || sz[start] == '\t'
 491                  :  false )
 492            start++;
 493    }
 494    else
 495    {
 496        while (start < len && sz[start] == c)
 497            start++;
 498    }
 499
 500     int ende = len-1;
 501    if (c == ' ')
 502    {  // Sonderbehandlung: SPC entfernt auch TABs:
 503        while ( ende >= start
 504                  ?  sz[ende] == ' '
 505                     || sz[ende] == '\t'
 506                  :  false  )
 507            ende--;
 508    }
 509    else
 510    {
 511        while (ende >= start && sz[ende] == c)
 512            ende--;
 513    }
 514     *this = get(start,ende-start+1);
 515 }
 516
 517 void
 518 Simstr::empty()
 519 {
 520    if (len > 0)
 521    {
 522       delete [] sz;
 523       sz = new char[1];
 524       *sz = 0;
 525       len = 0;
 526    }
 527 }
 528
 529 Simstr
 530 Simstr::take_first_token(char c)
 531 {
 532    Simstr ret;
 533    int pos = pos_first(c);
 534    if (pos != NO_POS)
 535       {
 536          ret = get_front(pos);
 537          pop_front(pos+1);
 538       }
 539    else
 540       {
 541          ret = sz;
 542          delete [] sz;
 543          sz = new char[1];
 544          *sz = NULCH;
 545          len = 0;
 546       }
 547
 548    return ret;
 549 }
 550
 551 Simstr
 552 Simstr::take_last_token(char c)
 553 {
 554    Simstr ret;
 555    int pos = pos_last(c);
 556    if (pos != NO_POS)
 557       {
 558          ret = get_back(len-pos-1);
 559          pop_back(len-pos);
 560       }
 561    else
 562       {
 563          ret = sz;
 564          delete [] sz;
 565          sz = new char[1];
 566          *sz = NULCH;
 567          len = 0;
 568       }
 569
 570    return ret;
 571 }
 572
 573
 574
 575 // Find
 576
 577 int
 578 Simstr::pos_first(char c) const
 579 {
 580    int i = 0;
 581    for (i = 0; i < len ? sz[i] != c : false; i++) ;
 582    if (i >= len)
 583       return NO_POS;
 584    else
 585       return i;
 586 }
 587
 588 int
 589 Simstr::pos_first_after( char           c,
 590                          int            startSearchPos) const
 591 {
 592    int i = 0;
 593    if (startSearchPos >= i)
 594       i = startSearchPos+1;
 595    for (; i < len ? sz[i] != c : false; i++) ;
 596    if (i >= len)
 597       return NO_POS;
 598    else
 599       return i;
 600 }
 601
 602
 603 int
 604 Simstr::pos_last(char c) const
 605 {
 606    int i = 0;
 607    for (i = len-1; i >= 0 ? sz[i] != c : false; i--) ;
 608    if (i < 0)
 609       return NO_POS;
 610    else
 611       return i;
 612 }
 613
 614 int
 615 Simstr::pos_first(const Simstr & S) const
 616 {
 617    char * ptr = strstr(sz,S.sz);
 618    if (ptr)
 619       return int(ptr-sz);
 620    else
 621       return NO_POS;
 622 }
 623
 624 int
 625 Simstr::pos_last(const Simstr & S) const
 626 {
 627    Simstr vgl;
 628    int i;
 629    for (i = len-S.len; i >= 0 ; i--)
 630       {
 631          vgl = get(i,S.len);
 632          if (vgl == S)
 633             break;
 634       }
 635    if (i >= 0)
 636       return i;
 637    else
 638       return NO_POS;
 639 }
 640
 641 int
 642 Simstr::count(char c) const
 643 {
 644    int ret = 0;
 645    for (int i =0; i < len; i++)
 646       if (sz[i] == c)
 647          ret++;
 648    return ret;
 649 }
 650
 651 bool
 652 Simstr::is_no_text() const
 653 {
 654    if (!len)
 655       return true;
 656
 657    int i;
 658    for (i = 0; sz[i] <= 32 && i < len; i++) ;
 659    if (i < len)
 660         return false;
 661     return true;
 662 }
 663
 664 // Change
 665
 666 void
 667 Simstr::replace(int  pos, char c)
 668 {
 669     if (pos < 0 || pos >= len)
 670       return;
 671    else
 672       sz[unsigned(pos)] = c;
 673 }
 674
 675 void
 676 Simstr::replace(int  startPos, int  anzahl, const Simstr & S)
 677 {
 678    if (startPos >= len || startPos < 0 || anzahl < 1)
 679       return;
 680
 681    int anz = len - startPos < anzahl ? len - startPos : anzahl;
 682
 683    char * result = new char[len-anz+S.len+1];
 684
 685    memcpy(result,sz,startPos);
 686    memcpy(result+startPos, S.sz, S.len);
 687    memcpy(result+startPos+S.len, sz+startPos+anz, len-startPos-anz+1);
 688
 689    delete [] sz;
 690    sz = result;
 691    len = len-anz+S.len;
 692 }
 693
 694 void
 695 Simstr::replace_all(char oldCh, char newCh)
 696 {
 697    for (int i=0; i < len; i++)
 698       if (sz[i] == oldCh)
 699          sz[i] = newCh;
 700 }
 701
 702 void
 703 Simstr::replace_all(const Simstr & oldS, const Simstr & newS)
 704 {
 705    Simstr vgl;
 706    int i = 0;
 707     while (i <= len-oldS.len)
 708         {
 709          vgl = get(i,oldS.len);
 710          if (strcmp(vgl.sz,oldS.sz) == 0)
 711             {
 712                replace(i,oldS.len,newS);
 713                i += newS.len;
 714             }
 715          else
 716             i++;
 717       }
 718 }
 719
 720 void
 721 Simstr::to_lower()
 722 {
 723     for (int i = 0; i < len; i++)
 724        sz[i] = (char) tolower(sz[i]);
 725 }
 726
 727
 728
 729 //   Simstr addition
 730 Simstr
 731 operator+(const char * str, const Simstr & S)
 732 {
 733    Simstr ret = S;
 734    ret.push_front(str);
 735    return ret;
 736 }
 737
 738 Simstr
 739 operator+(const Simstr & S, const char * str)
 740 {
 741    Simstr ret = S;
 742    ret.push_back(str);
 743    return ret;
 744 }
 745
 746 Simstr
 747 operator+(char c, const Simstr & S)
 748 {
 749    Simstr ret = S;
 750    ret.push_front(c);
 751    return ret;
 752 }
 753
 754 Simstr
 755 operator+(const Simstr & S, char c)
 756 {
 757    Simstr ret = S;
 758    ret.push_back(c);
 759    return ret;
 760 }
 761
 762
 763 // Simstr-Vergleiche mit char *
 764 bool
 765 operator==(const Simstr & S, const char * str)
 766 {
 767    return strcmp(S,str) == 0;
 768 }
 769
 770 bool
 771 operator!=(const Simstr & S, const char * str)
 772 {
 773    return strcmp(S,str) != 0;
 774 }
 775
 776 bool
 777 operator<(const Simstr & S, const char * str)
 778 {
 779    return strcmp(S,str) < 0;
 780 }
 781
 782 bool
 783 operator>(const Simstr & S, const char * str)
 784 {
 785    return strcmp(S,str) > 0;
 786 }
 787
 788 bool
 789 operator<=(const Simstr & S, const char * str)
 790 {
 791    return strcmp(S,str) <= 0;
 792 }
 793
 794 bool
 795 operator>=(const Simstr & S, const char * str)
 796 {
 797    return strcmp(S,str) >= 0;
 798 }
 799
 800 bool
 801 operator==(const char * str, const Simstr & S)
 802 {
 803    return strcmp(str,S) == 0;
 804 }
 805
 806 bool
 807 operator!=(const char * str, const Simstr & S)
 808 {
 809    return strcmp(str,S) != 0;
 810 }
 811
 812 bool
 813 operator<(const char * str, const Simstr & S)
 814 {
 815    return strcmp(str,S) < 0;
 816 }
 817
 818 bool
 819 operator>(const char * str, const Simstr & S)
 820 {
 821    return strcmp(str,S) > 0;
 822 }
 823
 824 bool
 825 operator<=(const char * str, const Simstr & S)
 826 {
 827    return strcmp(str,S) <= 0;
 828 }
 829
 830 bool
 831 operator>=(const char * str, const Simstr & S)
 832 {
 833    return strcmp(str,S) >= 0;
 834 }
 835
 836