1.1 --- a/emul/src/main/java/java/lang/StringBuffer.java Fri Jan 25 11:00:52 2013 +0100
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,604 +0,0 @@
1.4 -/*
1.5 - * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
1.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
1.7 - *
1.8 - * This code is free software; you can redistribute it and/or modify it
1.9 - * under the terms of the GNU General Public License version 2 only, as
1.10 - * published by the Free Software Foundation. Oracle designates this
1.11 - * particular file as subject to the "Classpath" exception as provided
1.12 - * by Oracle in the LICENSE file that accompanied this code.
1.13 - *
1.14 - * This code is distributed in the hope that it will be useful, but WITHOUT
1.15 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1.16 - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
1.17 - * version 2 for more details (a copy is included in the LICENSE file that
1.18 - * accompanied this code).
1.19 - *
1.20 - * You should have received a copy of the GNU General Public License version
1.21 - * 2 along with this work; if not, write to the Free Software Foundation,
1.22 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
1.23 - *
1.24 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
1.25 - * or visit www.oracle.com if you need additional information or have any
1.26 - * questions.
1.27 - */
1.28 -
1.29 -package java.lang;
1.30 -
1.31 -
1.32 -/**
1.33 - * A thread-safe, mutable sequence of characters.
1.34 - * A string buffer is like a {@link String}, but can be modified. At any
1.35 - * point in time it contains some particular sequence of characters, but
1.36 - * the length and content of the sequence can be changed through certain
1.37 - * method calls.
1.38 - * <p>
1.39 - * String buffers are safe for use by multiple threads. The methods
1.40 - * are synchronized where necessary so that all the operations on any
1.41 - * particular instance behave as if they occur in some serial order
1.42 - * that is consistent with the order of the method calls made by each of
1.43 - * the individual threads involved.
1.44 - * <p>
1.45 - * The principal operations on a <code>StringBuffer</code> are the
1.46 - * <code>append</code> and <code>insert</code> methods, which are
1.47 - * overloaded so as to accept data of any type. Each effectively
1.48 - * converts a given datum to a string and then appends or inserts the
1.49 - * characters of that string to the string buffer. The
1.50 - * <code>append</code> method always adds these characters at the end
1.51 - * of the buffer; the <code>insert</code> method adds the characters at
1.52 - * a specified point.
1.53 - * <p>
1.54 - * For example, if <code>z</code> refers to a string buffer object
1.55 - * whose current contents are "<code>start</code>", then
1.56 - * the method call <code>z.append("le")</code> would cause the string
1.57 - * buffer to contain "<code>startle</code>", whereas
1.58 - * <code>z.insert(4, "le")</code> would alter the string buffer to
1.59 - * contain "<code>starlet</code>".
1.60 - * <p>
1.61 - * In general, if sb refers to an instance of a <code>StringBuffer</code>,
1.62 - * then <code>sb.append(x)</code> has the same effect as
1.63 - * <code>sb.insert(sb.length(), x)</code>.
1.64 - * <p>
1.65 - * Whenever an operation occurs involving a source sequence (such as
1.66 - * appending or inserting from a source sequence) this class synchronizes
1.67 - * only on the string buffer performing the operation, not on the source.
1.68 - * <p>
1.69 - * Every string buffer has a capacity. As long as the length of the
1.70 - * character sequence contained in the string buffer does not exceed
1.71 - * the capacity, it is not necessary to allocate a new internal
1.72 - * buffer array. If the internal buffer overflows, it is
1.73 - * automatically made larger.
1.74 - *
1.75 - * As of release JDK 5, this class has been supplemented with an equivalent
1.76 - * class designed for use by a single thread, {@link StringBuilder}. The
1.77 - * <tt>StringBuilder</tt> class should generally be used in preference to
1.78 - * this one, as it supports all of the same operations but it is faster, as
1.79 - * it performs no synchronization.
1.80 - *
1.81 - * @author Arthur van Hoff
1.82 - * @see java.lang.StringBuilder
1.83 - * @see java.lang.String
1.84 - * @since JDK1.0
1.85 - */
1.86 - public final class StringBuffer
1.87 - extends AbstractStringBuilder
1.88 - implements java.io.Serializable, CharSequence
1.89 -{
1.90 -
1.91 - /** use serialVersionUID from JDK 1.0.2 for interoperability */
1.92 - static final long serialVersionUID = 3388685877147921107L;
1.93 -
1.94 - /**
1.95 - * Constructs a string buffer with no characters in it and an
1.96 - * initial capacity of 16 characters.
1.97 - */
1.98 - public StringBuffer() {
1.99 - super(16);
1.100 - }
1.101 -
1.102 - /**
1.103 - * Constructs a string buffer with no characters in it and
1.104 - * the specified initial capacity.
1.105 - *
1.106 - * @param capacity the initial capacity.
1.107 - * @exception NegativeArraySizeException if the <code>capacity</code>
1.108 - * argument is less than <code>0</code>.
1.109 - */
1.110 - public StringBuffer(int capacity) {
1.111 - super(capacity);
1.112 - }
1.113 -
1.114 - /**
1.115 - * Constructs a string buffer initialized to the contents of the
1.116 - * specified string. The initial capacity of the string buffer is
1.117 - * <code>16</code> plus the length of the string argument.
1.118 - *
1.119 - * @param str the initial contents of the buffer.
1.120 - * @exception NullPointerException if <code>str</code> is <code>null</code>
1.121 - */
1.122 - public StringBuffer(String str) {
1.123 - super(str.length() + 16);
1.124 - append(str);
1.125 - }
1.126 -
1.127 - /**
1.128 - * Constructs a string buffer that contains the same characters
1.129 - * as the specified <code>CharSequence</code>. The initial capacity of
1.130 - * the string buffer is <code>16</code> plus the length of the
1.131 - * <code>CharSequence</code> argument.
1.132 - * <p>
1.133 - * If the length of the specified <code>CharSequence</code> is
1.134 - * less than or equal to zero, then an empty buffer of capacity
1.135 - * <code>16</code> is returned.
1.136 - *
1.137 - * @param seq the sequence to copy.
1.138 - * @exception NullPointerException if <code>seq</code> is <code>null</code>
1.139 - * @since 1.5
1.140 - */
1.141 - public StringBuffer(CharSequence seq) {
1.142 - this(seq.length() + 16);
1.143 - append(seq);
1.144 - }
1.145 -
1.146 - public synchronized int length() {
1.147 - return count;
1.148 - }
1.149 -
1.150 - public synchronized int capacity() {
1.151 - return value.length;
1.152 - }
1.153 -
1.154 -
1.155 - public synchronized void ensureCapacity(int minimumCapacity) {
1.156 - if (minimumCapacity > value.length) {
1.157 - expandCapacity(minimumCapacity);
1.158 - }
1.159 - }
1.160 -
1.161 - /**
1.162 - * @since 1.5
1.163 - */
1.164 - public synchronized void trimToSize() {
1.165 - super.trimToSize();
1.166 - }
1.167 -
1.168 - /**
1.169 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.170 - * @see #length()
1.171 - */
1.172 - public synchronized void setLength(int newLength) {
1.173 - super.setLength(newLength);
1.174 - }
1.175 -
1.176 - /**
1.177 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.178 - * @see #length()
1.179 - */
1.180 - public synchronized char charAt(int index) {
1.181 - if ((index < 0) || (index >= count))
1.182 - throw new StringIndexOutOfBoundsException(index);
1.183 - return value[index];
1.184 - }
1.185 -
1.186 - /**
1.187 - * @since 1.5
1.188 - */
1.189 - public synchronized int codePointAt(int index) {
1.190 - return super.codePointAt(index);
1.191 - }
1.192 -
1.193 - /**
1.194 - * @since 1.5
1.195 - */
1.196 - public synchronized int codePointBefore(int index) {
1.197 - return super.codePointBefore(index);
1.198 - }
1.199 -
1.200 - /**
1.201 - * @since 1.5
1.202 - */
1.203 - public synchronized int codePointCount(int beginIndex, int endIndex) {
1.204 - return super.codePointCount(beginIndex, endIndex);
1.205 - }
1.206 -
1.207 - /**
1.208 - * @since 1.5
1.209 - */
1.210 - public synchronized int offsetByCodePoints(int index, int codePointOffset) {
1.211 - return super.offsetByCodePoints(index, codePointOffset);
1.212 - }
1.213 -
1.214 - /**
1.215 - * @throws NullPointerException {@inheritDoc}
1.216 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.217 - */
1.218 - public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
1.219 - int dstBegin)
1.220 - {
1.221 - super.getChars(srcBegin, srcEnd, dst, dstBegin);
1.222 - }
1.223 -
1.224 - /**
1.225 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.226 - * @see #length()
1.227 - */
1.228 - public synchronized void setCharAt(int index, char ch) {
1.229 - if ((index < 0) || (index >= count))
1.230 - throw new StringIndexOutOfBoundsException(index);
1.231 - value[index] = ch;
1.232 - }
1.233 -
1.234 - public synchronized StringBuffer append(Object obj) {
1.235 - super.append(String.valueOf(obj));
1.236 - return this;
1.237 - }
1.238 -
1.239 - public synchronized StringBuffer append(String str) {
1.240 - super.append(str);
1.241 - return this;
1.242 - }
1.243 -
1.244 - /**
1.245 - * Appends the specified <tt>StringBuffer</tt> to this sequence.
1.246 - * <p>
1.247 - * The characters of the <tt>StringBuffer</tt> argument are appended,
1.248 - * in order, to the contents of this <tt>StringBuffer</tt>, increasing the
1.249 - * length of this <tt>StringBuffer</tt> by the length of the argument.
1.250 - * If <tt>sb</tt> is <tt>null</tt>, then the four characters
1.251 - * <tt>"null"</tt> are appended to this <tt>StringBuffer</tt>.
1.252 - * <p>
1.253 - * Let <i>n</i> be the length of the old character sequence, the one
1.254 - * contained in the <tt>StringBuffer</tt> just prior to execution of the
1.255 - * <tt>append</tt> method. Then the character at index <i>k</i> in
1.256 - * the new character sequence is equal to the character at index <i>k</i>
1.257 - * in the old character sequence, if <i>k</i> is less than <i>n</i>;
1.258 - * otherwise, it is equal to the character at index <i>k-n</i> in the
1.259 - * argument <code>sb</code>.
1.260 - * <p>
1.261 - * This method synchronizes on <code>this</code> (the destination)
1.262 - * object but does not synchronize on the source (<code>sb</code>).
1.263 - *
1.264 - * @param sb the <tt>StringBuffer</tt> to append.
1.265 - * @return a reference to this object.
1.266 - * @since 1.4
1.267 - */
1.268 - public synchronized StringBuffer append(StringBuffer sb) {
1.269 - super.append(sb);
1.270 - return this;
1.271 - }
1.272 -
1.273 -
1.274 - /**
1.275 - * Appends the specified <code>CharSequence</code> to this
1.276 - * sequence.
1.277 - * <p>
1.278 - * The characters of the <code>CharSequence</code> argument are appended,
1.279 - * in order, increasing the length of this sequence by the length of the
1.280 - * argument.
1.281 - *
1.282 - * <p>The result of this method is exactly the same as if it were an
1.283 - * invocation of this.append(s, 0, s.length());
1.284 - *
1.285 - * <p>This method synchronizes on this (the destination)
1.286 - * object but does not synchronize on the source (<code>s</code>).
1.287 - *
1.288 - * <p>If <code>s</code> is <code>null</code>, then the four characters
1.289 - * <code>"null"</code> are appended.
1.290 - *
1.291 - * @param s the <code>CharSequence</code> to append.
1.292 - * @return a reference to this object.
1.293 - * @since 1.5
1.294 - */
1.295 - public StringBuffer append(CharSequence s) {
1.296 - // Note, synchronization achieved via other invocations
1.297 - if (s == null)
1.298 - s = "null";
1.299 - if (s instanceof String)
1.300 - return this.append((String)s);
1.301 - if (s instanceof StringBuffer)
1.302 - return this.append((StringBuffer)s);
1.303 - return this.append(s, 0, s.length());
1.304 - }
1.305 -
1.306 - /**
1.307 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.308 - * @since 1.5
1.309 - */
1.310 - public synchronized StringBuffer append(CharSequence s, int start, int end)
1.311 - {
1.312 - super.append(s, start, end);
1.313 - return this;
1.314 - }
1.315 -
1.316 - public synchronized StringBuffer append(char[] str) {
1.317 - super.append(str);
1.318 - return this;
1.319 - }
1.320 -
1.321 - /**
1.322 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.323 - */
1.324 - public synchronized StringBuffer append(char[] str, int offset, int len) {
1.325 - super.append(str, offset, len);
1.326 - return this;
1.327 - }
1.328 -
1.329 - public synchronized StringBuffer append(boolean b) {
1.330 - super.append(b);
1.331 - return this;
1.332 - }
1.333 -
1.334 - public synchronized StringBuffer append(char c) {
1.335 - super.append(c);
1.336 - return this;
1.337 - }
1.338 -
1.339 - public synchronized StringBuffer append(int i) {
1.340 - super.append(i);
1.341 - return this;
1.342 - }
1.343 -
1.344 - /**
1.345 - * @since 1.5
1.346 - */
1.347 - public synchronized StringBuffer appendCodePoint(int codePoint) {
1.348 - super.appendCodePoint(codePoint);
1.349 - return this;
1.350 - }
1.351 -
1.352 - public synchronized StringBuffer append(long lng) {
1.353 - super.append(lng);
1.354 - return this;
1.355 - }
1.356 -
1.357 - public synchronized StringBuffer append(float f) {
1.358 - super.append(f);
1.359 - return this;
1.360 - }
1.361 -
1.362 - public synchronized StringBuffer append(double d) {
1.363 - super.append(d);
1.364 - return this;
1.365 - }
1.366 -
1.367 - /**
1.368 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.369 - * @since 1.2
1.370 - */
1.371 - public synchronized StringBuffer delete(int start, int end) {
1.372 - super.delete(start, end);
1.373 - return this;
1.374 - }
1.375 -
1.376 - /**
1.377 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.378 - * @since 1.2
1.379 - */
1.380 - public synchronized StringBuffer deleteCharAt(int index) {
1.381 - super.deleteCharAt(index);
1.382 - return this;
1.383 - }
1.384 -
1.385 - /**
1.386 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.387 - * @since 1.2
1.388 - */
1.389 - public synchronized StringBuffer replace(int start, int end, String str) {
1.390 - super.replace(start, end, str);
1.391 - return this;
1.392 - }
1.393 -
1.394 - /**
1.395 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.396 - * @since 1.2
1.397 - */
1.398 - public synchronized String substring(int start) {
1.399 - return substring(start, count);
1.400 - }
1.401 -
1.402 - /**
1.403 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.404 - * @since 1.4
1.405 - */
1.406 - public synchronized CharSequence subSequence(int start, int end) {
1.407 - return super.substring(start, end);
1.408 - }
1.409 -
1.410 - /**
1.411 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.412 - * @since 1.2
1.413 - */
1.414 - public synchronized String substring(int start, int end) {
1.415 - return super.substring(start, end);
1.416 - }
1.417 -
1.418 - /**
1.419 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.420 - * @since 1.2
1.421 - */
1.422 - public synchronized StringBuffer insert(int index, char[] str, int offset,
1.423 - int len)
1.424 - {
1.425 - super.insert(index, str, offset, len);
1.426 - return this;
1.427 - }
1.428 -
1.429 - /**
1.430 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.431 - */
1.432 - public synchronized StringBuffer insert(int offset, Object obj) {
1.433 - super.insert(offset, String.valueOf(obj));
1.434 - return this;
1.435 - }
1.436 -
1.437 - /**
1.438 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.439 - */
1.440 - public synchronized StringBuffer insert(int offset, String str) {
1.441 - super.insert(offset, str);
1.442 - return this;
1.443 - }
1.444 -
1.445 - /**
1.446 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.447 - */
1.448 - public synchronized StringBuffer insert(int offset, char[] str) {
1.449 - super.insert(offset, str);
1.450 - return this;
1.451 - }
1.452 -
1.453 - /**
1.454 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.455 - * @since 1.5
1.456 - */
1.457 - public StringBuffer insert(int dstOffset, CharSequence s) {
1.458 - // Note, synchronization achieved via other invocations
1.459 - if (s == null)
1.460 - s = "null";
1.461 - if (s instanceof String)
1.462 - return this.insert(dstOffset, (String)s);
1.463 - return this.insert(dstOffset, s, 0, s.length());
1.464 - }
1.465 -
1.466 - /**
1.467 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.468 - * @since 1.5
1.469 - */
1.470 - public synchronized StringBuffer insert(int dstOffset, CharSequence s,
1.471 - int start, int end)
1.472 - {
1.473 - super.insert(dstOffset, s, start, end);
1.474 - return this;
1.475 - }
1.476 -
1.477 - /**
1.478 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.479 - */
1.480 - public StringBuffer insert(int offset, boolean b) {
1.481 - return insert(offset, String.valueOf(b));
1.482 - }
1.483 -
1.484 - /**
1.485 - * @throws IndexOutOfBoundsException {@inheritDoc}
1.486 - */
1.487 - public synchronized StringBuffer insert(int offset, char c) {
1.488 - super.insert(offset, c);
1.489 - return this;
1.490 - }
1.491 -
1.492 - /**
1.493 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.494 - */
1.495 - public StringBuffer insert(int offset, int i) {
1.496 - return insert(offset, String.valueOf(i));
1.497 - }
1.498 -
1.499 - /**
1.500 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.501 - */
1.502 - public StringBuffer insert(int offset, long l) {
1.503 - return insert(offset, String.valueOf(l));
1.504 - }
1.505 -
1.506 - /**
1.507 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.508 - */
1.509 - public StringBuffer insert(int offset, float f) {
1.510 - return insert(offset, String.valueOf(f));
1.511 - }
1.512 -
1.513 - /**
1.514 - * @throws StringIndexOutOfBoundsException {@inheritDoc}
1.515 - */
1.516 - public StringBuffer insert(int offset, double d) {
1.517 - return insert(offset, String.valueOf(d));
1.518 - }
1.519 -
1.520 - /**
1.521 - * @throws NullPointerException {@inheritDoc}
1.522 - * @since 1.4
1.523 - */
1.524 - public int indexOf(String str) {
1.525 - return indexOf(str, 0);
1.526 - }
1.527 -
1.528 - /**
1.529 - * @throws NullPointerException {@inheritDoc}
1.530 - * @since 1.4
1.531 - */
1.532 - public synchronized int indexOf(String str, int fromIndex) {
1.533 - return super.indexOf(str, fromIndex);
1.534 - }
1.535 -
1.536 - /**
1.537 - * @throws NullPointerException {@inheritDoc}
1.538 - * @since 1.4
1.539 - */
1.540 - public int lastIndexOf(String str) {
1.541 - // Note, synchronization achieved via other invocations
1.542 - return lastIndexOf(str, count);
1.543 - }
1.544 -
1.545 - /**
1.546 - * @throws NullPointerException {@inheritDoc}
1.547 - * @since 1.4
1.548 - */
1.549 - public synchronized int lastIndexOf(String str, int fromIndex) {
1.550 - return String.lastIndexOf(value, 0, count,
1.551 - str.toCharArray(), 0, str.length(), fromIndex);
1.552 - }
1.553 -
1.554 - /**
1.555 - * @since JDK1.0.2
1.556 - */
1.557 - public synchronized StringBuffer reverse() {
1.558 - super.reverse();
1.559 - return this;
1.560 - }
1.561 -
1.562 - public synchronized String toString() {
1.563 - return new String(value, 0, count);
1.564 - }
1.565 -
1.566 -// /**
1.567 -// * Serializable fields for StringBuffer.
1.568 -// *
1.569 -// * @serialField value char[]
1.570 -// * The backing character array of this StringBuffer.
1.571 -// * @serialField count int
1.572 -// * The number of characters in this StringBuffer.
1.573 -// * @serialField shared boolean
1.574 -// * A flag indicating whether the backing array is shared.
1.575 -// * The value is ignored upon deserialization.
1.576 -// */
1.577 -// private static final java.io.ObjectStreamField[] serialPersistentFields =
1.578 -// {
1.579 -// new java.io.ObjectStreamField("value", char[].class),
1.580 -// new java.io.ObjectStreamField("count", Integer.TYPE),
1.581 -// new java.io.ObjectStreamField("shared", Boolean.TYPE),
1.582 -// };
1.583 -//
1.584 -// /**
1.585 -// * readObject is called to restore the state of the StringBuffer from
1.586 -// * a stream.
1.587 -// */
1.588 -// private synchronized void writeObject(java.io.ObjectOutputStream s)
1.589 -// throws java.io.IOException {
1.590 -// java.io.ObjectOutputStream.PutField fields = s.putFields();
1.591 -// fields.put("value", value);
1.592 -// fields.put("count", count);
1.593 -// fields.put("shared", false);
1.594 -// s.writeFields();
1.595 -// }
1.596 -//
1.597 -// /**
1.598 -// * readObject is called to restore the state of the StringBuffer from
1.599 -// * a stream.
1.600 -// */
1.601 -// private void readObject(java.io.ObjectInputStream s)
1.602 -// throws java.io.IOException, ClassNotFoundException {
1.603 -// java.io.ObjectInputStream.GetField fields = s.readFields();
1.604 -// value = (char[])fields.get("value", null);
1.605 -// count = fields.get("count", 0);
1.606 -// }
1.607 -}