/* StringBuffer.java -- Growable strings   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006   Free Software Foundation, Inc.This file is part of GNU Classpath.GNU Classpath is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation; either version 2, or (at your option)any later version.GNU Classpath is distributed in the hope that it will be useful, butWITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNUGeneral Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Classpath; see the file COPYING.  If not, write to theFree Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA02110-1301 USA.Linking this library statically or dynamically with other modules ismaking a combined work based on this library.  Thus, the terms andconditions of the GNU General Public License cover the wholecombination.As a special exception, the copyright holders of this library give youpermission to link this library with independent modules to produce anexecutable, regardless of the license terms of these independentmodules, and to copy and distribute the resulting executable underterms of your choice, provided that you also meet, for each linkedindependent module, the terms and conditions of the license of thatmodule.  An independent module is a module which is not derived fromor based on this library.  If you modify this library, you may extendthis exception to your version of the library, but you are notobligated to do so.  If you do not wish to do so, delete thisexception statement from your version. */package java.lang;import java.io.Serializable;/** * <code>StringBuffer</code> represents a changeable <code>String</code>. * It provides the operations required to modify the * <code>StringBuffer</code>, including insert, replace, delete, append, * and reverse. It is thread-safe; meaning that all modifications to a buffer * are in synchronized methods. * * <p><code>StringBuffer</code>s are variable-length in nature, so even if * you initialize them to a certain size, they can still grow larger than * that. <em>Capacity</em> indicates the number of characters the * <code>StringBuffer</code> can have in it before it has to grow (growing * the char array is an expensive operation involving <code>new</code>). * * <p>Incidentally, compilers often implement the String operator "+" * by using a <code>StringBuffer</code> operation:<br> * <code>a + b</code><br> * is the same as<br> * <code>new StringBuffer().append(a).append(b).toString()</code>. * * <p>Classpath's StringBuffer is capable of sharing memory with Strings for * efficiency.  This will help when a StringBuffer is converted to a String * and the StringBuffer is not changed after that (quite common when performing * string concatenation). * * @author Paul Fisher * @author John Keiser * @author Tom Tromey * @author Eric Blake (ebb9@email.byu.edu) * @see String * @since 1.0 * @status updated to 1.4 */public final class StringBuffer implements Serializable, CharSequence{  /**   * Compatible with JDK 1.0+.   */  private static final long serialVersionUID = 3388685877147921107L;  /**   * Index of next available character (and thus the size of the current   * string contents).  Note that this has permissions set this way so that   * String can get the value.   *   * @serial the number of characters in the buffer   */  int count;  /**   * The buffer.  Note that this has permissions set this way so that String   * can get the value.   *   * @serial the buffer   */  char[] value;  /**   * True if the buffer is shared with another object (StringBuffer or   * String); this means the buffer must be copied before writing to it again.   * Note that this has permissions set this way so that String can get the   * value.   *   * @serial whether the buffer is shared   */  boolean shared;  /**   * The default capacity of a buffer.   */  private static final int DEFAULT_CAPACITY = 16;  /**   * Create a new StringBuffer with default capacity 16.   */  public StringBuffer()  {    this(DEFAULT_CAPACITY);  }  /**   * Create an empty <code>StringBuffer</code> with the specified initial   * capacity.   *   * @param capacity the initial capacity   * @throws NegativeArraySizeException if capacity is negative   */  public StringBuffer(int capacity)  {    value = new char[capacity];  }  /**   * Create a new <code>StringBuffer</code> with the characters in the   * specified <code>String</code>. Initial capacity will be the size of the   * String plus 16.   *   * @param str the <code>String</code> to convert   * @throws NullPointerException if str is null   */  public StringBuffer(String str)  {    // Unfortunately, because the size is 16 larger, we cannot share.    count = str.count;    value = new char[count + DEFAULT_CAPACITY];    str.getChars(0, count, value, 0);  }  /**   * Create a new <code>StringBuffer</code> with the characters from the   * specified <code>CharSequence</code>. Initial capacity will be the   * size of the CharSequence plus 16.   *   * @param sequence the <code>String</code> to convert   * @throws NullPointerException if str is null   *   * @since 1.5   */  public StringBuffer(CharSequence sequence)  {    count = Math.max(0, sequence.length());    value = new char[count + DEFAULT_CAPACITY];    for (int i = 0; i < count; ++i)      value[i] = sequence.charAt(i);  }  /**   * Get the length of the <code>String</code> this <code>StringBuffer</code>   * would create. Not to be confused with the <em>capacity</em> of the   * <code>StringBuffer</code>.   *   * @return the length of this <code>StringBuffer</code>   * @see #capacity()   * @see #setLength(int)   */  public synchronized int length()  {    return count;  }  /**   * Get the total number of characters this <code>StringBuffer</code> can   * support before it must be grown.  Not to be confused with <em>length</em>.   *   * @return the capacity of this <code>StringBuffer</code>   * @see #length()   * @see #ensureCapacity(int)   */  public synchronized int capacity()  {    return value.length;  }  /**   * Increase the capacity of this <code>StringBuffer</code>. This will   * ensure that an expensive growing operation will not occur until   * <code>minimumCapacity</code> is reached. The buffer is grown to the   * larger of <code>minimumCapacity</code> and   * <code>capacity() * 2 + 2</code>, if it is not already large enough.   *   * @param minimumCapacity the new capacity   * @see #capacity()   */  public synchronized void ensureCapacity(int minimumCapacity)  {    ensureCapacity_unsynchronized(minimumCapacity);  }  /**   * Set the length of this StringBuffer. If the new length is greater than   * the current length, all the new characters are set to '\0'. If the new   * length is less than the current length, the first <code>newLength</code>   * characters of the old array will be preserved, and the remaining   * characters are truncated.   *   * @param newLength the new length   * @throws IndexOutOfBoundsException if the new length is negative   *         (while unspecified, this is a StringIndexOutOfBoundsException)   * @see #length()   */  public synchronized void setLength(int newLength)  {    if (newLength < 0)      throw new StringIndexOutOfBoundsException(newLength);    int valueLength = value.length;    /* Always call ensureCapacity_unsynchronized in order to preserve       copy-on-write semantics.  */    ensureCapacity_unsynchronized(newLength);    if (newLength < valueLength)      {        /* If the StringBuffer's value just grew, then we know that           value is newly allocated and the region between count and           newLength is filled with '\0'.  */	count = newLength;      }    else      {	/* The StringBuffer's value doesn't need to grow.  However,	   we should clear out any cruft that may exist.  */	while (count < newLength)          value[count++] = '\0';      }  }  /**   * Get the character at the specified index.   *   * @param index the index of the character to get, starting at 0   * @return the character at the specified index   * @throws IndexOutOfBoundsException if index is negative or &gt;= length()   */  public synchronized char charAt(int index)  {    if (index < 0 || index >= count)      throw new StringIndexOutOfBoundsException(index);    return value[index];  }  /**   * Get the code point at the specified index.  This is like #charAt(int),   * but if the character is the start of a surrogate pair, and the   * following character completes the pair, then the corresponding   * supplementary code point is returned.   * @param index the index of the codepoint to get, starting at 0   * @return the codepoint at the specified index   * @throws IndexOutOfBoundsException if index is negative or &gt;= length()   * @since 1.5   */  public synchronized int codePointAt(int index)  {    return Character.codePointAt(value, index, count);  }  /**   * Get the code point before the specified index.  This is like   * #codePointAt(int), but checks the characters at <code>index-1</code> and   * <code>index-2</code> to see if they form a supplementary code point.   * @param index the index just past the codepoint to get, starting at 0   * @return the codepoint at the specified index   * @throws IndexOutOfBoundsException if index is negative or &gt;= length()   * @since 1.5   */  public synchronized int codePointBefore(int index)  {    // Character.codePointBefore() doesn't perform this check.  We    // could use the CharSequence overload, but this is just as easy.    if (index >= count)      throw new IndexOutOfBoundsException();    return Character.codePointBefore(value, index, 1);  }  /**   * Get the specified array of characters. <code>srcOffset - srcEnd</code>   * characters will be copied into the array you pass in.   *   * @param srcOffset the index to start copying from (inclusive)   * @param srcEnd the index to stop copying from (exclusive)   * @param dst the array to copy into   * @param dstOffset the index to start copying into   * @throws NullPointerException if dst is null   * @throws IndexOutOfBoundsException if any source or target indices are   *         out of range (while unspecified, source problems cause a   *         StringIndexOutOfBoundsException, and dest problems cause an   *         ArrayIndexOutOfBoundsException)   * @see System#arraycopy(Object, int, Object, int, int)   */  public synchronized void getChars(int srcOffset, int srcEnd,                                    char[] dst, int dstOffset)  {    if (srcOffset < 0 || srcEnd > count || srcEnd < srcOffset)      throw new StringIndexOutOfBoundsException();    System.arraycopy(value, srcOffset, dst, dstOffset, srcEnd - srcOffset);  }  /**   * Set the character at the specified index.   *   * @param index the index of the character to set starting at 0   * @param ch the value to set that character to   * @throws IndexOutOfBoundsException if index is negative or &gt;= length()   *         (while unspecified, this is a StringIndexOutOfBoundsException)   */  public synchronized void setCharAt(int index, char ch)  {    if (index < 0 || index >= count)      throw new StringIndexOutOfBoundsException(index);    // Call ensureCapacity to enforce copy-on-write.    ensureCapacity_unsynchronized(count);    value[index] = ch;  }  /**   * Append the <code>String</code> value of the argument to this   * <code>StringBuffer</code>. Uses <code>String.valueOf()</code> to convert   * to <code>String</code>.   *   * @param obj the <code>Object</code> to convert and append   * @return this <code>StringBuffer</code>   * @see String#valueOf(Object)   * @see #append(String)   */  public StringBuffer append(Object obj)  {    return append(obj == null ? "null" : obj.toString());  }  /**   * Append the <code>String</code> to this <code>StringBuffer</code>. If   * str is null, the String "null" is appended.   *   * @param str the <code>String</code> to append   * @return this <code>StringBuffer</code>   */  public synchronized StringBuffer append(String str)  {    if (str == null)      str = "null";    int len = str.count;    ensureCapacity_unsynchronized(count + len);    str.getChars(0, len, value, count);    count += len;    return this;  }  /**   * Append the <code>StringBuffer</code> value of the argument to this   * <code>StringBuffer</code>. This behaves the same as   * <code>append((Object) stringBuffer)</code>, except it is more efficient.   *   * @param stringBuffer the <code>StringBuffer</code> to convert and append   * @return this <code>StringBuffer</code>   * @see #append(Object)   * @since 1.4   */  public synchronized StringBuffer append(StringBuffer stringBuffer)  {    if (stringBuffer == null)      return append("null");    synchronized (stringBuffer)      {        int len = stringBuffer.count;        ensureCapacity_unsynchronized(count + len);        System.arraycopy(stringBuffer.value, 0, value, count, len);        count += len;      }    return this;  }  /**