ext/OGDF/src/basic/String.cpp

   1 /*
   2  * $Revision: 2565 $
   3  *
   4  * last checkin:
   5  *   $Author: gutwenger $
   6  *   $Date: 2012-07-07 17:14:54 +0200 (Sa, 07. Jul 2012) $
   7  ***************************************************************/
   8
   9 /** \file
  10  * \brief Implementation of class String
  11  *
  12  * \author Carsten Gutwenger
  13  *
  14  * \par License:
  15  * This file is part of the Open Graph Drawing Framework (OGDF).
  16  *
  17  * \par
  18  * Copyright (C)<br>
  19  * See README.txt in the root directory of the OGDF installation for details.
  20  *
  21  * \par
  22  * This program is free software; you can redistribute it and/or
  23  * modify it under the terms of the GNU General Public License
  24  * Version 2 or 3 as published by the Free Software Foundation;
  25  * see the file LICENSE.txt included in the packaging of this file
  26  * for details.
  27  *
  28  * \par
  29  * This program is distributed in the hope that it will be useful,
  30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  * GNU General Public License for more details.
  33  *
  34  * \par
  35  * You should have received a copy of the GNU General Public
  36  * License along with this program; if not, write to the Free
  37  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  38  * Boston, MA 02110-1301, USA.
  39  *
  40  * \see  http://www.gnu.org/copyleft/gpl.html
  41  ***************************************************************/
  42
  43
  44
  45 #include <ogdf/basic/String.h>
  46 #include <ogdf/basic/Hashing.h>
  47 #include <stdarg.h>
  48 #include <string.h>
  49
  50
  51 namespace ogdf {
  52
  53
  54 char String::s_pBuffer[OGDF_STRING_BUFFER_SIZE];
  55
  56
  57 String::String()
  58 {
  59         m_pChar = new char[1];
  60         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
  61
  62         m_pChar[0] = 0;
  63         m_length = 0;
  64 }
  65
  66
  67 String::String(const char c)
  68 {
  69         m_length = 1;
  70         m_pChar = new char[2];
  71         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
  72
  73         m_pChar[0] = c;
  74         m_pChar[1] = '\0';
  75 }
  76
  77
  78 String::String(const char *str)
  79 {
  80         m_length = strlen(str);
  81         m_pChar = new char[m_length+1];
  82         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
  83
  84         ogdf::strcpy(m_pChar,m_length+1,str);
  85 }
  86
  87
  88 String::String(size_t maxLen, const char *str)
  89 {
  90         m_length = maxLen;
  91         m_pChar = new char[m_length+1];
  92         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
  93
  94         ogdf::strncpy(m_pChar, m_length+1, str, m_length);
  95         m_pChar[m_length] = '\0';
  96 }
  97
  98 /*
  99 String::String(const char *format, ...)
 100 {
 101         va_list argList;
 102         va_start(argList,format);
 103
 104         m_length = vsprintf(s_pBuffer,format,argList);
 105         m_pChar = new char[m_length+1];
 106         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
 107
 108         strcpy(m_pChar,s_pBuffer);
 109 }
 110 */
 111
 112 String::String(const String &str)
 113 {
 114         m_length = str.m_length;
 115         m_pChar = new char[m_length+1];
 116         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
 117
 118         ogdf::strcpy(m_pChar,m_length+1,str.m_pChar);
 119 }
 120
 121
 122 String::~String()
 123 {
 124         delete [] m_pChar;
 125 }
 126
 127
 128 String &String::operator =(const String &str)
 129 {
 130         if (&str == this) return *this;
 131
 132         delete [] m_pChar;
 133
 134         m_length = str.m_length;
 135         m_pChar = new char[m_length+1];
 136         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
 137
 138         ogdf::strcpy(m_pChar,m_length+1,str.m_pChar);
 139
 140         return *this;
 141 }
 142
 143
 144 String &String::operator =(const char *str)
 145 {
 146         delete [] m_pChar;
 147
 148         m_length = strlen(str);
 149         m_pChar = new char[m_length+1];
 150         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
 151
 152         ogdf::strcpy(m_pChar,m_length+1,str);
 153
 154         return *this;
 155 }
 156
 157
 158 String &String::operator +=(const String &str)
 159 {
 160         size_t oldLength = m_length;
 161         char *pOldChar = m_pChar;
 162
 163         m_length += str.m_length;
 164         m_pChar = new char[m_length+1];
 165         if (m_pChar == 0) {
 166                 delete [] pOldChar;
 167                 OGDF_THROW(InsufficientMemoryException);
 168         }
 169
 170         ogdf::strcpy(m_pChar,m_length+1,pOldChar);
 171         ogdf::strcpy(m_pChar+oldLength,m_length+1-oldLength,str.m_pChar);
 172
 173         delete [] pOldChar;
 174
 175         return *this;
 176 }
 177
 178
 179 void String::sprintf(const char *format, ...)
 180 {
 181         delete [] m_pChar;
 182
 183         va_list argList;
 184         va_start(argList,format);
 185
 186         m_length = ogdf::vsprintf(s_pBuffer,OGDF_STRING_BUFFER_SIZE,format,argList);
 187         m_pChar = new char[m_length+1];
 188         if (m_pChar == 0) OGDF_THROW(InsufficientMemoryException);
 189
 190         ogdf::strcpy(m_pChar,m_length+1,s_pBuffer);
 191 }
 192
 193
 194 int String::compare (const String &x, const String &y)
 195 {
 196         return strcmp(x.m_pChar, y.m_pChar);
 197 }
 198
 199
 200 istream& operator>>(istream& is, String &str)
 201 {
 202         is >> String::s_pBuffer;
 203         str = String::s_pBuffer;
 204         return is;
 205 }
 206
 207 int DefHashFunc<String>::hash(const String &key) const
 208 {
 209         int hashValue = 0;
 210         const char *pChar = key.cstr();
 211
 212         while (*pChar)
 213                 hashValue += int(*pChar++);
 214
 215         return hashValue;
 216 }
 217
 218
 219 } // end namespace ogdf