mono/mcs/class/corlib/System.Text/StringBuilder.cs

// -*- 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;
		}
	}
}