com.baidu.bjf.remoting.protobuf.utils.StringBuilderWriter Maven / Gradle / Ivy
Show all versions of jprotobuf Show documentation
/*
* Copyright (c) Baidu Inc. All rights reserved.
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.baidu.bjf.remoting.protobuf.utils;
import java.io.IOException;
import java.io.Writer;
/**
* A character stream that collects its output in a string buffer, which can then be used to construct a string.
*
* Closing a StringWriter has no effect. The methods in this class can be called after the stream has been
* closed without generating an IOException.
*
* @author xiemalin
* @since 1.12.0
*/
public class StringBuilderWriter extends Writer {
/** The buf. */
private StringBuilder buf;
/**
* Create a new string writer using the default initial string-buffer size.
*/
public StringBuilderWriter() {
buf = new StringBuilder();
lock = buf;
}
/**
* Create a new string writer using the specified initial string-buffer size.
*
* @param initialSize The number of char values that will fit into this buffer before it is automatically
* expanded
*
* @throws IllegalArgumentException If initialSize is negative
*/
public StringBuilderWriter(int initialSize) {
if (initialSize < 0) {
throw new IllegalArgumentException("Negative buffer size");
}
buf = new StringBuilder(initialSize);
lock = buf;
}
/**
* Write a single character.
*
* @param c the c
*/
public void write(int c) {
buf.append((char) c);
}
/**
* Write a portion of an array of characters.
*
* @param cbuf Array of characters
* @param off Offset from which to start writing characters
* @param len Number of characters to write
*/
public void write(char cbuf[], int off, int len) {
if ((off < 0) || (off > cbuf.length) || (len < 0) || ((off + len) > cbuf.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
buf.append(cbuf, off, len);
}
/**
* Write a string.
*
* @param str the str
*/
public void write(String str) {
buf.append(str);
}
/**
* Write a portion of a string.
*
* @param str String to be written
* @param off Offset from which to start writing characters
* @param len Number of characters to write
*/
public void write(String str, int off, int len) {
buf.append(str.substring(off, off + len));
}
/**
* Appends the specified character sequence to this writer.
*
*
* An invocation of this method of the form out.append(csq) behaves in exactly the same way as the
* invocation
*
*
* out.write(csq.toString())
*
*
*
* Depending on the specification of toString for the character sequence csq, the entire sequence
* may not be appended. For instance, invoking the toString method of a character buffer will return a
* subsequence whose content depends upon the buffer's position and limit.
*
* @param csq The character sequence to append. If csq is null, then the four characters
* "null" are appended to this writer.
*
* @return This writer
*
* @since 1.5
*/
public StringBuilderWriter append(CharSequence csq) {
if (csq == null)
write("null");
else
write(csq.toString());
return this;
}
/**
* Appends a subsequence of the specified character sequence to this writer.
*
*
* An invocation of this method of the form out.append(csq, start,
* end) when csq is not null, behaves in exactly the same way as the invocation
*
*
* out.write(csq.subSequence(start, end).toString())
*
*
* @param csq The character sequence from which a subsequence will be appended. If csq is null,
* then characters will be appended as if csq contained the four characters "null".
*
* @param start The index of the first character in the subsequence
*
* @param end The index of the character following the last character in the subsequence
*
* @return This writer
*
* @throws IndexOutOfBoundsException If start or end are negative, start is greater than
* end, or end is greater than csq.length()
*
* @since 1.5
*/
public StringBuilderWriter append(CharSequence csq, int start, int end) {
CharSequence cs = (csq == null ? "null" : csq);
write(cs.subSequence(start, end).toString());
return this;
}
/**
* Appends the specified character to this writer.
*
*
* An invocation of this method of the form out.append(c) behaves in exactly the same way as the invocation
*
*
* out.write(c)
*
*
* @param c The 16-bit character to append
*
* @return This writer
*
* @since 1.5
*/
public StringBuilderWriter append(char c) {
write(c);
return this;
}
/**
* Return the buffer's current value as a string.
*
* @return the string
*/
public String toString() {
return buf.toString();
}
/**
* Gets the buffer.
*
* @return the buffer
*/
public StringBuilder getBuffer() {
return buf;
}
/**
* Flush the stream.
*/
public void flush() {
}
/**
* Closing a StringWriter has no effect. The methods in this class can be called after the stream has been
* closed without generating an IOException.
*
* @throws IOException Signals that an I/O exception has occurred.
*/
public void close() throws IOException {
}
}