1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
|
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
//
// System.Text.StringBuilder
//
// Authors:
// Marcin Szczepanski (marcins@zipworld.com.au)
// Paolo Molaro (lupus@ximian.com)
// Patrik Torstensson
//
// NOTE: In the case the buffer is only filled by 50% a new string
// will be returned by ToString() is cached in the '_cached_str'
// cache_string will also control if a string has been handed out
// to via ToString(). If you are chaning the code make sure that
// if you modify the string data set the cache_string to null.
//
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.Runtime.CompilerServices;
namespace System.Text {
[Serializable]
[MonoTODO ("Fix serialization compatibility with MS.NET")]
public sealed class StringBuilder
{
private int _length;
private string _str = null;
private string _cached_str = null;
private int _maxCapacity = Int32.MaxValue;
private const int constDefaultCapacity = 16;
public StringBuilder(string value, int startIndex, int length, int capacity)
{
// first, check the parameters and throw appropriate exceptions if needed
if (null == value)
value = "";
// make sure startIndex is zero or positive
if (startIndex < 0)
throw new System.ArgumentOutOfRangeException ("startIndex", startIndex, "StartIndex cannot be less than zero.");
// make sure length is zero or positive
if(length < 0)
throw new System.ArgumentOutOfRangeException ("length", length, "Length cannot be less than zero.");
if (capacity < 0)
throw new System.ArgumentOutOfRangeException ("capacity", capacity, "capacity must be greater than zero.");
// make sure startIndex and length give a valid substring of value
// re-ordered to avoid possible integer overflow
if (startIndex > value.Length - length)
throw new System.ArgumentOutOfRangeException ("startIndex", startIndex, "StartIndex and length must refer to a location within the string.");
if (capacity == 0)
capacity = constDefaultCapacity;
_str = String.InternalAllocateStr ((length > capacity) ? length : capacity);
if (length > 0)
String.InternalStrcpy(_str, 0, value, startIndex, length);
_length = length;
}
public StringBuilder () : this (String.Empty, 0, 0, 0) {}
public StringBuilder(int capacity) : this (String.Empty, 0, 0, capacity) {}
public StringBuilder(int capacity, int maxCapacity) : this (String.Empty, 0, 0, capacity) {
if (capacity > maxCapacity)
throw new System.ArgumentOutOfRangeException ("capacity", "Capacity exceeds maximum capacity.");
_maxCapacity = maxCapacity;
}
public StringBuilder( string value ) : this() {
Append (value);
}
public StringBuilder( string value, int capacity) : this(value, 0, value.Length, capacity) {}
public int MaxCapacity {
get {
// MS runtime always returns Int32.MaxValue.
return _maxCapacity;
}
}
public int Capacity {
get {
return _str.Length;
}
set {
if (value < _length)
throw new ArgumentException( "Capacity must be larger than length" );
InternalEnsureCapacity(value);
}
}
public int Length {
get {
return _length;
}
set {
if( value < 0 || value > _maxCapacity)
throw new ArgumentOutOfRangeException();
if (value == _length)
return;
if( value < _length )
{
// LAMESPEC: The spec is unclear as to what to do
// with the capacity when truncating the string.
// Do as MS, keep the capacity
_length = value;
} else
{
// Expand the capacity to the new length and
// pad the string with spaces.
// LAMESPEC: The spec says to put the spaces on the
// left of the string however the MS implementation
// puts them on the right. We'll do that for
// compatibility (!)
Append(' ', value - _length);
}
}
}
[IndexerName("Chars")]
public char this [int index] {
get {
if (index >= _length || index < 0)
throw new IndexOutOfRangeException();
return _str [index];
}
set {
if (index >= _length || index < 0)
throw new IndexOutOfRangeException();
if (null != _cached_str)
InternalEnsureCapacity (_length);
_str.InternalSetChar (index, value);
}
}
public override string ToString ()
{
if (_length == 0)
return String.Empty;
if (null != _cached_str)
return _cached_str;
// If we only have a half-full buffer we return a new string.
if (_length < (_str.Length >> 1))
{
_cached_str = _str.Substring(0, _length);
return _cached_str;
}
_cached_str = _str;
_str.InternalSetLength(_length);
return _str;
}
public string ToString (int startIndex, int length)
{
// re-ordered to avoid possible integer overflow
if (startIndex < 0 || length < 0 || startIndex > _length - length)
throw new ArgumentOutOfRangeException();
return _str.Substring (startIndex, length);
}
public int EnsureCapacity (int capacity)
{
if (capacity < 0)
throw new ArgumentOutOfRangeException ("Capacity must be greater than 0." );
if( capacity <= _str.Length )
return _str.Length;
InternalEnsureCapacity (capacity);
return _str.Length;
}
public bool Equals (StringBuilder sb)
{
if (_length == sb.Length && _str == sb._str )
return true;
return false;
}
public StringBuilder Remove (int startIndex, int length)
{
// re-ordered to avoid possible integer overflow
if (startIndex < 0 || length < 0 || startIndex > _length - length)
throw new ArgumentOutOfRangeException();
// Copy everything after the 'removed' part to the start
// of the removed part and truncate the sLength
if (_length - (startIndex + length) > 0)
String.InternalStrcpy (_str, startIndex, _str, startIndex + length, _length - (startIndex + length));
_length -= length;
if (null != _cached_str)
InternalEnsureCapacity (_length);
return this;
}
public StringBuilder Replace (char oldChar, char newChar)
{
return Replace( oldChar, newChar, 0, _length);
}
public StringBuilder Replace (char oldChar, char newChar, int startIndex, int count)
{
// re-ordered to avoid possible integer overflow
if (startIndex > _length - count || startIndex < 0 || count < 0)
throw new ArgumentOutOfRangeException();
if (null != _cached_str)
InternalEnsureCapacity (_str.Length);
for (int replaceIterate = startIndex; replaceIterate < startIndex + count; replaceIterate++ ) {
if( _str [replaceIterate] == oldChar )
_str.InternalSetChar (replaceIterate, newChar);
}
return this;
}
public StringBuilder Replace( string oldValue, string newValue ) {
return Replace (oldValue, newValue, 0, _length);
}
public StringBuilder Replace( string oldValue, string newValue, int startIndex, int count )
{
if (oldValue == null)
throw new ArgumentNullException ("The old value cannot be null.");
if (startIndex < 0 || count < 0 || startIndex > _length - count)
throw new ArgumentOutOfRangeException ();
if (oldValue.Length == 0)
throw new ArgumentException ("The old value cannot be zero length.");
// TODO: OPTIMIZE!
string replace = _str.Substring(startIndex, count).Replace(oldValue, newValue);
InternalEnsureCapacity (replace.Length + (_length - count));
String.InternalStrcpy (_str, startIndex, replace);
_length = replace.Length + (_length - count);
return this;
}
/* The Append Methods */
public StringBuilder Append (char[] value)
{
if (value == null)
return this;
int needed_cap = _length + value.Length;
if (null != _cached_str || _str.Length < needed_cap)
InternalEnsureCapacity (needed_cap);
for (int i = 0; i != value.Length; i++)
_str.InternalSetChar (i + _length, value[i]);
_length += value.Length;
return this;
}
public StringBuilder Append (string value)
{
if (value == null)
return this;
int needed_cap = _length + value.Length;
if (null != _cached_str || _str.Length < needed_cap)
InternalEnsureCapacity (needed_cap);
String.InternalStrcpy (_str, _length, value);
_length += value.Length;
return this;
}
public StringBuilder Append (bool value) {
return Append (value.ToString());
}
public StringBuilder Append (byte value) {
return Append (value.ToString());
}
public StringBuilder Append (decimal value) {
return Append (value.ToString());
}
public StringBuilder Append (double value) {
return Append (value.ToString());
}
public StringBuilder Append (short value) {
return Append (value.ToString());
}
public StringBuilder Append (int value) {
return Append (value.ToString());
}
public StringBuilder Append (long value) {
return Append (value.ToString());
}
public StringBuilder Append (object value) {
if (value == null)
return this;
return Append (value.ToString());
}
[CLSCompliant(false)]
public StringBuilder Append (sbyte value) {
return Append (value.ToString());
}
public StringBuilder Append (float value) {
return Append (value.ToString());
}
[CLSCompliant(false)]
public StringBuilder Append (ushort value) {
return Append (value.ToString());
}
[CLSCompliant(false)]
public StringBuilder Append (uint value) {
return Append (value.ToString());
}
[CLSCompliant(false)]
public StringBuilder Append (ulong value) {
return Append (value.ToString());
}
public StringBuilder Append (char value)
{
int needed_cap = _length + 1;
if (null != _cached_str || _str.Length < needed_cap)
InternalEnsureCapacity (needed_cap);
_str.InternalSetChar(_length, value);
_length++;
return this;
}
public StringBuilder Append (char value, int repeatCount)
{
if( repeatCount < 0 )
throw new ArgumentOutOfRangeException();
InternalEnsureCapacity (_length + repeatCount);
for (int i = 0; i < repeatCount; i++)
_str.InternalSetChar (_length++, value);
return this;
}
public StringBuilder Append( char[] value, int startIndex, int charCount )
{
if (value == null) {
if (!(startIndex == 0 && charCount == 0))
throw new ArgumentNullException ("value");
return this;
}
if ((charCount < 0 || startIndex < 0) || (startIndex > value.Length - charCount))
throw new ArgumentOutOfRangeException();
InternalEnsureCapacity (_length + charCount);
int endPos = charCount + startIndex;
for (int i = startIndex; i != endPos; i++)
_str.InternalSetChar (_length++, value[i]);
return this;
}
public StringBuilder Append (string value, int startIndex, int count)
{
if (value == null) {
if (startIndex != 0 && count != 0)
throw new ArgumentNullException ("value");
return this;
}
if ((count < 0 || startIndex < 0) || (startIndex > value.Length - count))
throw new ArgumentOutOfRangeException();
int needed_cap = _length + count;
if (null != _cached_str || _str.Length < needed_cap)
InternalEnsureCapacity (needed_cap);
String.InternalStrcpy (_str, _length, value, startIndex, count);
_length += count;
return this;
}
public StringBuilder AppendFormat (string format, object arg0)
{
return AppendFormat (null, format, new object [] { arg0 });
}
public StringBuilder AppendFormat (string format, params object[] args)
{
return AppendFormat (null, format, args);
}
public StringBuilder AppendFormat (IFormatProvider provider,
string format,
params object[] args)
{
String.FormatHelper (this, provider, format, args);
return this;
}
public StringBuilder AppendFormat (string format, object arg0, object arg1)
{
return AppendFormat (null, format, new object [] { arg0, arg1 });
}
public StringBuilder AppendFormat (string format, object arg0, object arg1, object arg2)
{
return AppendFormat (null, format, new object [] { arg0, arg1, arg2 });
}
/* The Insert Functions */
public StringBuilder Insert (int index, char[] value)
{
return Insert (index, new string (value));
}
public StringBuilder Insert (int index, string value)
{
if( index > _length || index < 0)
throw new ArgumentOutOfRangeException();
if (value == null || value.Length == 0)
return this;
InternalEnsureCapacity (_length + value.Length);
// Move everything to the right of the insert point across
String.InternalStrcpy (_str, index + value.Length, _str, index, _length - index);
// Copy in stuff from the insert buffer
String.InternalStrcpy (_str, index, value);
_length += value.Length;
return this;
}
public StringBuilder Insert( int index, bool value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, byte value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, char value)
{
if (index > _length || index < 0)
throw new ArgumentOutOfRangeException ("index");
InternalEnsureCapacity (_length + 1);
// Move everything to the right of the insert point across
String.InternalStrcpy (_str, index + 1, _str, index, _length - index);
_str.InternalSetChar (index, value);
_length++;
return this;
}
public StringBuilder Insert( int index, decimal value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, double value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, short value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, int value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, long value ) {
return Insert (index, value.ToString());
}
public StringBuilder Insert( int index, object value ) {
return Insert (index, value.ToString());
}
[CLSCompliant(false)]
public StringBuilder Insert( int index, sbyte value ) {
return Insert (index, value.ToString() );
}
public StringBuilder Insert (int index, float value) {
return Insert (index, value.ToString() );
}
[CLSCompliant(false)]
public StringBuilder Insert (int index, ushort value) {
return Insert (index, value.ToString() );
}
[CLSCompliant(false)]
public StringBuilder Insert (int index, uint value) {
return Insert ( index, value.ToString() );
}
[CLSCompliant(false)]
public StringBuilder Insert (int index, ulong value) {
return Insert ( index, value.ToString() );
}
public StringBuilder Insert (int index, string value, int count)
{
// LAMESPEC: The spec says to throw an exception if
// count < 0, while MS throws even for count < 1!
if ( count < 0 )
throw new ArgumentOutOfRangeException();
if (value != null && value != String.Empty)
for (int insertCount = 0; insertCount < count; insertCount++)
Insert( index, value );
return this;
}
public StringBuilder Insert (int index, char [] value, int startIndex, int charCount)
{
if (value == null) {
if (startIndex == 0 && charCount == 0)
return this;
throw new ArgumentNullException ("value");
}
if (charCount < 0 || startIndex < 0 || startIndex > value.Length - charCount)
throw new ArgumentOutOfRangeException ();
return Insert (index, new String (value, startIndex, charCount));
}
private void InternalEnsureCapacity (int size)
{
if (size > _str.Length || _cached_str == _str)
{
int capacity = _str.Length;
// Try double buffer, if that doesn't work, set the length as capacity
if (size > capacity)
{
capacity = capacity << 1;
if (size > capacity)
capacity = size;
if (capacity >= Int32.MaxValue || capacity < 0)
capacity = Int32.MaxValue;
if (capacity > _maxCapacity)
throw new ArgumentOutOfRangeException ("size", "capacity was less than the current size.");
}
string tmp = String.InternalAllocateStr (capacity);
if (_length > 0)
String.InternalStrcpy (tmp, 0, _str, 0, _length);
_str = tmp;
}
_cached_str = null;
}
}
}
|