libcore/support/src/test/java/tests/support/Support_StringWriter.java

   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
  18 package tests.support;
  19
  20 import java.io.IOException;
  21 import java.io.Writer;
  22
  23 public 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 }