hwpfilter/source/mzstring.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 /* PURPOSE
  30  *   supposed to be used instead of std::string
  31  */
  32
  33 #include "mzstring.h"
  34
  35 #ifndef WIN32
  36 #else
  37
  38     #if defined _MSC_VER
  39         #pragma warning(push, 1)
  40     #endif
  41 # include <windows.h>
  42     #if defined _MSC_VER
  43         #pragma warning(pop)
  44     #endif
  45 #endif                                            /* WIN32 */
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49
  50 #ifndef WIN32
  51 # define wsprintf sprintf
  52 #endif
  53
  54 const int AllocSize = 8;
  55
  56 inline int get_alloc_size(int len)
  57 {
  58     return (len + AllocSize - 1) / AllocSize * AllocSize;
  59 }
  60
  61
  62 MzString::MzString()
  63 {
  64     Length    = 0;
  65     Allocated = 0;
  66     Data      = 0;
  67 }
  68
  69
  70 MzString::~MzString()
  71 {
  72     if (Data)
  73         free(Data);
  74 }
  75
  76
  77 MzString &MzString::operator = (MzString &s)
  78 {
  79     int n = s.length();
  80     if (allocate(n))
  81     {
  82         if (n > 0) memcpy(Data, s.Data, n);
  83         Length = n;
  84     }
  85     return *this;
  86 }
  87
  88
  89 MzString &MzString::operator = (const char *s)
  90 {
  91     if (s == NULL)
  92         s = "";
  93     int n = strlen(s);
  94     if (allocate(n))
  95     {
  96         if (n > 0) memcpy(Data, s, n);
  97         Length = n;
  98     }
  99     return *this;
 100 }
 101
 102
 103 void MzString::append(const char *s, int slen)
 104 {
 105     if(!s || slen <= 0)
 106         return;
 107
 108     int new_len = Length + slen;
 109     if (resize(new_len))
 110     {
 111         memcpy(Data + Length, s, slen);
 112         Length = new_len;
 113     }
 114 }
 115
 116
 117 void MzString::append(MzString const &s)
 118 {
 119     if (s.Data)
 120         append(s.Data, s.length());
 121 }
 122
 123
 124 void MzString::append(const char *s)
 125 {
 126     if (!s) return;
 127     append(s, strlen(s));
 128 }
 129
 130
 131 int MzString::compare(const char *s)
 132 {
 133     if (!Data)   return -1;
 134     if (s==NULL) return 1;
 135
 136     Data[Length] = 0;
 137     return strcmp(Data, s);
 138 }
 139
 140
 141 int MzString::find(char ch)
 142 {
 143     return find(ch,0);
 144 }
 145
 146
 147 int MzString::find(char ch, int pos)
 148 {
 149     for (int i = pos; i < Length; i++)
 150     {
 151         if (Data[i] == ch)
 152             return i;
 153     }
 154     return -1;
 155 }
 156
 157
 158 int MzString::rfind(char ch)
 159 {
 160     return rfind(ch, Length - 1);
 161 }
 162
 163
 164 int MzString::rfind(char ch, int pos)
 165 {
 166     if (pos >= Length)
 167         return -1;
 168
 169     while (pos >= 0)
 170     {
 171         if (Data[pos] == ch)
 172             return pos;
 173         pos--;
 174     }
 175     return -1;
 176 }
 177
 178
 179 // += operator
 180
 181 MzString &MzString::operator += (char ch)
 182 {
 183     append(&ch, 1);
 184     return *this;
 185 }
 186
 187
 188 MzString &MzString::operator += (const char *str)
 189 {
 190     append(str);
 191     return *this;
 192 }
 193
 194
 195 MzString &MzString::operator += (MzString const &s)
 196 {
 197     append(s);
 198     return *this;
 199 }
 200
 201
 202 // << operator
 203 MzString &MzString::operator << (const char *str)
 204 {
 205     append(str);
 206     return *this;
 207 }
 208
 209
 210 MzString &MzString::operator << (char ch)
 211 {
 212     append(&ch, 1);
 213     return *this;
 214 }
 215
 216
 217 MzString &MzString::operator << (int i)
 218 {
 219     char str[80];
 220
 221     wsprintf(str, "%d", i);
 222     append(str);
 223     return *this;
 224 }
 225
 226
 227 MzString &MzString::operator << (long l)
 228 {
 229     char str[80];
 230
 231     wsprintf(str, "%ld", l);
 232     append(str);
 233     return *this;
 234 }
 235
 236
 237 MzString &MzString::operator << (MzString const &s)
 238 {
 239     append(s);
 240     return *this;
 241 }
 242
 243
 244 char MzString::operator [] (int n)
 245 {
 246     if (Data && 0 <= n && n < Length)
 247         return Data[n];
 248
 249     return 0;
 250 }
 251
 252
 253 void MzString::replace(int pos, char ch)
 254 {
 255     if (Data && 0 <= pos && pos < Length)
 256         Data[pos] = ch;
 257 }
 258
 259
 260 //------------------------------------------------------------------------
 261 // Private Methods.
 262 //
 263
 264 bool MzString::allocate(int len)
 265 {
 266     len++;                                        // In case we want to add a null.
 267
 268     if (len < 0)
 269         return false;
 270
 271     if (Data)
 272     {
 273         if (len < Allocated)
 274             return true;
 275         else
 276         {
 277             int   n = get_alloc_size(len);
 278             char *p = (char *)realloc(Data, n);
 279             if (p)
 280             {
 281                 Data      = p;
 282                 Allocated = n;
 283                 return true;
 284             }
 285         }
 286     }
 287     else
 288     {
 289 // In case we want to add a null.
 290         int n = get_alloc_size(len);
 291         Data  = (char *)malloc(n);
 292         if (Data)
 293         {
 294             Allocated = n;
 295             return true;
 296         }
 297     }
 298
 299     return false;
 300 }
 301
 302
 303 bool MzString::resize(int len)
 304 {
 305     return allocate(len);
 306 }
 307
 308 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */