mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 17:02:10 -10:00
* StringBuilder.cs (Insert int, char[]): fix by using new string(char[]) instead of char[].ToString() and simplify. (Insert int, string, int): add LAMESPEC note. (Insert int char[], int, int): handle value==null according to spec. Use a string instead of char array + Array.Copy (gonzalo) svn path=/trunk/mcs/; revision=23920
612 lines
16 KiB
C#
612 lines
16 KiB
C#
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
|
|
//
|
|
// System.Text.StringBuilder
|
|
//
|
|
// Authors:
|
|
// Marcin Szczepanski ([email protected])
|
|
// Paolo Molaro ([email protected])
|
|
// 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.
|
|
//
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace System.Text {
|
|
|
|
[Serializable]
|
|
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
|
|
if (startIndex + (length -1) > (value.Length - 1) )
|
|
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(value, 0, value == null ? 0 : value.Length, value == null? 0 : value.Length) {
|
|
}
|
|
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
if( startIndex + count > _length || 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 + count > _length)
|
|
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) || (charCount + startIndex > value.Length))
|
|
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 + count > value.Length))
|
|
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 + charCount > value.Length)
|
|
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;
|
|
}
|
|
|
|
string tmp = String.InternalAllocateStr (capacity);
|
|
if (_length > 0)
|
|
String.InternalStrcpy (tmp, 0, _str, 0, _length);
|
|
|
|
_str = tmp;
|
|
}
|
|
|
|
_cached_str = null;
|
|
}
|
|
}
|
|
}
|