hwpfilter/source/mzstring.cpp

   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: mzstring.cpp,v $
  10  * $Revision: 1.5 $
  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 /* NAME $Id: mzstring.cpp,v 1.5 2008-06-04 10:02:20 vg Exp $
  32  * PURPOSE
  33  *   supposed to be used instead of std::string
  34  * NOTES
  35  *
  36  * HISTORY
  37  *        frog - Oct 8, 1998: Created.
  38  */
  39
  40 #ifdef __GNUG__
  41 #pragma implementation "mzstring.h"
  42 #endif
  43
  44 //#include "stdafx.h"           //
  45 #include "mzstring.h"
  46
  47 #ifndef WIN32
  48 #else
  49
  50     #if defined _MSC_VER
  51         #pragma warning(push, 1)
  52     #endif
  53 # include <windows.h>
  54     #if defined _MSC_VER
  55         #pragma warning(pop)
  56     #endif
  57 //# include <crtdbg.h>
  58 #endif                                            /* WIN32 */
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 #ifndef WIN32
  64 # define wsprintf sprintf
  65 #endif
  66
  67 const int AllocSize = 8;
  68
  69 inline int get_alloc_size(int len)
  70 {
  71     return (len + AllocSize - 1) / AllocSize * AllocSize;
  72 }
  73
  74
  75 MzString::MzString()
  76 {
  77     Length    = 0;
  78     Allocated = 0;
  79     Data      = 0;
  80 }
  81
  82
  83 MzString::~MzString()
  84 {
  85     if (Data)
  86         free(Data);
  87 }
  88
  89
  90 void MzString::operator = (MzString &s)
  91 {
  92     int n = s.length();
  93     if (allocate(n))
  94     {
  95         if (n > 0) memcpy(Data, s.Data, n);
  96         Length = n;
  97     }
  98 }
  99
 100
 101 void MzString::operator = (const char *s)
 102 {
 103     if (s == NULL)
 104         s = "";
 105     int n = strlen(s);
 106     if (allocate(n))
 107     {
 108         if (n > 0) memcpy(Data, s, n);
 109         Length = n;
 110     }
 111 }
 112
 113
 114 void MzString::append(const char *s, int slen)
 115 {
 116     if(!s || slen <= 0)
 117         return;
 118
 119     int new_len = Length + slen;
 120     if (resize(new_len))
 121     {
 122         memcpy(Data + Length, s, slen);
 123         Length = new_len;
 124     }
 125 }
 126
 127
 128 void MzString::append(MzString const &s)
 129 {
 130     if (s.Data)
 131         append(s.Data, s.length());
 132 }
 133
 134
 135 void MzString::append(const char *s)
 136 {
 137     if (!s) return;
 138     append(s, strlen(s));
 139 }
 140
 141
 142 int MzString::compare(const char *s)
 143 {
 144     if (!Data)   return -1;
 145     if (s==NULL) return 1;
 146
 147     Data[Length] = 0;
 148     return strcmp(Data, s);
 149 }
 150
 151
 152 int MzString::find(char ch)
 153 {
 154     return find(ch,0);
 155 }
 156
 157
 158 int MzString::find(char ch, int pos)
 159 {
 160     for (int i = pos; i < Length; i++)
 161     {
 162         if (Data[i] == ch)
 163             return i;
 164     }
 165     return -1;
 166 }
 167
 168
 169 int MzString::rfind(char ch)
 170 {
 171     return rfind(ch, Length - 1);
 172 }
 173
 174
 175 int MzString::rfind(char ch, int pos)
 176 {
 177     if (pos >= Length)
 178         return -1;
 179
 180     while (pos >= 0)
 181     {
 182         if (Data[pos] == ch)
 183             return pos;
 184         pos--;
 185     }
 186     return -1;
 187 }
 188
 189
 190 // += operator
 191
 192 MzString &MzString::operator += (char ch)
 193 {
 194     append(&ch, 1);
 195     return *this;
 196 }
 197
 198
 199 MzString &MzString::operator += (const char *str)
 200 {
 201     append(str);
 202     return *this;
 203 }
 204
 205
 206 MzString &MzString::operator += (MzString const &s)
 207 {
 208     append(s);
 209     return *this;
 210 }
 211
 212
 213 // << operator
 214 MzString &MzString::operator << (const char *str)
 215 {
 216     append(str);
 217     return *this;
 218 }
 219
 220
 221 MzString &MzString::operator << (char ch)
 222 {
 223     append(&ch, 1);
 224     return *this;
 225 }
 226
 227
 228 MzString &MzString::operator << (int i)
 229 {
 230     char str[80];
 231
 232     wsprintf(str, "%d", i);
 233     append(str);
 234     return *this;
 235 }
 236
 237
 238 MzString &MzString::operator << (long l)
 239 {
 240     char str[80];
 241
 242     wsprintf(str, "%ld", l);
 243     append(str);
 244     return *this;
 245 }
 246
 247
 248 MzString &MzString::operator << (MzString const &s)
 249 {
 250     append(s);
 251     return *this;
 252 }
 253
 254
 255 char MzString::operator [] (int n)
 256 {
 257     if (Data && 0 <= n && n < Length)
 258         return Data[n];
 259
 260     return 0;
 261 }
 262
 263
 264 void MzString::replace(int pos, char ch)
 265 {
 266     if (Data && 0 <= pos && pos < Length)
 267         Data[pos] = ch;
 268 }
 269
 270
 271 //------------------------------------------------------------------------
 272 // Private Methods.
 273 //
 274
 275 bool MzString::allocate(int len)
 276 {
 277     len++;                                        // In case we want to add a null.
 278
 279     if (len < 0)
 280         return false;
 281
 282     if (Data)
 283     {
 284         if (len < Allocated)
 285             return true;
 286         else
 287         {
 288             int   n = get_alloc_size(len);
 289             char *p = (char *)realloc(Data, n);
 290             if (p)
 291             {
 292                 Data      = p;
 293                 Allocated = n;
 294                 return true;
 295             }
 296         }
 297     }
 298     else
 299     {
 300 // In case we want to add a null.
 301         int n = get_alloc_size(len);
 302         Data  = (char *)malloc(n);
 303         if (Data)
 304         {
 305             Allocated = n;
 306             return true;
 307         }
 308     }
 309
 310     return false;
 311 }
 312
 313
 314 bool MzString::resize(int len)
 315 {
 316     return allocate(len);
 317 }