1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package tests.support; 19 20import java.io.IOException; 21import java.io.Writer; 22 23public class Support_StringWriter extends Writer { 24 private StringBuffer buf; 25 26 /** 27 * Constructs a new StringWriter which has a StringBuffer allocated with the 28 * default size of 16 characters. The StringBuffer is also the 29 * <code>lock</code> used to synchronize access to this Writer. 30 */ 31 public Support_StringWriter() { 32 super(); 33 buf = new StringBuffer(16); 34 lock = buf; 35 } 36 37 /** 38 * Constructs a new StringWriter which has a StringBuffer allocated with the 39 * size of <code>initialSize</code> characters. The StringBuffer is also 40 * the <code>lock</code> used to synchronize access to this Writer. 41 */ 42 public Support_StringWriter(int initialSize) { 43 if (initialSize >= 0) { 44 buf = new StringBuffer(initialSize); 45 lock = buf; 46 } else { 47 throw new IllegalArgumentException(); 48 } 49 } 50 51 /** 52 * Close this Writer. This is the concrete implementation required. This 53 * particular implementation does nothing. 54 * 55 * @exception java.io.IOException 56 * If an IO error occurs closing this StringWriter. 57 */ 58 @Override 59 public void close() throws IOException { 60 } 61 62 /** 63 * Flush this Writer. This is the concrete implementation required. This 64 * particular implementation does nothing. 65 * 66 */ 67 @Override 68 public void flush() { 69 } 70 71 /** 72 * Answer the contents of this StringWriter as a StringBuffer. Any changes 73 * made to the StringBuffer by the receiver or the caller are reflected in 74 * this StringWriter. 75 * 76 * @return this StringWriters local StringBuffer. 77 */ 78 public StringBuffer getBuffer() { 79 synchronized (lock) { 80 return buf; 81 } 82 } 83 84 /** 85 * Answer the contents of this StringWriter as a String. Any changes made to 86 * the StringBuffer by the receiver after returning will not be reflected in 87 * the String returned to the caller. 88 * 89 * @return this StringWriters current contents as a String. 90 */ 91 @Override 92 public String toString() { 93 synchronized (lock) { 94 return buf.toString(); 95 } 96 } 97 98 /** 99 * Writes <code>count</code> characters starting at <code>offset</code> 100 * in <code>buf</code> to this StringWriter. 101 * 102 * @param buf 103 * the non-null array containing characters to write. 104 * @param offset 105 * offset in buf to retrieve characters 106 * @param count 107 * maximum number of characters to write 108 * 109 * @exception java.lang.ArrayIndexOutOfBoundsException 110 * If offset or count are outside of bounds. 111 */ 112 @Override 113 public void write(char[] buf, int offset, int count) { 114 // avoid int overflow 115 if (0 <= offset && offset <= buf.length && 0 <= count 116 && count <= buf.length - offset) { 117 synchronized (lock) { 118 this.buf.append(buf, offset, count); 119 } 120 } else { 121 throw new ArrayIndexOutOfBoundsException(); 122 } 123 } 124 125 /** 126 * Writes the specified character <code>oneChar</code> to this 127 * StringWriter. This implementation writes the low order two bytes to the 128 * Stream. 129 * 130 * @param oneChar 131 * The character to write 132 * 133 */ 134 @Override 135 public void write(int oneChar) { 136 synchronized (lock) { 137 buf.append((char) oneChar); 138 } 139 } 140 141 /** 142 * Writes the characters from the String <code>str</code> to this 143 * StringWriter. 144 * 145 * @param str 146 * the non-null String containing the characters to write. 147 * 148 */ 149 @Override 150 public void write(String str) { 151 synchronized (lock) { 152 buf.append(str); 153 } 154 } 155 156 /** 157 * Writes <code>count</code> number of characters starting at 158 * <code>offset</code> from the String <code>str</code> to this 159 * StringWriter. 160 * 161 * @param str 162 * the non-null String containing the characters to write. 163 * @param offset 164 * the starting point to retrieve characters. 165 * @param count 166 * the number of characters to retrieve and write. 167 * 168 * @exception java.lang.ArrayIndexOutOfBoundsException 169 * If offset or count are outside of bounds. 170 */ 171 @Override 172 public void write(String str, int offset, int count) { 173 String sub = str.substring(offset, offset + count); 174 synchronized (lock) { 175 buf.append(sub); 176 } 177 } 178} 179