hwpfilter/source/mzstring.cxx

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