1*59617ebcSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*59617ebcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*59617ebcSAndrew Rist * or more contributor license agreements. See the NOTICE file
5*59617ebcSAndrew Rist * distributed with this work for additional information
6*59617ebcSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*59617ebcSAndrew Rist * to you under the Apache License, Version 2.0 (the
8*59617ebcSAndrew Rist * "License"); you may not use this file except in compliance
9*59617ebcSAndrew Rist * with the License. You may obtain a copy of the License at
10*59617ebcSAndrew Rist *
11*59617ebcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*59617ebcSAndrew Rist *
13*59617ebcSAndrew Rist * Unless required by applicable law or agreed to in writing,
14*59617ebcSAndrew Rist * software distributed under the License is distributed on an
15*59617ebcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*59617ebcSAndrew Rist * KIND, either express or implied. See the License for the
17*59617ebcSAndrew Rist * specific language governing permissions and limitations
18*59617ebcSAndrew Rist * under the License.
19*59617ebcSAndrew Rist *
20*59617ebcSAndrew Rist *************************************************************/
21*59617ebcSAndrew Rist
22*59617ebcSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir #include <precomp.h>
25cdf0e10cSrcweir #include <cosv/streamstr.hxx>
26cdf0e10cSrcweir
27cdf0e10cSrcweir // NOT FULLY DECLARED SERVICES
28cdf0e10cSrcweir #include <string.h>
29cdf0e10cSrcweir #include <stdio.h>
30cdf0e10cSrcweir #include <stdarg.h> // both are needed to satisfy all compilers
31cdf0e10cSrcweir #include <cstdarg> // std::va_list and friends
32cdf0e10cSrcweir
33cdf0e10cSrcweir #include <cosv/comfunc.hxx>
34cdf0e10cSrcweir #include <cosv/tpl/swelist.hxx>
35cdf0e10cSrcweir
36cdf0e10cSrcweir
37cdf0e10cSrcweir
38cdf0e10cSrcweir namespace csv
39cdf0e10cSrcweir {
40cdf0e10cSrcweir
41cdf0e10cSrcweir
42cdf0e10cSrcweir // Maximal sizes of resulting integers in text form:
43cdf0e10cSrcweir const uintt C_short_max_size = sizeof(short) * 3;
44cdf0e10cSrcweir const uintt C_int_max_size = sizeof(int) * 3;
45cdf0e10cSrcweir const uintt C_long_max_size = sizeof(long) * 3;
46cdf0e10cSrcweir
47cdf0e10cSrcweir
48cdf0e10cSrcweir inline void
Advance(size_type i_nAddedSize)49cdf0e10cSrcweir StreamStr::Advance(size_type i_nAddedSize)
50cdf0e10cSrcweir { pCur += i_nAddedSize; }
51cdf0e10cSrcweir
52cdf0e10cSrcweir
53cdf0e10cSrcweir
StreamStr(size_type i_nCapacity)54cdf0e10cSrcweir StreamStr::StreamStr( size_type i_nCapacity )
55cdf0e10cSrcweir : bostream(),
56cdf0e10cSrcweir nCapacity1( i_nCapacity + 1 ),
57cdf0e10cSrcweir dpData( new char [i_nCapacity + 1] ),
58cdf0e10cSrcweir pEnd(dpData),
59cdf0e10cSrcweir pCur(dpData),
60cdf0e10cSrcweir eMode(str::overwrite)
61cdf0e10cSrcweir {
62cdf0e10cSrcweir *pEnd = '\0';
63cdf0e10cSrcweir }
64cdf0e10cSrcweir
StreamStr(const char * i_sInitStr,size_type i_nCapacity)65cdf0e10cSrcweir StreamStr::StreamStr( const char * i_sInitStr,
66cdf0e10cSrcweir size_type i_nCapacity )
67cdf0e10cSrcweir : bostream(),
68cdf0e10cSrcweir nCapacity1(0),
69cdf0e10cSrcweir dpData(0),
70cdf0e10cSrcweir pEnd(0),
71cdf0e10cSrcweir pCur(0),
72cdf0e10cSrcweir eMode(str::overwrite)
73cdf0e10cSrcweir {
74cdf0e10cSrcweir size_type nLength = strlen(i_sInitStr);
75cdf0e10cSrcweir nCapacity1 = csv::max(nLength, i_nCapacity) + 1;
76cdf0e10cSrcweir dpData = new char [nCapacity1];
77cdf0e10cSrcweir strcpy(dpData, i_sInitStr); // SAFE STRCPY (#100211# - checked)
78cdf0e10cSrcweir pCur = dpData + nLength;
79cdf0e10cSrcweir pEnd = pCur;
80cdf0e10cSrcweir }
81cdf0e10cSrcweir
StreamStr(size_type i_nGuessedCapacity,const char * str1,const char * str2,...)82cdf0e10cSrcweir StreamStr::StreamStr( size_type i_nGuessedCapacity,
83cdf0e10cSrcweir const char * str1,
84cdf0e10cSrcweir const char * str2,
85cdf0e10cSrcweir ... )
86cdf0e10cSrcweir : bostream(),
87cdf0e10cSrcweir nCapacity1( i_nGuessedCapacity + 1 ),
88cdf0e10cSrcweir dpData( new char [i_nGuessedCapacity + 1] ),
89cdf0e10cSrcweir pEnd(dpData),
90cdf0e10cSrcweir pCur(dpData),
91cdf0e10cSrcweir eMode(str::overwrite)
92cdf0e10cSrcweir {
93cdf0e10cSrcweir *pEnd = '\0';
94cdf0e10cSrcweir
95cdf0e10cSrcweir operator<<(str1);
96cdf0e10cSrcweir operator<<(str2);
97cdf0e10cSrcweir
98cdf0e10cSrcweir ::va_list ap;
99cdf0e10cSrcweir
100cdf0e10cSrcweir va_start(ap, str2);
101cdf0e10cSrcweir for ( const char * strAdd = va_arg(ap,const char*);
102cdf0e10cSrcweir strAdd != 0;
103cdf0e10cSrcweir strAdd = va_arg(ap,const char*) )
104cdf0e10cSrcweir {
105cdf0e10cSrcweir size_type nLen = strlen(strAdd);
106cdf0e10cSrcweir ProvideAddingSize( nLen );
107cdf0e10cSrcweir memcpy(pCur, strAdd, nLen);
108cdf0e10cSrcweir Advance(nLen);
109cdf0e10cSrcweir } // end for
110cdf0e10cSrcweir va_end(ap);
111cdf0e10cSrcweir }
112cdf0e10cSrcweir
StreamStr(const self & i_rOther)113cdf0e10cSrcweir StreamStr::StreamStr( const self & i_rOther )
114cdf0e10cSrcweir : bostream(),
115cdf0e10cSrcweir nCapacity1( i_rOther.nCapacity1 ),
116cdf0e10cSrcweir dpData( new char [i_rOther.nCapacity1] ),
117cdf0e10cSrcweir pEnd( dpData + strlen(i_rOther.dpData) ),
118cdf0e10cSrcweir pCur( dpData + i_rOther.tellp() ),
119cdf0e10cSrcweir eMode(i_rOther.eMode)
120cdf0e10cSrcweir {
121cdf0e10cSrcweir strcpy( dpData, i_rOther.dpData ); // SAFE STRCPY (#100211# - checked)
122cdf0e10cSrcweir }
123cdf0e10cSrcweir
StreamStr(csv::bstream & i_source)124cdf0e10cSrcweir StreamStr::StreamStr(csv::bstream & i_source)
125cdf0e10cSrcweir : bostream(),
126cdf0e10cSrcweir nCapacity1(0),
127cdf0e10cSrcweir dpData(0),
128cdf0e10cSrcweir pEnd(0),
129cdf0e10cSrcweir pCur(0),
130cdf0e10cSrcweir eMode(str::overwrite)
131cdf0e10cSrcweir {
132cdf0e10cSrcweir i_source.seek(0, csv::end);
133cdf0e10cSrcweir nCapacity1 = static_cast<size_type>(i_source.position()) + 1;
134cdf0e10cSrcweir i_source.seek(0);
135cdf0e10cSrcweir
136cdf0e10cSrcweir dpData = new char[nCapacity1];
137cdf0e10cSrcweir i_source.read(dpData, nCapacity1 - 1);
138cdf0e10cSrcweir pCur = dpData + nCapacity1 - 1;
139cdf0e10cSrcweir pEnd = pCur;
140cdf0e10cSrcweir *pCur = '\0';
141cdf0e10cSrcweir }
142cdf0e10cSrcweir
~StreamStr()143cdf0e10cSrcweir StreamStr::~StreamStr()
144cdf0e10cSrcweir {
145cdf0e10cSrcweir delete [] dpData;
146cdf0e10cSrcweir }
147cdf0e10cSrcweir
148cdf0e10cSrcweir
149cdf0e10cSrcweir StreamStr &
operator =(const self & i_rOther)150cdf0e10cSrcweir StreamStr::operator=( const self & i_rOther )
151cdf0e10cSrcweir {
152cdf0e10cSrcweir delete [] dpData;
153cdf0e10cSrcweir
154cdf0e10cSrcweir nCapacity1 = i_rOther.nCapacity1;
155cdf0e10cSrcweir dpData = new char [i_rOther.nCapacity1];
156cdf0e10cSrcweir pEnd = dpData + strlen(i_rOther.dpData);
157cdf0e10cSrcweir strcpy( dpData, i_rOther.dpData ); // SAFE STRCPY (#100211# - checked)
158cdf0e10cSrcweir pCur = dpData + i_rOther.tellp();
159cdf0e10cSrcweir eMode = i_rOther.eMode;
160cdf0e10cSrcweir
161cdf0e10cSrcweir return *this;
162cdf0e10cSrcweir }
163cdf0e10cSrcweir
164cdf0e10cSrcweir StreamStr &
operator <<(const char * i_s)165cdf0e10cSrcweir StreamStr::operator<<( const char * i_s )
166cdf0e10cSrcweir {
167cdf0e10cSrcweir size_type nLength = strlen(i_s);
168cdf0e10cSrcweir
169cdf0e10cSrcweir ProvideAddingSize( nLength );
170cdf0e10cSrcweir memcpy( pCur, i_s, nLength );
171cdf0e10cSrcweir Advance(nLength);
172cdf0e10cSrcweir
173cdf0e10cSrcweir return *this;
174cdf0e10cSrcweir }
175cdf0e10cSrcweir
176cdf0e10cSrcweir StreamStr &
operator <<(const String & i_s)177cdf0e10cSrcweir StreamStr::operator<<( const String & i_s )
178cdf0e10cSrcweir {
179cdf0e10cSrcweir size_type nLength = i_s.length();
180cdf0e10cSrcweir
181cdf0e10cSrcweir ProvideAddingSize( nLength );
182cdf0e10cSrcweir memcpy( pCur, i_s.c_str(), nLength );
183cdf0e10cSrcweir Advance(nLength);
184cdf0e10cSrcweir
185cdf0e10cSrcweir return *this;
186cdf0e10cSrcweir }
187cdf0e10cSrcweir
188cdf0e10cSrcweir StreamStr &
operator <<(char i_c)189cdf0e10cSrcweir StreamStr::operator<<( char i_c )
190cdf0e10cSrcweir {
191cdf0e10cSrcweir ProvideAddingSize( 1 );
192cdf0e10cSrcweir *pCur = i_c;
193cdf0e10cSrcweir Advance(1);
194cdf0e10cSrcweir
195cdf0e10cSrcweir return *this;
196cdf0e10cSrcweir }
197cdf0e10cSrcweir
198cdf0e10cSrcweir StreamStr &
operator <<(unsigned char i_c)199cdf0e10cSrcweir StreamStr::operator<<( unsigned char i_c )
200cdf0e10cSrcweir {
201cdf0e10cSrcweir return operator<<( char(i_c) );
202cdf0e10cSrcweir }
203cdf0e10cSrcweir
204cdf0e10cSrcweir StreamStr &
operator <<(signed char i_c)205cdf0e10cSrcweir StreamStr::operator<<( signed char i_c )
206cdf0e10cSrcweir {
207cdf0e10cSrcweir return operator<<( char(i_c) );
208cdf0e10cSrcweir }
209cdf0e10cSrcweir
210cdf0e10cSrcweir StreamStr &
operator <<(short i_n)211cdf0e10cSrcweir StreamStr::operator<<( short i_n )
212cdf0e10cSrcweir {
213cdf0e10cSrcweir char buf[C_short_max_size] = "";
214cdf0e10cSrcweir sprintf( buf, "%hi", i_n ); // SAFE SPRINTF (#100211# - checked)
215cdf0e10cSrcweir
216cdf0e10cSrcweir size_type nLength = strlen(buf);
217cdf0e10cSrcweir ProvideAddingSize( nLength );
218cdf0e10cSrcweir memcpy( pCur, buf, nLength );
219cdf0e10cSrcweir Advance( nLength );
220cdf0e10cSrcweir
221cdf0e10cSrcweir return *this;
222cdf0e10cSrcweir }
223cdf0e10cSrcweir
224cdf0e10cSrcweir StreamStr &
operator <<(unsigned short i_n)225cdf0e10cSrcweir StreamStr::operator<<( unsigned short i_n )
226cdf0e10cSrcweir {
227cdf0e10cSrcweir char buf[C_short_max_size] = "";
228cdf0e10cSrcweir sprintf( buf, "%hu", i_n ); // SAFE SPRINTF (#100211# - checked)
229cdf0e10cSrcweir
230cdf0e10cSrcweir size_type nLength = strlen(buf);
231cdf0e10cSrcweir ProvideAddingSize( nLength );
232cdf0e10cSrcweir memcpy( pCur, buf, nLength );
233cdf0e10cSrcweir Advance( nLength );
234cdf0e10cSrcweir
235cdf0e10cSrcweir return *this;
236cdf0e10cSrcweir }
237cdf0e10cSrcweir
238cdf0e10cSrcweir StreamStr &
operator <<(int i_n)239cdf0e10cSrcweir StreamStr::operator<<( int i_n )
240cdf0e10cSrcweir {
241cdf0e10cSrcweir char buf[C_int_max_size] = "";
242cdf0e10cSrcweir sprintf( buf, "%i", i_n ); // SAFE SPRINTF (#100211# - checked)
243cdf0e10cSrcweir
244cdf0e10cSrcweir size_type nLength = strlen(buf);
245cdf0e10cSrcweir ProvideAddingSize( nLength );
246cdf0e10cSrcweir memcpy( pCur, buf, nLength );
247cdf0e10cSrcweir Advance( nLength );
248cdf0e10cSrcweir
249cdf0e10cSrcweir return *this;
250cdf0e10cSrcweir }
251cdf0e10cSrcweir
252cdf0e10cSrcweir StreamStr &
operator <<(unsigned int i_n)253cdf0e10cSrcweir StreamStr::operator<<( unsigned int i_n )
254cdf0e10cSrcweir {
255cdf0e10cSrcweir char buf[C_int_max_size] = "";
256cdf0e10cSrcweir sprintf( buf, "%u", i_n ); // SAFE SPRINTF (#100211# - checked)
257cdf0e10cSrcweir
258cdf0e10cSrcweir size_type nLength = strlen(buf);
259cdf0e10cSrcweir ProvideAddingSize( nLength );
260cdf0e10cSrcweir memcpy( pCur, buf, nLength );
261cdf0e10cSrcweir Advance( nLength );
262cdf0e10cSrcweir
263cdf0e10cSrcweir return *this;
264cdf0e10cSrcweir }
265cdf0e10cSrcweir
266cdf0e10cSrcweir StreamStr &
operator <<(long i_n)267cdf0e10cSrcweir StreamStr::operator<<( long i_n )
268cdf0e10cSrcweir {
269cdf0e10cSrcweir char buf[C_long_max_size] = "";
270cdf0e10cSrcweir sprintf( buf, "%li", i_n ); // SAFE SPRINTF (#100211# - checked)
271cdf0e10cSrcweir
272cdf0e10cSrcweir size_type nLength = strlen(buf);
273cdf0e10cSrcweir ProvideAddingSize( nLength );
274cdf0e10cSrcweir memcpy( pCur, buf, nLength );
275cdf0e10cSrcweir Advance( nLength );
276cdf0e10cSrcweir
277cdf0e10cSrcweir return *this;
278cdf0e10cSrcweir }
279cdf0e10cSrcweir
280cdf0e10cSrcweir StreamStr &
operator <<(unsigned long i_n)281cdf0e10cSrcweir StreamStr::operator<<( unsigned long i_n )
282cdf0e10cSrcweir {
283cdf0e10cSrcweir char buf[C_long_max_size] = "";
284cdf0e10cSrcweir sprintf( buf, "%lu", i_n ); // SAFE SPRINTF (#100211# - checked)
285cdf0e10cSrcweir
286cdf0e10cSrcweir size_type nLength = strlen(buf);
287cdf0e10cSrcweir ProvideAddingSize( nLength );
288cdf0e10cSrcweir memcpy( pCur, buf, nLength );
289cdf0e10cSrcweir Advance( nLength );
290cdf0e10cSrcweir
291cdf0e10cSrcweir return *this;
292cdf0e10cSrcweir }
293cdf0e10cSrcweir
294cdf0e10cSrcweir StreamStr &
operator <<(float i_n)295cdf0e10cSrcweir StreamStr::operator<<( float i_n )
296cdf0e10cSrcweir {
297cdf0e10cSrcweir const int C_float_max_size = 20;
298cdf0e10cSrcweir char buf[C_float_max_size] = "";
299cdf0e10cSrcweir sprintf( buf, "%.*g", C_float_max_size-8, i_n ); // SAFE SPRINTF (#100211# - checked)
300cdf0e10cSrcweir
301cdf0e10cSrcweir size_type nLength = strlen(buf);
302cdf0e10cSrcweir ProvideAddingSize( nLength );
303cdf0e10cSrcweir memcpy( pCur, buf, nLength );
304cdf0e10cSrcweir Advance( nLength );
305cdf0e10cSrcweir
306cdf0e10cSrcweir return *this;
307cdf0e10cSrcweir }
308cdf0e10cSrcweir
309cdf0e10cSrcweir StreamStr &
operator <<(double i_n)310cdf0e10cSrcweir StreamStr::operator<<( double i_n )
311cdf0e10cSrcweir {
312cdf0e10cSrcweir const int C_double_max_size = 30;
313cdf0e10cSrcweir char buf[C_double_max_size] = "";
314cdf0e10cSrcweir sprintf( buf, "%.*lg", C_double_max_size-8, i_n ); // SAFE SPRINTF (#100211# - checked)
315cdf0e10cSrcweir
316cdf0e10cSrcweir size_type nLength = strlen(buf);
317cdf0e10cSrcweir ProvideAddingSize( nLength );
318cdf0e10cSrcweir memcpy( pCur, buf, nLength );
319cdf0e10cSrcweir Advance( nLength );
320cdf0e10cSrcweir
321cdf0e10cSrcweir return *this;
322cdf0e10cSrcweir }
323cdf0e10cSrcweir
324cdf0e10cSrcweir const char &
operator [](position_type i_nPosition) const325cdf0e10cSrcweir StreamStr::operator[]( position_type i_nPosition ) const
326cdf0e10cSrcweir {
327cdf0e10cSrcweir static const char aNull_ = '\0';
328cdf0e10cSrcweir
329cdf0e10cSrcweir if ( position_type(pEnd - dpData) > i_nPosition )
330cdf0e10cSrcweir return dpData[i_nPosition];
331cdf0e10cSrcweir return aNull_;
332cdf0e10cSrcweir }
333cdf0e10cSrcweir
334cdf0e10cSrcweir char &
operator [](position_type i_nPosition)335cdf0e10cSrcweir StreamStr::operator[]( position_type i_nPosition )
336cdf0e10cSrcweir {
337cdf0e10cSrcweir static char aDummy_ = '\0';
338cdf0e10cSrcweir
339cdf0e10cSrcweir if ( position_type(pEnd - dpData) > i_nPosition )
340cdf0e10cSrcweir return dpData[i_nPosition];
341cdf0e10cSrcweir return aDummy_;
342cdf0e10cSrcweir }
343cdf0e10cSrcweir
344cdf0e10cSrcweir void
resize(size_type i_nMinimumCapacity)345cdf0e10cSrcweir StreamStr::resize( size_type i_nMinimumCapacity )
346cdf0e10cSrcweir {
347cdf0e10cSrcweir if ( i_nMinimumCapacity <= capacity() )
348cdf0e10cSrcweir return;
349cdf0e10cSrcweir
350cdf0e10cSrcweir Resize(i_nMinimumCapacity);
351cdf0e10cSrcweir }
352cdf0e10cSrcweir
353cdf0e10cSrcweir void
swap(StreamStr & io_swap)354cdf0e10cSrcweir StreamStr::swap( StreamStr & io_swap )
355cdf0e10cSrcweir {
356cdf0e10cSrcweir size_type
357cdf0e10cSrcweir n = io_swap.nCapacity1;
358cdf0e10cSrcweir io_swap.nCapacity1 = nCapacity1;
359cdf0e10cSrcweir nCapacity1 = n;
360cdf0e10cSrcweir
361cdf0e10cSrcweir char *
362cdf0e10cSrcweir p = io_swap.dpData;
363cdf0e10cSrcweir io_swap.dpData = dpData;
364cdf0e10cSrcweir dpData = p;
365cdf0e10cSrcweir
366cdf0e10cSrcweir p = io_swap.pEnd;
367cdf0e10cSrcweir io_swap.pEnd = pEnd;
368cdf0e10cSrcweir pEnd = p;
369cdf0e10cSrcweir
370cdf0e10cSrcweir p = io_swap.pCur;
371cdf0e10cSrcweir io_swap.pCur = pCur;
372cdf0e10cSrcweir pCur = p;
373cdf0e10cSrcweir
374cdf0e10cSrcweir insert_mode
375cdf0e10cSrcweir m = io_swap.eMode;
376cdf0e10cSrcweir io_swap.eMode = eMode;
377cdf0e10cSrcweir eMode = m;
378cdf0e10cSrcweir }
379cdf0e10cSrcweir
380cdf0e10cSrcweir StreamStr &
seekp(seek_type i_nCount,seek_dir i_eDirection)381cdf0e10cSrcweir StreamStr::seekp( seek_type i_nCount,
382cdf0e10cSrcweir seek_dir i_eDirection )
383cdf0e10cSrcweir {
384cdf0e10cSrcweir seek_type nLength = seek_type( length() );
385cdf0e10cSrcweir seek_type nNewPos = tellp();
386cdf0e10cSrcweir
387cdf0e10cSrcweir switch ( i_eDirection )
388cdf0e10cSrcweir {
389cdf0e10cSrcweir case ::csv::beg: nNewPos = i_nCount;
390cdf0e10cSrcweir break;
391cdf0e10cSrcweir case ::csv::cur: nNewPos += i_nCount;
392cdf0e10cSrcweir break;
393cdf0e10cSrcweir case ::csv::end: nNewPos = nLength + i_nCount;
394cdf0e10cSrcweir break;
395cdf0e10cSrcweir }
396cdf0e10cSrcweir
397cdf0e10cSrcweir if ( in_range<seek_type>(0, nNewPos, nLength + 1) )
398cdf0e10cSrcweir {
399cdf0e10cSrcweir pCur = dpData + nNewPos;
400cdf0e10cSrcweir if (eMode == str::overwrite)
401cdf0e10cSrcweir {
402cdf0e10cSrcweir pEnd = pCur;
403cdf0e10cSrcweir *pEnd = '\0';
404cdf0e10cSrcweir }
405cdf0e10cSrcweir }
406cdf0e10cSrcweir
407cdf0e10cSrcweir return *this;
408cdf0e10cSrcweir }
409cdf0e10cSrcweir
410cdf0e10cSrcweir StreamStr &
set_insert_mode(insert_mode i_eMode)411cdf0e10cSrcweir StreamStr::set_insert_mode( insert_mode i_eMode )
412cdf0e10cSrcweir {
413cdf0e10cSrcweir eMode = i_eMode;
414cdf0e10cSrcweir return *this;
415cdf0e10cSrcweir }
416cdf0e10cSrcweir
417cdf0e10cSrcweir void
push_front(const char * i_str)418cdf0e10cSrcweir StreamStr::push_front( const char * i_str )
419cdf0e10cSrcweir {
420cdf0e10cSrcweir insert_mode eOriginalMode = eMode;
421cdf0e10cSrcweir char * pOriginalCur = pCur;
422cdf0e10cSrcweir eMode = str::insert;
423cdf0e10cSrcweir pCur = dpData;
424cdf0e10cSrcweir
425cdf0e10cSrcweir operator<<(i_str);
426cdf0e10cSrcweir
427cdf0e10cSrcweir eMode = eOriginalMode;
428cdf0e10cSrcweir pCur = pOriginalCur + strlen(i_str);
429cdf0e10cSrcweir }
430cdf0e10cSrcweir
431cdf0e10cSrcweir void
push_front(char i_c)432cdf0e10cSrcweir StreamStr::push_front( char i_c )
433cdf0e10cSrcweir {
434cdf0e10cSrcweir insert_mode eOriginalMode = eMode;
435cdf0e10cSrcweir char * pOriginalCur = pCur;
436cdf0e10cSrcweir eMode = str::insert;
437cdf0e10cSrcweir pCur = dpData;
438cdf0e10cSrcweir
439cdf0e10cSrcweir operator<<(i_c);
440cdf0e10cSrcweir
441cdf0e10cSrcweir eMode = eOriginalMode;
442cdf0e10cSrcweir pCur = pOriginalCur + 1;
443cdf0e10cSrcweir }
444cdf0e10cSrcweir
445cdf0e10cSrcweir void
push_back(const char * i_str)446cdf0e10cSrcweir StreamStr::push_back( const char * i_str )
447cdf0e10cSrcweir {
448cdf0e10cSrcweir insert_mode eOriginalMode = eMode;
449cdf0e10cSrcweir eMode = str::overwrite;
450cdf0e10cSrcweir
451cdf0e10cSrcweir operator<<(i_str);
452cdf0e10cSrcweir
453cdf0e10cSrcweir eMode = eOriginalMode;
454cdf0e10cSrcweir }
455cdf0e10cSrcweir
456cdf0e10cSrcweir void
push_back(char i_c)457cdf0e10cSrcweir StreamStr::push_back( char i_c )
458cdf0e10cSrcweir {
459cdf0e10cSrcweir insert_mode eOriginalMode = eMode;
460cdf0e10cSrcweir eMode = str::overwrite;
461cdf0e10cSrcweir
462cdf0e10cSrcweir operator<<(i_c);
463cdf0e10cSrcweir
464cdf0e10cSrcweir eMode = eOriginalMode;
465cdf0e10cSrcweir }
466cdf0e10cSrcweir
467cdf0e10cSrcweir void
pop_front(size_type i_nCount)468cdf0e10cSrcweir StreamStr::pop_front( size_type i_nCount )
469cdf0e10cSrcweir {
470cdf0e10cSrcweir size_type nCount = min(i_nCount, length());
471cdf0e10cSrcweir
472cdf0e10cSrcweir MoveData( dpData + nCount, pEnd, -(seek_type(nCount)) );
473cdf0e10cSrcweir
474cdf0e10cSrcweir pCur -= nCount;
475cdf0e10cSrcweir pEnd -= nCount;
476cdf0e10cSrcweir *pEnd = '\0';
477cdf0e10cSrcweir }
478cdf0e10cSrcweir
479cdf0e10cSrcweir void
pop_back(size_type i_nCount)480cdf0e10cSrcweir StreamStr::pop_back( size_type i_nCount )
481cdf0e10cSrcweir {
482cdf0e10cSrcweir size_type nCount = min(i_nCount, length());
483cdf0e10cSrcweir pEnd -= nCount;
484cdf0e10cSrcweir if (pCur > pEnd)
485cdf0e10cSrcweir pCur = pEnd;
486cdf0e10cSrcweir *pEnd = '\0';
487cdf0e10cSrcweir }
488cdf0e10cSrcweir
489cdf0e10cSrcweir StreamStr &
operator_join(std::vector<String>::const_iterator i_rBegin,std::vector<String>::const_iterator i_rEnd,const char * i_sLink)490cdf0e10cSrcweir StreamStr::operator_join( std::vector<String>::const_iterator i_rBegin,
491cdf0e10cSrcweir std::vector<String>::const_iterator i_rEnd,
492cdf0e10cSrcweir const char * i_sLink )
493cdf0e10cSrcweir {
494cdf0e10cSrcweir std::vector<String>::const_iterator it = i_rBegin;
495cdf0e10cSrcweir if ( it != i_rEnd )
496cdf0e10cSrcweir {
497cdf0e10cSrcweir operator<<(*it);
498cdf0e10cSrcweir for ( ++it; it != i_rEnd; ++it )
499cdf0e10cSrcweir {
500cdf0e10cSrcweir operator<<(i_sLink);
501cdf0e10cSrcweir operator<<(*it);
502cdf0e10cSrcweir }
503cdf0e10cSrcweir }
504cdf0e10cSrcweir return *this;
505cdf0e10cSrcweir }
506cdf0e10cSrcweir
507cdf0e10cSrcweir StreamStr &
operator_add_substr(const char * i_sText,size_type i_nLength)508cdf0e10cSrcweir StreamStr::operator_add_substr( const char * i_sText,
509cdf0e10cSrcweir size_type i_nLength )
510cdf0e10cSrcweir {
511cdf0e10cSrcweir size_type nLength = csv::min<size_type>(i_nLength, strlen(i_sText));
512cdf0e10cSrcweir
513cdf0e10cSrcweir ProvideAddingSize( nLength );
514cdf0e10cSrcweir memcpy( pCur, i_sText, nLength );
515cdf0e10cSrcweir Advance(nLength);
516cdf0e10cSrcweir
517cdf0e10cSrcweir return *this;
518cdf0e10cSrcweir }
519cdf0e10cSrcweir
520cdf0e10cSrcweir StreamStr &
operator_add_token(const char * i_sText,char i_cDelimiter)521cdf0e10cSrcweir StreamStr::operator_add_token( const char * i_sText,
522cdf0e10cSrcweir char i_cDelimiter )
523cdf0e10cSrcweir {
524cdf0e10cSrcweir const char * pTokenEnd = strchr(i_sText, i_cDelimiter);
525cdf0e10cSrcweir if (pTokenEnd == 0)
526cdf0e10cSrcweir operator<<(i_sText);
527cdf0e10cSrcweir else
528cdf0e10cSrcweir operator_add_substr(i_sText, pTokenEnd-i_sText);
529cdf0e10cSrcweir return *this;
530cdf0e10cSrcweir }
531cdf0e10cSrcweir
532cdf0e10cSrcweir StreamStr &
operator_read_line(bstream & i_src)533cdf0e10cSrcweir StreamStr::operator_read_line( bstream & i_src )
534cdf0e10cSrcweir {
535cdf0e10cSrcweir char c = 0;
536cdf0e10cSrcweir intt nCount = 0;
537cdf0e10cSrcweir for ( nCount = i_src.read(&c, 1);
538cdf0e10cSrcweir nCount == 1 AND c != 13 AND c != 10;
539cdf0e10cSrcweir nCount = i_src.read(&c, 1) )
540cdf0e10cSrcweir {
541cdf0e10cSrcweir operator<<(c);
542cdf0e10cSrcweir }
543cdf0e10cSrcweir
544cdf0e10cSrcweir bool bEndOfStream = nCount == 0;
545cdf0e10cSrcweir // Check for line-end:
546cdf0e10cSrcweir if ( NOT bEndOfStream AND c != 0 )
547cdf0e10cSrcweir {
548cdf0e10cSrcweir char oldc = c;
549cdf0e10cSrcweir if (i_src.read(&c, 1) == 1)
550cdf0e10cSrcweir {
551cdf0e10cSrcweir if ( (c != 13 AND c != 10) OR c == oldc)
552cdf0e10cSrcweir i_src.seek(-1,::csv::cur);
553cdf0e10cSrcweir }
554cdf0e10cSrcweir }
555cdf0e10cSrcweir return *this;
556cdf0e10cSrcweir }
557cdf0e10cSrcweir
558cdf0e10cSrcweir void
strip_front(char i_cToRemove)559cdf0e10cSrcweir StreamStr::strip_front(char i_cToRemove)
560cdf0e10cSrcweir {
561cdf0e10cSrcweir const_iterator it = begin();
562cdf0e10cSrcweir for ( ;
563cdf0e10cSrcweir it != end() ? *it == i_cToRemove : false;
564cdf0e10cSrcweir ++it ) ;
565cdf0e10cSrcweir pop_front(it - begin());
566cdf0e10cSrcweir }
567cdf0e10cSrcweir
568cdf0e10cSrcweir void
strip_back(char i_cToRemove)569cdf0e10cSrcweir StreamStr::strip_back(char i_cToRemove)
570cdf0e10cSrcweir {
571cdf0e10cSrcweir const_iterator it = end();
572cdf0e10cSrcweir for ( ;
573cdf0e10cSrcweir it != begin() ? *(it-1) == i_cToRemove : false;
574cdf0e10cSrcweir --it ) ;
575cdf0e10cSrcweir pop_back(end() - it);
576cdf0e10cSrcweir }
577cdf0e10cSrcweir
578cdf0e10cSrcweir void
strip_frontback(char i_cToRemove)579cdf0e10cSrcweir StreamStr::strip_frontback(char i_cToRemove)
580cdf0e10cSrcweir {
581cdf0e10cSrcweir strip_front(i_cToRemove);
582cdf0e10cSrcweir strip_back(i_cToRemove);
583cdf0e10cSrcweir }
584cdf0e10cSrcweir
585cdf0e10cSrcweir void
strip_front_whitespace()586cdf0e10cSrcweir StreamStr::strip_front_whitespace()
587cdf0e10cSrcweir {
588cdf0e10cSrcweir const_iterator it = begin();
589cdf0e10cSrcweir for ( ;
590cdf0e10cSrcweir it != end() ? *it < 33 : false;
591cdf0e10cSrcweir ++it ) ;
592cdf0e10cSrcweir pop_front(it - begin());
593cdf0e10cSrcweir }
594cdf0e10cSrcweir
595cdf0e10cSrcweir void
strip_back_whitespace()596cdf0e10cSrcweir StreamStr::strip_back_whitespace()
597cdf0e10cSrcweir {
598cdf0e10cSrcweir const_iterator it = end();
599cdf0e10cSrcweir for ( ;
600cdf0e10cSrcweir it != begin() ? *(it-1) < 33 : false;
601cdf0e10cSrcweir --it ) ;
602cdf0e10cSrcweir pop_back(end() - it);
603cdf0e10cSrcweir }
604cdf0e10cSrcweir
605cdf0e10cSrcweir void
strip_frontback_whitespace()606cdf0e10cSrcweir StreamStr::strip_frontback_whitespace()
607cdf0e10cSrcweir {
608cdf0e10cSrcweir strip_front_whitespace();
609cdf0e10cSrcweir strip_back_whitespace();
610cdf0e10cSrcweir }
611cdf0e10cSrcweir
612cdf0e10cSrcweir void
remove(iterator i_begin,iterator i_end)613cdf0e10cSrcweir StreamStr::remove( iterator i_begin,
614cdf0e10cSrcweir iterator i_end )
615cdf0e10cSrcweir {
616cdf0e10cSrcweir csv_assert(i_begin >= dpData AND i_begin <= pEnd);
617cdf0e10cSrcweir csv_assert(i_end >= dpData AND i_end <= pEnd);
618cdf0e10cSrcweir csv_assert(i_end >= i_begin);
619cdf0e10cSrcweir MoveData(i_end, pEnd, i_begin - i_end);
620cdf0e10cSrcweir pCur = pEnd;
621cdf0e10cSrcweir }
622cdf0e10cSrcweir
623cdf0e10cSrcweir void
replace(position_type i_nStart,size_type i_nSize,Area i_aReplacement)624cdf0e10cSrcweir StreamStr::replace( position_type i_nStart,
625cdf0e10cSrcweir size_type i_nSize,
626cdf0e10cSrcweir Area i_aReplacement )
627cdf0e10cSrcweir {
628cdf0e10cSrcweir if (i_nStart >= length() OR i_nSize < 1)
629cdf0e10cSrcweir return;
630cdf0e10cSrcweir
631cdf0e10cSrcweir insert_mode eOldMode = eMode;
632cdf0e10cSrcweir eMode = str::insert;
633cdf0e10cSrcweir pCur = dpData + i_nStart;
634cdf0e10cSrcweir
635cdf0e10cSrcweir size_type anz = min( length() - i_nStart, i_nSize );
636cdf0e10cSrcweir
637cdf0e10cSrcweir if ( anz < i_aReplacement.nLength )
638cdf0e10cSrcweir {
639cdf0e10cSrcweir ProvideAddingSize( i_aReplacement.nLength - anz );
640cdf0e10cSrcweir }
641cdf0e10cSrcweir else if ( anz > i_aReplacement.nLength )
642cdf0e10cSrcweir {
643cdf0e10cSrcweir seek_type nMove = seek_type(anz - i_aReplacement.nLength);
644cdf0e10cSrcweir
645cdf0e10cSrcweir MoveData( dpData + i_nStart + anz,
646cdf0e10cSrcweir pEnd,
647cdf0e10cSrcweir -nMove );
648cdf0e10cSrcweir pEnd -= nMove;
649cdf0e10cSrcweir *pEnd = '\0';
650cdf0e10cSrcweir }
651cdf0e10cSrcweir
652cdf0e10cSrcweir if (i_aReplacement.nLength > 0)
653cdf0e10cSrcweir {
654cdf0e10cSrcweir memcpy( dpData + i_nStart, i_aReplacement.sStr, i_aReplacement.nLength );
655cdf0e10cSrcweir Advance(i_aReplacement.nLength);
656cdf0e10cSrcweir }
657cdf0e10cSrcweir
658cdf0e10cSrcweir eMode = eOldMode;
659cdf0e10cSrcweir pCur = pEnd;
660cdf0e10cSrcweir }
661cdf0e10cSrcweir
662cdf0e10cSrcweir void
replace_all(char i_cCarToSearch,char i_cReplacement)663cdf0e10cSrcweir StreamStr::replace_all( char i_cCarToSearch,
664cdf0e10cSrcweir char i_cReplacement )
665cdf0e10cSrcweir {
666cdf0e10cSrcweir for ( char * p = dpData; p != pEnd; ++p )
667cdf0e10cSrcweir {
668cdf0e10cSrcweir if (*p == i_cCarToSearch)
669cdf0e10cSrcweir *p = i_cReplacement;
670cdf0e10cSrcweir }
671cdf0e10cSrcweir }
672cdf0e10cSrcweir
673cdf0e10cSrcweir void
replace_all(Area i_aStrToSearch,Area i_aReplacement)674cdf0e10cSrcweir StreamStr::replace_all( Area i_aStrToSearch,
675cdf0e10cSrcweir Area i_aReplacement )
676cdf0e10cSrcweir {
677cdf0e10cSrcweir position_type p = 0;
678cdf0e10cSrcweir const char * pSearch = i_aStrToSearch.sStr;
679cdf0e10cSrcweir size_type nSearch = i_aStrToSearch.nLength;
680cdf0e10cSrcweir
681cdf0e10cSrcweir while ( p <= length() - nSearch )
682cdf0e10cSrcweir {
683cdf0e10cSrcweir if ( strncmp(dpData+p, pSearch, nSearch) == 0 )
684cdf0e10cSrcweir {
685cdf0e10cSrcweir replace( p, nSearch, i_aReplacement );
686cdf0e10cSrcweir p += i_aReplacement.nLength;
687cdf0e10cSrcweir }
688cdf0e10cSrcweir else
689cdf0e10cSrcweir {
690cdf0e10cSrcweir ++p;
691cdf0e10cSrcweir }
692cdf0e10cSrcweir } // end while
693cdf0e10cSrcweir }
694cdf0e10cSrcweir
695cdf0e10cSrcweir StreamStr &
to_lower(position_type i_nStart,size_type i_nLength)696cdf0e10cSrcweir StreamStr::to_lower( position_type i_nStart,
697cdf0e10cSrcweir size_type i_nLength )
698cdf0e10cSrcweir {
699cdf0e10cSrcweir static char cLower[128] =
700cdf0e10cSrcweir { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
701cdf0e10cSrcweir 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
702cdf0e10cSrcweir 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
703cdf0e10cSrcweir 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
704cdf0e10cSrcweir 64, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
705cdf0e10cSrcweir 112,113,114,115,116,117,118,119,120,121,122, 91, 92, 93, 94, 95,
706cdf0e10cSrcweir 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
707cdf0e10cSrcweir 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127 };
708cdf0e10cSrcweir
709cdf0e10cSrcweir if ( i_nStart < length() )
710cdf0e10cSrcweir {
711cdf0e10cSrcweir char * pStop = i_nStart + i_nLength < length()
712cdf0e10cSrcweir ? dpData + i_nStart + i_nLength
713cdf0e10cSrcweir : pEnd;
714cdf0e10cSrcweir for ( char * pChange = dpData + i_nStart;
715cdf0e10cSrcweir pChange != pStop;
716cdf0e10cSrcweir ++pChange )
717cdf0e10cSrcweir {
718cdf0e10cSrcweir *pChange = (static_cast< unsigned char >(*pChange) & 0x80) == 0
719cdf0e10cSrcweir ? cLower[ UINT8(*pChange) ]
720cdf0e10cSrcweir : *pChange;
721cdf0e10cSrcweir }
722cdf0e10cSrcweir }
723cdf0e10cSrcweir return *this;
724cdf0e10cSrcweir }
725cdf0e10cSrcweir
726cdf0e10cSrcweir StreamStr &
to_upper(position_type i_nStart,size_type i_nLength)727cdf0e10cSrcweir StreamStr::to_upper( position_type i_nStart,
728cdf0e10cSrcweir size_type i_nLength )
729cdf0e10cSrcweir {
730cdf0e10cSrcweir static char cUpper[128] =
731cdf0e10cSrcweir { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
732cdf0e10cSrcweir 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
733cdf0e10cSrcweir 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
734cdf0e10cSrcweir 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
735cdf0e10cSrcweir 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
736cdf0e10cSrcweir 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
737cdf0e10cSrcweir 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
738cdf0e10cSrcweir 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123,124,125,126,127 };
739cdf0e10cSrcweir
740cdf0e10cSrcweir if ( i_nStart < length() )
741cdf0e10cSrcweir {
742cdf0e10cSrcweir char * pStop = i_nStart + i_nLength < length()
743cdf0e10cSrcweir ? dpData + i_nStart + i_nLength
744cdf0e10cSrcweir : pEnd;
745cdf0e10cSrcweir for ( char * pChange = dpData + i_nStart;
746cdf0e10cSrcweir pChange != pStop;
747cdf0e10cSrcweir ++pChange )
748cdf0e10cSrcweir {
749cdf0e10cSrcweir *pChange = (static_cast< unsigned char >(*pChange) & 0x80) == 0
750cdf0e10cSrcweir ? cUpper[ UINT8(*pChange) ]
751cdf0e10cSrcweir : *pChange;
752cdf0e10cSrcweir }
753cdf0e10cSrcweir }
754cdf0e10cSrcweir return *this;
755cdf0e10cSrcweir }
756cdf0e10cSrcweir
757cdf0e10cSrcweir
758cdf0e10cSrcweir StreamStr::size_type
token_count(char i_cSplit) const759cdf0e10cSrcweir StreamStr::token_count( char i_cSplit ) const
760cdf0e10cSrcweir {
761cdf0e10cSrcweir return count_chars(dpData, i_cSplit) + 1;
762cdf0e10cSrcweir }
763cdf0e10cSrcweir
764cdf0e10cSrcweir String
token(position_type i_nNr,char i_cSplit) const765cdf0e10cSrcweir StreamStr::token( position_type i_nNr,
766cdf0e10cSrcweir char i_cSplit ) const
767cdf0e10cSrcweir {
768cdf0e10cSrcweir // Find begin:
769cdf0e10cSrcweir const char * pTokenBegin = dpData;
770cdf0e10cSrcweir for ( position_type nNr = i_nNr;
771cdf0e10cSrcweir nNr > 0;
772cdf0e10cSrcweir --nNr )
773cdf0e10cSrcweir {
774cdf0e10cSrcweir pTokenBegin = strchr(pTokenBegin,i_cSplit);
775cdf0e10cSrcweir if (pTokenBegin == 0)
776cdf0e10cSrcweir return String("");
777cdf0e10cSrcweir ++pTokenBegin;
778cdf0e10cSrcweir }
779cdf0e10cSrcweir
780cdf0e10cSrcweir // Find end:
781cdf0e10cSrcweir const char * pTokenEnd = strchr(pTokenBegin, i_cSplit);
782cdf0e10cSrcweir if (pTokenEnd == 0)
783cdf0e10cSrcweir pTokenEnd = pEnd;
784cdf0e10cSrcweir
785cdf0e10cSrcweir return String(pTokenBegin, size_type(pTokenEnd-pTokenBegin) );
786cdf0e10cSrcweir }
787cdf0e10cSrcweir
788cdf0e10cSrcweir class StreamStrPool
789cdf0e10cSrcweir {
790cdf0e10cSrcweir public:
791cdf0e10cSrcweir StreamStrPool();
792cdf0e10cSrcweir ~StreamStrPool();
793cdf0e10cSrcweir private:
794cdf0e10cSrcweir // Non-copyable
795cdf0e10cSrcweir StreamStrPool(StreamStrPool &); // not defined
796cdf0e10cSrcweir void operator =(StreamStrPool &); // not defined
797cdf0e10cSrcweir
798cdf0e10cSrcweir // Interface to:
799cdf0e10cSrcweir friend class StreamStrLock;
800cdf0e10cSrcweir static StreamStr & AcquireFromPool_(
801cdf0e10cSrcweir uintt i_nMinimalSize );
802cdf0e10cSrcweir static void ReleaseToPool_(
803cdf0e10cSrcweir DYN StreamStr * let_dpUsedStr );
804cdf0e10cSrcweir
805cdf0e10cSrcweir // DATA
806cdf0e10cSrcweir SweList< DYN StreamStr* >
807cdf0e10cSrcweir aPool;
808cdf0e10cSrcweir };
809cdf0e10cSrcweir
StreamStrPool()810cdf0e10cSrcweir StreamStrPool::StreamStrPool()
811cdf0e10cSrcweir {
812cdf0e10cSrcweir }
813cdf0e10cSrcweir
~StreamStrPool()814cdf0e10cSrcweir StreamStrPool::~StreamStrPool()
815cdf0e10cSrcweir {
816cdf0e10cSrcweir for ( SweList< DYN StreamStr* >::iterator it = aPool.begin();
817cdf0e10cSrcweir it != aPool.end();
818cdf0e10cSrcweir ++it )
819cdf0e10cSrcweir {
820cdf0e10cSrcweir delete (*it);
821cdf0e10cSrcweir }
822cdf0e10cSrcweir }
823cdf0e10cSrcweir
824cdf0e10cSrcweir namespace
825cdf0e10cSrcweir {
826cdf0e10cSrcweir static StreamStrPool aPool_;
827cdf0e10cSrcweir }
828cdf0e10cSrcweir
829cdf0e10cSrcweir
830cdf0e10cSrcweir StreamStr &
AcquireFromPool_(uintt i_nMinimalSize)831cdf0e10cSrcweir StreamStrPool::AcquireFromPool_( uintt i_nMinimalSize )
832cdf0e10cSrcweir {
833cdf0e10cSrcweir if ( aPool_.aPool.empty() )
834cdf0e10cSrcweir {
835cdf0e10cSrcweir return *new StreamStr(i_nMinimalSize);
836cdf0e10cSrcweir }
837cdf0e10cSrcweir
838cdf0e10cSrcweir StreamStr & ret = *aPool_.aPool.front();
839cdf0e10cSrcweir aPool_.aPool.pop_front();
840cdf0e10cSrcweir ret.resize(i_nMinimalSize);
841cdf0e10cSrcweir ret.seekp(0);
842cdf0e10cSrcweir ret.set_insert_mode(str::overwrite);
843cdf0e10cSrcweir return ret;
844cdf0e10cSrcweir }
845cdf0e10cSrcweir
846cdf0e10cSrcweir void
ReleaseToPool_(DYN StreamStr * let_dpUsedStr)847cdf0e10cSrcweir StreamStrPool::ReleaseToPool_( DYN StreamStr * let_dpUsedStr )
848cdf0e10cSrcweir {
849cdf0e10cSrcweir aPool_.aPool.push_back( let_dpUsedStr );
850cdf0e10cSrcweir }
851cdf0e10cSrcweir
StreamStrLock(uintt i_nMinimalSize)852cdf0e10cSrcweir StreamStrLock::StreamStrLock( uintt i_nMinimalSize )
853cdf0e10cSrcweir : pStr( &StreamStrPool::AcquireFromPool_(i_nMinimalSize) )
854cdf0e10cSrcweir {
855cdf0e10cSrcweir }
856cdf0e10cSrcweir
~StreamStrLock()857cdf0e10cSrcweir StreamStrLock::~StreamStrLock()
858cdf0e10cSrcweir {
859cdf0e10cSrcweir StreamStrPool::ReleaseToPool_(pStr);
860cdf0e10cSrcweir }
861cdf0e10cSrcweir
862cdf0e10cSrcweir
863cdf0e10cSrcweir UINT32
do_write(const void * i_pSrc,UINT32 i_nNrofBytes)864cdf0e10cSrcweir StreamStr::do_write( const void * i_pSrc,
865cdf0e10cSrcweir UINT32 i_nNrofBytes )
866cdf0e10cSrcweir {
867cdf0e10cSrcweir ProvideAddingSize( i_nNrofBytes );
868cdf0e10cSrcweir memcpy( pCur, i_pSrc, i_nNrofBytes );
869cdf0e10cSrcweir Advance(i_nNrofBytes);
870cdf0e10cSrcweir
871cdf0e10cSrcweir return i_nNrofBytes;
872cdf0e10cSrcweir }
873cdf0e10cSrcweir
874cdf0e10cSrcweir void
ProvideAddingSize(size_type i_nSize2Add)875cdf0e10cSrcweir StreamStr::ProvideAddingSize( size_type i_nSize2Add )
876cdf0e10cSrcweir {
877cdf0e10cSrcweir size_type nLength = length();
878cdf0e10cSrcweir if ( capacity() - nLength < i_nSize2Add )
879cdf0e10cSrcweir Resize( nLength + i_nSize2Add );
880cdf0e10cSrcweir
881cdf0e10cSrcweir pEnd += i_nSize2Add;
882cdf0e10cSrcweir *pEnd = '\0';
883cdf0e10cSrcweir
884cdf0e10cSrcweir if (eMode == str::insert AND pCur != pEnd)
885cdf0e10cSrcweir {
886cdf0e10cSrcweir MoveData( pCur, pCur + i_nSize2Add, seek_type(i_nSize2Add) );
887cdf0e10cSrcweir }
888cdf0e10cSrcweir }
889cdf0e10cSrcweir
890cdf0e10cSrcweir void
Resize(size_type i_nMinimumCapacity)891cdf0e10cSrcweir StreamStr::Resize( size_type i_nMinimumCapacity )
892cdf0e10cSrcweir {
893cdf0e10cSrcweir size_type nNewSize = nCapacity1 < 128
894cdf0e10cSrcweir ? nCapacity1 << 1
895cdf0e10cSrcweir : (nCapacity1 << 1) - (nCapacity1 >> 1);
896cdf0e10cSrcweir nCapacity1 = csv::max( nNewSize, size_type(i_nMinimumCapacity + 1) );
897cdf0e10cSrcweir
898cdf0e10cSrcweir char * pNew = new char[nCapacity1];
899cdf0e10cSrcweir strcpy ( pNew, dpData ); // SAFE STRCPY (#100211# - checked)
900cdf0e10cSrcweir pEnd = pNew + (pEnd - dpData);
901cdf0e10cSrcweir pCur = pNew + (pCur - dpData);
902cdf0e10cSrcweir
903cdf0e10cSrcweir delete [] dpData;
904cdf0e10cSrcweir dpData = pNew;
905cdf0e10cSrcweir }
906cdf0e10cSrcweir
907cdf0e10cSrcweir void
MoveData(char * i_pStart,char * i_pEnd,seek_type i_nDiff)908cdf0e10cSrcweir StreamStr::MoveData( char * i_pStart,
909cdf0e10cSrcweir char * i_pEnd,
910cdf0e10cSrcweir seek_type i_nDiff )
911cdf0e10cSrcweir {
912cdf0e10cSrcweir if (i_nDiff > 0)
913cdf0e10cSrcweir {
914cdf0e10cSrcweir register const char * pSrc = i_pEnd;
915cdf0e10cSrcweir register char * pDest = i_pEnd + i_nDiff;
916cdf0e10cSrcweir for ( ; pSrc != i_pStart; --pSrc, --pDest )
917cdf0e10cSrcweir {
918cdf0e10cSrcweir *pDest = *pSrc;
919cdf0e10cSrcweir }
920cdf0e10cSrcweir *pDest = *pSrc;
921cdf0e10cSrcweir }
922cdf0e10cSrcweir else if (i_nDiff < 0)
923cdf0e10cSrcweir {
924cdf0e10cSrcweir const char * pSrc = i_pStart;
925cdf0e10cSrcweir char * pDest = i_pStart + i_nDiff;
926cdf0e10cSrcweir for ( ; pSrc != i_pEnd; ++pSrc, ++pDest )
927cdf0e10cSrcweir {
928cdf0e10cSrcweir *pDest = *pSrc;
929cdf0e10cSrcweir }
930cdf0e10cSrcweir }
931cdf0e10cSrcweir }
932cdf0e10cSrcweir
933cdf0e10cSrcweir // Does nothing, only the name of this function is needed.
934cdf0e10cSrcweir void
c_str()935cdf0e10cSrcweir c_str()
936cdf0e10cSrcweir {
937cdf0e10cSrcweir // Does nothing.
938cdf0e10cSrcweir }
939cdf0e10cSrcweir
940cdf0e10cSrcweir
941cdf0e10cSrcweir
942cdf0e10cSrcweir void
Split(std::vector<String> & o_list,const char * i_text)943cdf0e10cSrcweir Split( std::vector<String> & o_list,
944cdf0e10cSrcweir const char * i_text )
945cdf0e10cSrcweir {
946cdf0e10cSrcweir const char *
947cdf0e10cSrcweir pCurrentToken = 0;
948cdf0e10cSrcweir bool
949cdf0e10cSrcweir white = false;
950cdf0e10cSrcweir for (const char * p = i_text; *p != '\0'; ++p)
951cdf0e10cSrcweir {
952cdf0e10cSrcweir white = UINT8(*p) > 32;
953cdf0e10cSrcweir if (pCurrentToken != 0)
954cdf0e10cSrcweir {
955cdf0e10cSrcweir if (white)
956cdf0e10cSrcweir {
957cdf0e10cSrcweir o_list.push_back(String(pCurrentToken, p));
958cdf0e10cSrcweir pCurrentToken = 0;
959cdf0e10cSrcweir }
960cdf0e10cSrcweir }
961cdf0e10cSrcweir else
962cdf0e10cSrcweir {
963cdf0e10cSrcweir if ( NOT white)
964cdf0e10cSrcweir pCurrentToken = p;
965cdf0e10cSrcweir } // endif (bInToken) else
966cdf0e10cSrcweir } // end for
967cdf0e10cSrcweir
968cdf0e10cSrcweir if (pCurrentToken != 0)
969cdf0e10cSrcweir {
970cdf0e10cSrcweir o_list.push_back(String(pCurrentToken));
971cdf0e10cSrcweir }
972cdf0e10cSrcweir }
973cdf0e10cSrcweir
974cdf0e10cSrcweir
975cdf0e10cSrcweir
976cdf0e10cSrcweir
977cdf0e10cSrcweir } // namespace csv
978