1 : //=============================================================================
2 : // File <$/src/cpp/prod/tool/String.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //=============================================================================
21 :
22 : // Portability
23 : #include "yaorb/config.h"
24 : #include "src/cpp/prod/port/port_stdc.h"
25 : #include "src/cpp/prod/port/port_unistd.h"
26 :
27 : #include <stdio.h>
28 :
29 : #include "src/cpp/prod/tool/String.h"
30 : #include "src/cpp/prod/tool/Assert.h"
31 :
32 : static const char * const emptyCharString = "" ;
33 : static const char endOfString = '\0' ;
34 :
35 141254 : String::String()
36 141254 : : _len(0), _str(NULL)
37 : {
38 141254 : _len = 1 ;
39 141254 : _str = new char[_len] ;
40 141254 : _str[0] = endOfString ;
41 : }
42 :
43 345 : String::String(char c)
44 345 : : _len(0), _str(NULL)
45 : {
46 345 : _len = 2 ;
47 345 : _str = new char[_len] ;
48 345 : _str[0] = c ;
49 345 : _str[1] = endOfString ;
50 : }
51 :
52 186 : String::String(const int aSize)
53 186 : : _len(0), _str(NULL)
54 : {
55 : ASSERT(aSize >= 0) ;
56 :
57 186 : _len = aSize + 1 ;
58 186 : _str = new char[_len] ;
59 186 : _str[0] = endOfString ;
60 : }
61 :
62 95621 : String::String(const char* aCharString)
63 95621 : : _len(0), _str(NULL)
64 : {
65 95621 : if (aCharString == NULL)
66 : {
67 0 : aCharString = emptyCharString ;
68 : }
69 :
70 95621 : _len = strlen(aCharString) + 1 ;
71 95621 : _str = new char[_len] ;
72 95621 : strcpy(_str, aCharString) ;
73 : }
74 :
75 45281 : String::String(const String& aString)
76 45281 : : _len(0), _str(NULL)
77 : {
78 45281 : _len = aString._len ;
79 45281 : _str = new char[_len] ;
80 :
81 45281 : strcpy(_str, aString._str) ;
82 : }
83 :
84 248714 : String::~String()
85 : {
86 248714 : delete [] _str ;
87 19353 : }
88 :
89 467 : int String::length() const
90 : {
91 467 : return strlen(_str) ;
92 : }
93 :
94 15612 : String & String::operator =(const char* aCharString)
95 : {
96 15612 : if (aCharString == NULL)
97 : {
98 0 : aCharString = emptyCharString ;
99 : }
100 :
101 15612 : int newLen = strlen(aCharString) + 1 ;
102 15612 : if (_len < newLen)
103 : {
104 2538 : delete [] _str ;
105 :
106 2538 : _len = newLen ;
107 2538 : _str = new char[_len] ;
108 : }
109 :
110 15612 : strcpy(_str, aCharString) ;
111 :
112 : return *this ;
113 : }
114 :
115 146204 : String & String::operator =(const String& aString)
116 : {
117 146204 : int newLen = strlen(aString._str) + 1 ;
118 146204 : if (_len < newLen)
119 : {
120 124283 : delete [] _str ;
121 :
122 124283 : _len = newLen ;
123 124283 : _str = new char[_len] ;
124 : }
125 :
126 146204 : strcpy(_str, aString._str) ;
127 :
128 : return *this ;
129 : }
130 :
131 44966 : void String::operator +=(const char* aCharString)
132 : {
133 44966 : if (aCharString == NULL)
134 : {
135 0 : aCharString = emptyCharString ;
136 : }
137 :
138 44966 : int newLen = strlen(_str) + strlen(aCharString) + 1 ;
139 44966 : if (_len < newLen)
140 : {
141 44617 : char* newStr = new char[newLen] ;
142 44617 : strcpy(newStr, _str) ;
143 44617 : delete [] _str ;
144 44617 : _str = newStr ;
145 44617 : _len = newLen ;
146 : }
147 :
148 44966 : strcat(_str, aCharString) ;
149 : }
150 :
151 64619 : void String::operator +=(const String& aString)
152 : {
153 64619 : int newLen = strlen(_str) + strlen(aString._str) + 1 ;
154 :
155 64619 : if (_len < newLen)
156 : {
157 60843 : char* newStr = new char[newLen] ;
158 60843 : strcpy(newStr, _str) ;
159 60843 : delete [] _str ;
160 60843 : _str = newStr ;
161 60843 : _len =newLen ;
162 : }
163 :
164 64619 : strcat(_str, aString._str) ;
165 : }
166 :
167 443146 : int String::operator ==(const char* aCharString) const
168 : {
169 443146 : if (aCharString == NULL)
170 : {
171 0 : aCharString = emptyCharString ;
172 : }
173 :
174 443146 : return ((strcmp(_str, aCharString)==0) ? true : false) ;
175 : }
176 :
177 702980 : int String::operator ==(const String& aString) const
178 : {
179 702980 : return ((strcmp(_str, aString._str)==0) ? true : false) ;
180 : }
181 :
182 232516 : String::operator const char* () const
183 : {
184 : return _str ;
185 : }
186 :
187 0 : int String::compare(const char* aCharString) const
188 : {
189 0 : if (aCharString == NULL)
190 : {
191 0 : aCharString = emptyCharString ;
192 : }
193 :
194 0 : return (strcmp(_str, aCharString)) ;
195 : }
196 :
197 0 : int String::compare(const String& aString) const
198 : {
199 0 : return (strcmp(_str, aString._str)) ;
200 : }
201 :
202 28 : int String::Hash(const char* str)
203 : {
204 28 : if (str == NULL)
205 : {
206 : return 0 ;
207 : }
208 :
209 : int hash = 0 ;
210 28 : int len = strlen(str) ;
211 : char c = 0 ;
212 : int shift_c = 0 ;
213 : int dec = 0 ;
214 : int index = 0 ;
215 :
216 482 : for (index = 0 ;
217 : index < len ;
218 : index ++)
219 : {
220 : c = str[index] ;
221 : shift_c = c << dec ;
222 454 : hash ^= shift_c ;
223 454 : dec = (dec + 1) % 24 ;
224 : }
225 :
226 : // fprintf(stderr, "String::Hash(%s) = %d\n", str, hash) ;
227 :
228 : return hash ;
229 : }
230 :
231 0 : int String::Hash(void) const
232 : {
233 0 : return String::Hash(_str) ;
234 : }
235 :
|
