/* StringBuffer.java -- Growable strings Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the 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, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ package java.lang; import java.io.Serializable; /** * StringBuffer represents a changeable String. * It provides the operations required to modify the * StringBuffer, including insert, replace, delete, append, * and reverse. It is thread-safe; meaning that all modifications to a buffer * are in synchronized methods. * *

StringBuffers are variable-length in nature, so even if * you initialize them to a certain size, they can still grow larger than * that. Capacity indicates the number of characters the * StringBuffer can have in it before it has to grow (growing * the char array is an expensive operation involving new). * *

Incidentally, compilers often implement the String operator "+" * by using a StringBuffer operation:
* a + b
* is the same as
* new StringBuffer().append(a).append(b).toString(). * *

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 * @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 final static int DEFAULT_CAPACITY = 16; /** * Create a new StringBuffer with default capacity 16. */ public StringBuffer() { this(DEFAULT_CAPACITY); } /** * Create an empty StringBuffer 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 StringBuffer with the characters in the * specified String. Initial capacity will be the size of the * String plus 16. * * @param str the String 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); } /** * Get the length of the String this StringBuffer * would create. Not to be confused with the capacity of the * StringBuffer. * * @return the length of this StringBuffer * @see #capacity() * @see #setLength(int) */ public synchronized int length() { return count; } /** * Get the total number of characters this StringBuffer can * support before it must be grown. Not to be confused with length. * * @return the capacity of this StringBuffer * @see #length() * @see #ensureCapacity(int) */ public synchronized int capacity() { return value.length; } /** * Increase the capacity of this StringBuffer. This will * ensure that an expensive growing operation will not occur until * minimumCapacity is reached. The buffer is grown to the * larger of minimumCapacity and * capacity() * 2 + 2, 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 newLength * 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); ensureCapacity_unsynchronized(newLength); while (count < newLength) value[count++] = '\0'; count = newLength; } /** * 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 >= length() * (while unspecified, this is a StringIndexOutOfBoundsException) */ public synchronized char charAt(int index) { if (index < 0 || index >= count) throw new StringIndexOutOfBoundsException(index); return value[index]; } /** * Get the specified array of characters. srcOffset - srcEnd * 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) { int todo = srcEnd - srcOffset; if (srcOffset < 0 || srcEnd > count || todo < 0) throw new StringIndexOutOfBoundsException(); System.arraycopy(value, srcOffset, dst, dstOffset, todo); } /** * 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 >= 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 String value of the argument to this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param obj the Object to convert and append * @return this StringBuffer * @see String#valueOf(Object) * @see #append(String) */ public StringBuffer append(Object obj) { return append(obj == null ? "null" : obj.toString()); } /** * Append the String to this StringBuffer. If * str is null, the String "null" is appended. * * @param str the String to append * @return this StringBuffer */ 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 StringBuffer value of the argument to this * StringBuffer. This behaves the same as * append((Object) stringBuffer), except it is more efficient. * * @param stringBuffer the StringBuffer to convert and append * @return this StringBuffer * @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; } /** * Append the char array to this StringBuffer. * This is similar (but more efficient) than * append(new String(data)), except in the case of null. * * @param data the char[] to append * @return this StringBuffer * @throws NullPointerException if str is null * @see #append(char[], int, int) */ public StringBuffer append(char[] data) { return append(data, 0, data.length); } /** * Append part of the char array to this * StringBuffer. This is similar (but more efficient) than * append(new String(data, offset, count)), except in the case * of null. * * @param data the char[] to append * @param offset the start location in str * @param count the number of characters to get from str * @return this StringBuffer * @throws NullPointerException if str is null * @throws IndexOutOfBoundsException if offset or count is out of range * (while unspecified, this is a StringIndexOutOfBoundsException) */ public synchronized StringBuffer append(char[] data, int offset, int count) { ensureCapacity_unsynchronized(this.count + count); System.arraycopy(data, offset, value, this.count, count); this.count += count; return this; } /** * Append the String value of the argument to this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param bool the boolean to convert and append * @return this StringBuffer * @see String#valueOf(boolean) */ public StringBuffer append(boolean bool) { return append(bool ? "true" : "false"); } /** * Append the char to this StringBuffer. * * @param c the char to append * @return this StringBuffer */ public synchronized StringBuffer append(char ch) { ensureCapacity_unsynchronized(count + 1); value[count++] = ch; return this; } /** * Append the String value of the argument to this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param inum the int to convert and append * @return this StringBuffer * @see String#valueOf(int) */ // GCJ LOCAL: this is native for efficiency. public native StringBuffer append (int inum); /** * Append the String value of the argument to this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param lnum the long to convert and append * @return this StringBuffer * @see String#valueOf(long) */ public StringBuffer append(long lnum) { return append(Long.toString(lnum, 10)); } /** * Append the String value of the argument to this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param fnum the float to convert and append * @return this StringBuffer * @see String#valueOf(float) */ public StringBuffer append(float fnum) { return append(Float.toString(fnum)); } /** * Append the String value of the argument to this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param dnum the double to convert and append * @return this StringBuffer * @see String#valueOf(double) */ public StringBuffer append(double dnum) { return append(Double.toString(dnum)); } /** * Delete characters from this StringBuffer. * delete(10, 12) will delete 10 and 11, but not 12. It is * harmless for end to be larger than length(). * * @param start the first character to delete * @param end the index after the last character to delete * @return this StringBuffer * @throws StringIndexOutOfBoundsException if start or end are out of bounds * @since 1.2 */ public synchronized StringBuffer delete(int start, int end) { if (start < 0 || start > count || start > end) throw new StringIndexOutOfBoundsException(start); if (end > count) end = count; // This will unshare if required. ensureCapacity_unsynchronized(count); if (count - end != 0) System.arraycopy(value, end, value, start, count - end); count -= end - start; return this; } /** * Delete a character from this StringBuffer. * * @param index the index of the character to delete * @return this StringBuffer * @throws StringIndexOutOfBoundsException if index is out of bounds * @since 1.2 */ public StringBuffer deleteCharAt(int index) { return delete(index, index + 1); } /** * Replace characters between index start (inclusive) and * end (exclusive) with str. If end * is larger than the size of this StringBuffer, all characters after * start are replaced. * * @param start the beginning index of characters to delete (inclusive) * @param end the ending index of characters to delete (exclusive) * @param str the new String to insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if start or end are out of bounds * @throws NullPointerException if str is null * @since 1.2 */ public synchronized StringBuffer replace(int start, int end, String str) { if (start < 0 || start > count || start > end) throw new StringIndexOutOfBoundsException(start); int len = str.count; // Calculate the difference in 'count' after the replace. int delta = len - (end > count ? count : end) + start; ensureCapacity_unsynchronized(count + delta); if (delta != 0 && end < count) System.arraycopy(value, end, value, end + delta, count - end); str.getChars(0, len, value, start); count += delta; return this; } /** * Creates a substring of this StringBuffer, starting at a specified index * and ending at the end of this StringBuffer. * * @param beginIndex index to start substring (base 0) * @return new String which is a substring of this StringBuffer * @throws StringIndexOutOfBoundsException if beginIndex is out of bounds * @see #substring(int, int) * @since 1.2 */ public String substring(int beginIndex) { return substring(beginIndex, count); } /** * Creates a substring of this StringBuffer, starting at a specified index * and ending at one character before a specified index. This is implemented * the same as substring(beginIndex, endIndex), to satisfy * the CharSequence interface. * * @param beginIndex index to start at (inclusive, base 0) * @param endIndex index to end at (exclusive) * @return new String which is a substring of this StringBuffer * @throws IndexOutOfBoundsException if beginIndex or endIndex is out of * bounds * @see #substring(int, int) * @since 1.4 */ public CharSequence subSequence(int beginIndex, int endIndex) { return substring(beginIndex, endIndex); } /** * Creates a substring of this StringBuffer, starting at a specified index * and ending at one character before a specified index. * * @param beginIndex index to start at (inclusive, base 0) * @param endIndex index to end at (exclusive) * @return new String which is a substring of this StringBuffer * @throws StringIndexOutOfBoundsException if beginIndex or endIndex is out * of bounds * @since 1.2 */ public synchronized String substring(int beginIndex, int endIndex) { int len = endIndex - beginIndex; if (beginIndex < 0 || endIndex > count || len < 0) throw new StringIndexOutOfBoundsException(); if (len == 0) return ""; // Share the char[] unless 3/4 empty. shared = (len << 2) >= value.length; // Package constructor avoids an array copy. return new String(value, beginIndex, len, shared); } /** * Insert a subarray of the char[] argument into this * StringBuffer. * * @param offset the place to insert in this buffer * @param str the char[] to insert * @param str_offset the index in str to start inserting from * @param len the number of characters to insert * @return this StringBuffer * @throws NullPointerException if str is null * @throws StringIndexOutOfBoundsException if any index is out of bounds * @since 1.2 */ public synchronized StringBuffer insert(int offset, char[] str, int str_offset, int len) { if (offset < 0 || offset > count || len < 0 || str_offset < 0 || str_offset + len > str.length) throw new StringIndexOutOfBoundsException(); ensureCapacity_unsynchronized(count + len); System.arraycopy(value, offset, value, offset + len, count - offset); System.arraycopy(str, str_offset, value, offset, len); count += len; return this; } /** * Insert the String value of the argument into this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param offset the place to insert in this buffer * @param obj the Object to convert and insert * @return this StringBuffer * @exception StringIndexOutOfBoundsException if offset is out of bounds * @see String#valueOf(Object) */ public StringBuffer insert(int offset, Object obj) { return insert(offset, obj == null ? "null" : obj.toString()); } /** * Insert the String argument into this * StringBuffer. If str is null, the String "null" is used * instead. * * @param offset the place to insert in this buffer * @param str the String to insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds */ public synchronized StringBuffer insert(int offset, String str) { if (offset < 0 || offset > count) throw new StringIndexOutOfBoundsException(offset); if (str == null) str = "null"; int len = str.count; ensureCapacity_unsynchronized(count + len); System.arraycopy(value, offset, value, offset + len, count - offset); str.getChars(0, len, value, offset); count += len; return this; } /** * Insert the char[] argument into this * StringBuffer. * * @param offset the place to insert in this buffer * @param data the char[] to insert * @return this StringBuffer * @throws NullPointerException if data is null * @throws StringIndexOutOfBoundsException if offset is out of bounds * @see #insert(int, char[], int, int) */ public StringBuffer insert(int offset, char[] data) { return insert(offset, data, 0, data.length); } /** * Insert the String value of the argument into this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param offset the place to insert in this buffer * @param bool the boolean to convert and insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds * @see String#valueOf(boolean) */ public StringBuffer insert(int offset, boolean bool) { return insert(offset, bool ? "true" : "false"); } /** * Insert the char argument into this StringBuffer. * * @param offset the place to insert in this buffer * @param ch the char to insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds */ public synchronized StringBuffer insert(int offset, char ch) { if (offset < 0 || offset > count) throw new StringIndexOutOfBoundsException(offset); ensureCapacity_unsynchronized(count + 1); System.arraycopy(value, offset, value, offset + 1, count - offset); value[offset] = ch; count++; return this; } /** * Insert the String value of the argument into this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param offset the place to insert in this buffer * @param inum the int to convert and insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds * @see String#valueOf(int) */ public StringBuffer insert(int offset, int inum) { return insert(offset, String.valueOf(inum)); } /** * Insert the String value of the argument into this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param offset the place to insert in this buffer * @param lnum the long to convert and insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds * @see String#valueOf(long) */ public StringBuffer insert(int offset, long lnum) { return insert(offset, Long.toString(lnum, 10)); } /** * Insert the String value of the argument into this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param offset the place to insert in this buffer * @param fnum the float to convert and insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds * @see String#valueOf(float) */ public StringBuffer insert(int offset, float fnum) { return insert(offset, Float.toString(fnum)); } /** * Insert the String value of the argument into this * StringBuffer. Uses String.valueOf() to convert * to String. * * @param offset the place to insert in this buffer * @param dnum the double to convert and insert * @return this StringBuffer * @throws StringIndexOutOfBoundsException if offset is out of bounds * @see String#valueOf(double) */ public StringBuffer insert(int offset, double dnum) { return insert(offset, Double.toString(dnum)); } /** * Finds the first instance of a substring in this StringBuffer. * * @param str String to find * @return location (base 0) of the String, or -1 if not found * @throws NullPointerException if str is null * @see #indexOf(String, int) * @since 1.4 */ public int indexOf(String str) { return indexOf(str, 0); } /** * Finds the first instance of a String in this StringBuffer, starting at * a given index. If starting index is less than 0, the search starts at * the beginning of this String. If the starting index is greater than the * length of this String, or the substring is not found, -1 is returned. * * @param str String to find * @param fromIndex index to start the search * @return location (base 0) of the String, or -1 if not found * @throws NullPointerException if str is null * @since 1.4 */ public synchronized int indexOf(String str, int fromIndex) { if (fromIndex < 0) fromIndex = 0; int limit = count - str.count; for ( ; fromIndex <= limit; fromIndex++) if (regionMatches(fromIndex, str)) return fromIndex; return -1; } /** * Finds the last instance of a substring in this StringBuffer. * * @param str String to find * @return location (base 0) of the String, or -1 if not found * @throws NullPointerException if str is null * @see #lastIndexOf(String, int) * @since 1.4 */ public int lastIndexOf(String str) { return lastIndexOf(str, count - str.count); } /** * Finds the last instance of a String in this StringBuffer, starting at a * given index. If starting index is greater than the maximum valid index, * then the search begins at the end of this String. If the starting index * is less than zero, or the substring is not found, -1 is returned. * * @param str String to find * @param fromIndex index to start the search * @return location (base 0) of the String, or -1 if not found * @throws NullPointerException if str is null * @since 1.4 */ public synchronized int lastIndexOf(String str, int fromIndex) { fromIndex = Math.min(fromIndex, count - str.count); for ( ; fromIndex >= 0; fromIndex--) if (regionMatches(fromIndex, str)) return fromIndex; return -1; } /** * Reverse the characters in this StringBuffer. The same sequence of * characters exists, but in the reverse index ordering. * * @return this StringBuffer */ public synchronized StringBuffer reverse() { // Call ensureCapacity to enforce copy-on-write. ensureCapacity_unsynchronized(count); for (int i = count >> 1, j = count - i; --i >= 0; ++j) { char c = value[i]; value[i] = value[j]; value[j] = c; } return this; } /** * Convert this StringBuffer to a String. The * String is composed of the characters currently in this StringBuffer. Note * that the result is a copy, and that future modifications to this buffer * do not affect the String. * * @return the characters in this StringBuffer */ public String toString() { // The string will set this.shared = true. return new String(this); } /** * An unsynchronized version of ensureCapacity, used internally to avoid * the cost of a second lock on the same object. This also has the side * effect of duplicating the array, if it was shared (to form copy-on-write * semantics). * * @param minimumCapacity the minimum capacity * @see #ensureCapacity(int) */ private void ensureCapacity_unsynchronized(int minimumCapacity) { if (shared || minimumCapacity > value.length) { // We don't want to make a larger vector when `shared' is // set. If we do, then setLength becomes very inefficient // when repeatedly reusing a StringBuffer in a loop. int max = (minimumCapacity > value.length ? value.length * 2 + 2 : value.length); minimumCapacity = (minimumCapacity < max ? max : minimumCapacity); char[] nb = new char[minimumCapacity]; System.arraycopy(value, 0, nb, 0, count); value = nb; shared = false; } } /** * Predicate which determines if a substring of this matches another String * starting at a specified offset for each String and continuing for a * specified length. This is more efficient than creating a String to call * indexOf on. * * @param toffset index to start comparison at for this String * @param other non-null String to compare to region of this * @return true if regions match, false otherwise * @see #indexOf(String, int) * @see #lastIndexOf(String, int) * @see String#regionMatches(boolean, int, String, int, int) */ // GCJ LOCAL: native for gcj. private native boolean regionMatches(int toffset, String other); }