/// <summary> /// This will add a <c>String</c> to the end of the buffer. /// The buffer will not overflow with repeated uses of the /// <c>append</c>, it uses an <c>ensureCapacity</c> /// method which will allow the buffer to dynamically grow in /// size to accomodate large <c>String</c> objects. /// </summary> /// <param name="str"> /// the <c>String</c> to be appended to this /// </param> /// <param name="off"> /// the read offset for the <c>String</c> /// </param> /// <param name="len"> /// the number of characters to append to this /// </param> public void Append(String str, int off, int len) { EnsureCapacity(count+ len); str.getChars(off,len,buf,count); count += len; }
/// <summary> /// This will add a <c>String</c> to the end of the buffer. /// The buffer will not overflow with repeated uses of the /// <c>append</c>, it uses an <c>ensureCapacity</c> /// method which will allow the buffer to dynamically grow in /// size to accomodate large <c>String</c> objects. /// </summary> /// <param name="str"> /// the <c>String</c> to be appended to this /// </param> public void Append(String str) { EnsureCapacity(count+ str.Length()); str.getChars(0,str.Length(),buf,count); count += str.Length(); }
protected internal void replace0(int start, int end, String s) { if (start >= 0) { if (end > count) { end = count; } if (end > start) { int stringLength = s.length(); int diff = end - start - stringLength; if (diff > 0) { // replacing with fewer characters if (!shared) { // index == count case is no-op java.lang.SystemJ.arraycopy(value, end, value, start + stringLength, count - end); } else { char[] newData = new char[value.Length]; java.lang.SystemJ.arraycopy(value, 0, newData, 0, start); // index == count case is no-op java.lang.SystemJ.arraycopy(value, end, newData, start + stringLength, count - end); value = newData; shared = false; } } else if (diff < 0) { // replacing with more characters...need some room move(-diff, end); } else if (shared) { char[] clone = new char[value.Length]; SystemJ.arraycopy(value, 0, clone, 0, value.Length); value = clone; shared = false; } s.getChars(0, stringLength, value, start); count -= diff; return; } if (start == end) { if (s == null) { throw new NullPointerException(); } insert0(start, s); return; } } throw new StringIndexOutOfBoundsException(); }
protected internal void insert0(int index, String s) { if (0 <= index && index <= count) { if (s == null) { s = "null"; //$NON-NLS-1$ } int min = s.length(); if (min != 0) { move(min, index); s.getChars(0, min, value, index); count += min; } } else { throw new StringIndexOutOfBoundsException(index); } }
protected internal void append0(String s) { if (s == null) { appendNull(); return; } int adding = s.length(); int newSize = count + adding; if (newSize > value.Length) { enlargeBuffer(newSize); } s.getChars(0, adding, value, count); count = newSize; }
/** * Writes {@code count} characters starting at {@code offset} in {@code str} * to this writer. If {@code count} is greater than this writer's buffer, * then this writer is flushed and the remaining characters are written * directly to the target writer. If count is negative no characters are * written to the buffer. This differs from the behavior of the superclass. * * @param str * the non-null String containing characters to write. * @param offset * the start position in {@code str} for retrieving characters. * @param count * maximum number of characters to write. * @throws IOException * if this writer has already been closed or another I/O error * occurs. * @throws IndexOutOfBoundsException * if {@code offset < 0} or {@code offset + count} is greater * than the length of {@code str}. */ public override void write(String str, int offset, int count) { //throws IOException { lock (lockJ) { if (isClosed()) { throw new IOException("Writer is closed."); //$NON-NLS-1$ } if (count <= 0) { return; } if (offset > str.length() - count || offset < 0) { throw new java.lang.StringIndexOutOfBoundsException(); } if (pos == 0 && count >= buf.Length) { char[] chars = new char[count]; str.getChars(offset, offset + count, chars, 0); outj.write(chars, 0, count); return; } int available = buf.Length - pos; if (count < available) { available = count; } if (available > 0) { str.getChars(offset, offset + available, buf, pos); pos += available; } if (pos == buf.Length) { outj.write(this.buf, 0, this.buf.Length); pos = 0; if (count > available) { offset += available; available = count - available; if (available >= buf.Length) { char[] chars = new char[count]; str.getChars(offset, offset + available, chars, 0); outj.write(chars, 0, available); return; } str.getChars(offset, offset + available, buf, pos); pos += available; } } } }
/** * Writes {@code count} characters from {@code str} starting at {@code * offset} to the target. * * @param str * the non-null string containing the characters to write. * @param offset * the index of the first character in {@code str} to write. * @param count * the number of characters from {@code str} to write. * @throws IOException * if this writer is closed or another I/O error occurs. * @throws IndexOutOfBoundsException * if {@code offset < 0} or {@code count < 0}, or if {@code * offset + count} is greater than the length of {@code str}. */ public virtual void write(String str, int offset, int count) { //throws IOException { if (count < 0) { // other cases tested by getChars() throw new java.lang.StringIndexOutOfBoundsException(); } char[] buf = new char[count]; str.getChars(offset, offset + count, buf, 0); lock (lockJ) { write(buf, 0, buf.Length); } }