xml2cmp/source/support/sistr.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: sistr.cxx,v $
  10  * $Revision: 1.7.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
  32 #include <sistr.hxx>
  33
  34 // The following two header-files declare
  35 //   standard ANSI-C++ functions. They may be replaced
  36 //   by the corresponding header-file-names of the
  37 //   actually used runtime library.
  38 #include <string.h>  // strlen(), memcpy(), memset()
  39 #include <ctype.h>   // tolower()
  40 #include <limits.h>  // INT_MAX
  41
  42 #if (_MSC_VER >=1400)
  43 #pragma warning(disable:4365)
  44 #endif
  45
  46 const char NULCH = '\0';
  47 const int  NO_POS = -1;
  48
  49
  50 Simstr::Simstr(const char * str_)
  51 {
  52    if (str_ == 0)
  53       {
  54          len = 0;
  55          sz = new char[1];
  56          *sz = 0;
  57       }
  58    else
  59       {
  60          len = strlen(str_);
  61          sz = new char[len+1];
  62          memcpy(sz,str_,len+1);
  63       }
  64 }
  65
  66 Simstr::Simstr( const char *   anybytes,
  67                 int            firstBytesPos,
  68                 int            nrOfBytes)
  69 {
  70    unsigned slen = strlen(anybytes);
  71    if (anybytes == 0 || slen <= unsigned(firstBytesPos))
  72       {
  73          len = 0;
  74          sz = new char[1];
  75          *sz = 0;
  76       }
  77    else
  78       {
  79          int maxLen = slen - unsigned(firstBytesPos);
  80          len =  maxLen < nrOfBytes
  81                   ? maxLen
  82                   : nrOfBytes;
  83          sz = new char[len+1];
  84          memcpy(sz,anybytes+firstBytesPos,len);
  85          *(sz+len) = 0;
  86       }
  87 }
  88
  89
  90 Simstr::Simstr(const Simstr & S)
  91 {
  92    len = S.len;
  93    sz = new char[len+1];
  94    memcpy(sz,S.sz,len+1);
  95 }
  96
  97 Simstr & Simstr::operator=(const Simstr & S)
  98 {
  99    if (sz == S.sz)
 100       return *this;
 101
 102    delete [] sz;
 103
 104    len = S.len;
 105    sz = new char[len+1];
 106    memcpy(sz,S.sz,len+1);
 107
 108    return *this;
 109 }
 110
 111 Simstr::~Simstr()
 112 {
 113    delete [] sz;
 114 }
 115
 116 Simstr
 117 Simstr::operator+(const Simstr & S) const
 118 {
 119    Simstr ret = sz;
 120    ret.push_back(S);
 121    return ret;
 122 }
 123
 124 Simstr &
 125 Simstr::operator+=(const Simstr & S)
 126 {
 127    push_back(S);
 128    return *this;
 129 }
 130
 131
 132 // REL
 133
 134 bool
 135 Simstr::operator==(const Simstr & S) const
 136 { return !strcmp(sz,S.sz) ? true : false; }
 137
 138 bool
 139 Simstr::operator!=(const Simstr & S) const
 140 { return strcmp(sz,S.sz) ? true : false; }
 141
 142 bool
 143 Simstr::operator<(const Simstr & S) const
 144 { return (strcmp(sz,S.sz) < 0) ? true : false; }
 145
 146 bool
 147 Simstr::operator>(const Simstr & S) const
 148 { return (strcmp(sz,S.sz) > 0) ? true : false; }
 149
 150 bool
 151 Simstr::operator<=(const Simstr & S) const
 152 { return (strcmp(sz,S.sz) <= 0) ? true : false; }
 153
 154 bool
 155 Simstr::operator>=(const Simstr & S) const
 156 { return (strcmp(sz,S.sz) >= 0) ? true : false; }
 157
 158
 159
 160
 161 // **************          LIST - Funktionen        *****************
 162
 163 // Insert
 164
 165 void
 166 Simstr::push_front(char c)
 167 {
 168    char * result = new char[len+2];
 169
 170    result[0] = c;
 171    memcpy(result+1,sz,len+1);
 172
 173    delete [] sz;
 174    sz = result;
 175    len++;
 176 }
 177
 178 void
 179 Simstr::push_back(char c)
 180 {
 181    char * result = new char[len+2];
 182
 183    memcpy(result,sz,len);
 184    result[len] = c;
 185    result[len+1] = 0;
 186
 187    delete [] sz;
 188    sz = result;
 189    len++;
 190 }
 191
 192 void
 193 Simstr::push_front(const Simstr & S)
 194 {
 195    char * result = new char[len+1+S.len];
 196
 197    memcpy(result,S.sz,S.len);
 198    memcpy(result+S.len,sz,len+1);
 199
 200    delete [] sz;
 201    sz = result;
 202    len += S.len;
 203 }
 204
 205 void
 206 Simstr::push_back(const Simstr & S)
 207 {
 208    char * result = new char[len+1+S.len];
 209
 210    memcpy(result,sz,len);
 211    memcpy(result+len,S.sz,S.len+1);
 212
 213    delete [] sz;
 214    sz = result;
 215    len += S.len;
 216 }
 217
 218
 219 // Remove
 220
 221 void
 222 Simstr::remove(int  pos, int  anzahl)
 223 {
 224    if (pos >= len || pos < 0 || anzahl < 1)
 225       return;
 226
 227     int anz = len - pos < anzahl ? len - pos : anzahl;
 228
 229     char * result = new char[len-anz+1];
 230
 231     memcpy(result,sz,pos);
 232    memcpy(result+pos,sz+pos+anz,len-pos-anz+1);
 233
 234    delete [] sz;
 235    sz = result;
 236    len -= anz;
 237 }
 238
 239 void
 240 Simstr::remove_trailing_blanks()
 241 {
 242     int newlen = len-1;
 243     for ( ; newlen > 1 && sz[newlen] <= 32; --newlen ) {}
 244
 245     if (newlen < len-1)
 246         remove ( newlen+1, len-newlen);
 247 }
 248
 249 // Find
 250
 251 int
 252 Simstr::pos_first(char c) const
 253 {
 254    int i = 0;
 255    for (i = 0; i < len ? sz[i] != c : false; i++) ;
 256    if (i >= len)
 257       return NO_POS;
 258    else
 259       return i;
 260 }
 261
 262 int
 263 Simstr::pos_last(char c) const
 264 {
 265    int i = 0;
 266    for (i = len-1; i >= 0 ? sz[i] != c : false; i--) ;
 267    if (i < 0)
 268       return NO_POS;
 269    else
 270       return i;
 271 }
 272
 273 bool
 274 Simstr::is_no_text() const
 275 {
 276    if (!len)
 277       return true;
 278
 279    int i;
 280    for (i = 0; sz[i] <= 32 && i < len; i++) ;
 281    if (i < len)
 282         return false;
 283     return true;
 284 }
 285
 286 // Change
 287
 288 void
 289 Simstr::replace_all(char oldCh, char newCh)
 290 {
 291    for (int i=0; i < len; i++)
 292       if (sz[i] == oldCh)
 293          sz[i] = newCh;
 294 }
 295
 296 //   Simstr addition
 297 Simstr
 298 operator+(const char * str, const Simstr & S)
 299 {
 300    Simstr ret = S;
 301    ret.push_front(str);
 302    return ret;
 303 }
 304
 305 Simstr
 306 operator+(const Simstr & S, const char * str)
 307 {
 308    Simstr ret = S;
 309    ret.push_back(str);
 310    return ret;
 311 }
 312
 313 Simstr
 314 operator+(char c, const Simstr & S)
 315 {
 316    Simstr ret = S;
 317    ret.push_front(c);
 318    return ret;
 319 }
 320
 321 Simstr
 322 operator+(const Simstr & S, char c)
 323 {
 324    Simstr ret = S;
 325    ret.push_back(c);
 326    return ret;
 327 }
 328
 329
 330 // Simstr-Vergleiche mit char *
 331 bool
 332 operator==(const Simstr & S, const char * str)
 333 {
 334    return strcmp(S,str) == 0;
 335 }
 336
 337 bool
 338 operator!=(const Simstr & S, const char * str)
 339 {
 340    return strcmp(S,str) != 0;
 341 }
 342
 343 bool
 344 operator<(const Simstr & S, const char * str)
 345 {
 346    return strcmp(S,str) < 0;
 347 }
 348
 349 bool
 350 operator>(const Simstr & S, const char * str)
 351 {
 352    return strcmp(S,str) > 0;
 353 }
 354
 355 bool
 356 operator<=(const Simstr & S, const char * str)
 357 {
 358    return strcmp(S,str) <= 0;
 359 }
 360
 361 bool
 362 operator>=(const Simstr & S, const char * str)
 363 {
 364    return strcmp(S,str) >= 0;
 365 }
 366
 367 bool
 368 operator==(const char * str, const Simstr & S)
 369 {
 370    return strcmp(str,S) == 0;
 371 }
 372
 373 bool
 374 operator!=(const char * str, const Simstr & S)
 375 {
 376    return strcmp(str,S) != 0;
 377 }
 378
 379 bool
 380 operator<(const char * str, const Simstr & S)
 381 {
 382    return strcmp(str,S) < 0;
 383 }
 384
 385 bool
 386 operator>(const char * str, const Simstr & S)
 387 {
 388    return strcmp(str,S) > 0;
 389 }
 390
 391 bool
 392 operator<=(const char * str, const Simstr & S)
 393 {
 394    return strcmp(str,S) <= 0;
 395 }
 396
 397 bool
 398 operator>=(const char * str, const Simstr & S)
 399 {
 400    return strcmp(str,S) >= 0;
 401 }
 402
 403