| Methods Summary |
|---|
| public java.io.CharArrayWriter | append(char c)Appends a char {@code c} to the CharArrayWriter. The method works the
same way as {@code write(c)}.
write(c);
return this;
|
| public java.io.CharArrayWriter | append(java.lang.CharSequence csq)Appends a CharSequence {@code csq} to the CharArrayWriter. The method
works the same way as {@code write(csq.toString())}. If {@code csq} is
null, then it will be substituted with the string "null".
if (null == csq) {
append(TOKEN_NULL, 0, TOKEN_NULL.length());
} else {
append(csq, 0, csq.length());
}
return this;
|
| public java.io.CharArrayWriter | append(java.lang.CharSequence csq, int start, int end)Append a subsequence of a CharSequence {@code csq} to the
CharArrayWriter. The first and last characters of the subsequence are
specified by the parameters {@code start} and {@code end}. The
CharArrayWriter.append({@code csq}) works the same way as
{@code CharArrayWriter.write(csq.subSequence(start, end).toString)}. If
{@code csq} is null, then it will be substituted with the string "null".
if (null == csq) {
csq = TOKEN_NULL;
}
String output = csq.subSequence(start, end).toString();
write(output, 0, output.length());
return this;
|
| public void | close()Closes this writer. The implementation in CharArrayWriter does nothing.
/* empty */
|
| private void | expand(int i)
/* Can the buffer handle @i more chars, if not expand it */
if (count + i <= buf.length) {
return;
}
char[] newbuf = new char[buf.length + (2 * i)];
System.arraycopy(buf, 0, newbuf, 0, count);
buf = newbuf;
|
| public void | flush()Flushes this writer. The implementation in CharArrayWriter does nothing.
/* empty */
|
| public void | reset()Resets this writer. The current write position is reset to the beginning
of the buffer. All written characters are lost and the size of this
writer is set to 0.
synchronized (lock) {
count = 0;
}
|
| public int | size()Returns the size of this writer, that is the number of characters it
stores. This number changes if this writer is reset or when more
characters are written to it.
synchronized (lock) {
return count;
}
|
| public char[] | toCharArray()Returns the contents of the receiver as a char array. The array returned
is a copy and any modifications made to this writer after calling this
method are not reflected in the result.
synchronized (lock) {
char[] result = new char[count];
System.arraycopy(buf, 0, result, 0, count);
return result;
}
|
| public java.lang.String | toString()Returns the contents of this CharArrayWriter as a string. The string
returned is a copy and any modifications made to this writer after
calling this method are not reflected in the result.
synchronized (lock) {
return new String(buf, 0, count);
}
|
| public void | write(char[] c, int offset, int len)Writes {@code count} characters starting at {@code offset} in {@code c}
to this writer.
// avoid int overflow
// BEGIN android-changed
// Exception priorities (in case of multiple errors) differ from
// RI, but are spec-compliant.
// made implicit null check explicit,
// removed redundant check,
// added null check, used (offset | len) < 0 instead of
// (offset < 0) || (len < 0) to safe one operation
if (c == null) {
throw new NullPointerException(Msg.getString("K0047")); //$NON-NLS-1$
}
if ((offset | len) < 0 || len > c.length - offset) {
throw new IndexOutOfBoundsException(Msg.getString("K002f")); //$NON-NLS-1$
}
// END android-changed
synchronized (lock) {
expand(len);
System.arraycopy(c, offset, this.buf, this.count, len);
this.count += len;
}
|
| public void | write(int oneChar)Writes the specified character {@code oneChar} to this writer.
This implementation writes the two low order bytes of the integer
{@code oneChar} to the buffer.
synchronized (lock) {
expand(1);
buf[count++] = (char) oneChar;
}
|
| public void | write(java.lang.String str, int offset, int len)Writes {@code count} number of characters starting at {@code offset} from
the string {@code str} to this CharArrayWriter.
if (str == null) {
throw new NullPointerException(Msg.getString("K0047")); //$NON-NLS-1$
}
// avoid int overflow
// BEGIN android-changed
// Exception priorities (in case of multiple errors) differ from
// RI, but are spec-compliant.
// removed redundant check, used (offset | len) < 0
// instead of (offset < 0) || (len < 0) to safe one operation
if ((offset | len) < 0 || len > str.length() - offset) {
throw new StringIndexOutOfBoundsException(Msg.getString("K002f")); //$NON-NLS-1$
}
// END android-changed
synchronized (lock) {
expand(len);
str.getChars(offset, offset + len, buf, this.count);
this.count += len;
}
|
| public void | writeTo(java.io.Writer out)Writes the contents of this CharArrayWriter to another Writer. The output
is all the characters that have been written to the receiver since the
last reset or since it was created.
synchronized (lock) {
out.write(buf, 0, count);
}
|
