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 #ifdef _WIN32
  27 # if !defined WIN32_LEAN_AND_MEAN
  28 #  define WIN32_LEAN_AND_MEAN
  29 # endif
  30 # include <windows.h>
  31 #endif
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #ifndef _WIN32
  37 # define wsprintfA sprintf
  38 #endif
  39
  40 const int AllocSize = 8;
  41
  42 static int get_alloc_size(int len)
  43 {
  44     return (len + AllocSize - 1) / AllocSize * AllocSize;
  45 }
  46
  47
  48 MzString::MzString()
  49 {
  50     Length    = 0;
  51     Allocated = 0;
  52     Data      = nullptr;
  53 }
  54
  55
  56 MzString::~MzString()
  57 {
  58     if (Data)
  59         free(Data);
  60 }
  61
  62
  63 MzString &MzString::operator=(const MzString &s)
  64 {
  65     if(this == &s)
  66         return *this;
  67
  68     int n = s.length();
  69     if (allocate(n))
  70     {
  71         if (n > 0) memcpy(Data, s.Data, n);
  72         Length = n;
  73     }
  74     return *this;
  75 }
  76
  77
  78 MzString &MzString::operator = (const char *s)
  79 {
  80     if (s == nullptr)
  81         s = "";
  82     int n = strlen(s);
  83     if (allocate(n))
  84     {
  85         if (n > 0) memcpy(Data, s, n);
  86         Length = n;
  87     }
  88     return *this;
  89 }
  90
  91
  92 void MzString::append(const char *s, int slen)
  93 {
  94     if(!s || slen <= 0)
  95         return;
  96
  97     int new_len = Length + slen;
  98     if (allocate(new_len))
  99     {
 100         memcpy(Data + Length, s, slen);
 101         Length = new_len;
 102     }
 103 }
 104
 105
 106 void MzString::append(MzString const &s)
 107 {
 108     if (s.Data)
 109         append(s.Data, s.length());
 110 }
 111
 112
 113 void MzString::append(const char *s)
 114 {
 115     if (!s) return;
 116     append(s, strlen(s));
 117 }
 118
 119
 120 int MzString::compare(const char *s)
 121 {
 122     if (!Data)   return -1;
 123     if (s==nullptr) return 1;
 124
 125     Data[Length] = 0;
 126     return strcmp(Data, s);
 127 }
 128
 129
 130 int MzString::find(char ch)
 131 {
 132     return find(ch,0);
 133 }
 134
 135
 136 int MzString::find(char ch, int pos)
 137 {
 138     for (int i = pos; i < Length; i++)
 139     {
 140         if (Data[i] == ch)
 141             return i;
 142     }
 143     return -1;
 144 }
 145
 146
 147 int MzString::rfind(char ch)
 148 {
 149     return rfind(ch, Length - 1);
 150 }
 151
 152
 153 int MzString::rfind(char ch, int pos)
 154 {
 155     if (pos >= Length)
 156         return -1;
 157
 158     while (pos >= 0)
 159     {
 160         if (Data[pos] == ch)
 161             return pos;
 162         pos--;
 163     }
 164     return -1;
 165 }
 166
 167
 168 // << operator
 169 MzString &MzString::operator << (const char *str)
 170 {
 171     append(str);
 172     return *this;
 173 }
 174
 175
 176 MzString &MzString::operator << (char ch)
 177 {
 178     append(&ch, 1);
 179     return *this;
 180 }
 181
 182
 183 MzString &MzString::operator << (int i)
 184 {
 185     char str[80];
 186
 187     wsprintfA(str, "%d", i);
 188     append(str);
 189     return *this;
 190 }
 191
 192
 193 MzString &MzString::operator << (tools::Long l)
 194 {
 195     char str[80];
 196
 197     wsprintfA(str, "%ld", l);
 198     append(str);
 199     return *this;
 200 }
 201
 202
 203 MzString &MzString::operator << (MzString const &s)
 204 {
 205     append(s);
 206     return *this;
 207 }
 208
 209
 210 char MzString::operator [] (int n)
 211 {
 212     if (Data && 0 <= n && n < Length)
 213         return Data[n];
 214
 215     return 0;
 216 }
 217
 218
 219 void MzString::replace(int pos, char ch)
 220 {
 221     if (Data && 0 <= pos && pos < Length)
 222         Data[pos] = ch;
 223 }
 224
 225
 226 // Private Methods.
 227
 228
 229 bool MzString::allocate(int len)
 230 {
 231     len++;                                        // In case we want to add a null.
 232
 233     if (len < 0)
 234         return false;
 235
 236     if (Data)
 237     {
 238         if (len < Allocated)
 239             return true;
 240         else
 241         {
 242             int   n = get_alloc_size(len);
 243             char *p = static_cast<char *>(realloc(Data, n));
 244             if (p)
 245             {
 246                 Data      = p;
 247                 Allocated = n;
 248                 return true;
 249             }
 250         }
 251     }
 252     else
 253     {
 254 // In case we want to add a null.
 255         int n = get_alloc_size(len);
 256         Data  = static_cast<char *>(malloc(n));
 257         if (Data)
 258         {
 259             Allocated = n;
 260             return true;
 261         }
 262     }
 263
 264     return false;
 265 }
 266
 267
 268 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */