001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.lang3.text;
018
019import java.io.IOException;
020import java.io.Reader;
021import java.io.Serializable;
022import java.io.Writer;
023import java.nio.CharBuffer;
024import java.util.Iterator;
025import java.util.List;
026import java.util.Objects;
027
028import org.apache.commons.lang3.ArrayUtils;
029import org.apache.commons.lang3.CharUtils;
030import org.apache.commons.lang3.StringUtils;
031import org.apache.commons.lang3.builder.Builder;
032
033/**
034 * Builds a string from constituent parts providing a more flexible and powerful API
035 * than StringBuffer.
036 * <p>
037 * The main differences from StringBuffer/StringBuilder are:
038 * </p>
039 * <ul>
040 * <li>Not synchronized</li>
041 * <li>Not final</li>
042 * <li>Subclasses have direct access to character array</li>
043 * <li>Additional methods
044 *  <ul>
045 *   <li>appendWithSeparators - adds an array of values, with a separator</li>
046 *   <li>appendPadding - adds a length padding characters</li>
047 *   <li>appendFixedLength - adds a fixed width field to the builder</li>
048 *   <li>toCharArray/getChars - simpler ways to get a range of the character array</li>
049 *   <li>delete - delete char or string</li>
050 *   <li>replace - search and replace for a char or string</li>
051 *   <li>leftString/rightString/midString - substring without exceptions</li>
052 *   <li>contains - whether the builder contains a char or string</li>
053 *   <li>size/clear/isEmpty - collections style API methods</li>
054 *  </ul>
055 * </li>
056 * <li>Views
057 *  <ul>
058 *   <li>asTokenizer - uses the internal buffer as the source of a StrTokenizer</li>
059 *   <li>asReader - uses the internal buffer as the source of a Reader</li>
060 *   <li>asWriter - allows a Writer to write directly to the internal buffer</li>
061 *  </ul>
062 * </li>
063 * </ul>
064 * <p>
065 * The aim has been to provide an API that mimics very closely what StringBuffer
066 * provides, but with additional methods. It should be noted that some edge cases,
067 * with invalid indices or null input, have been altered - see individual methods.
068 * The biggest of these changes is that by default, null will not output the text
069 * 'null'. This can be controlled by a property, {@link #setNullText(String)}.
070 * <p>
071 * Prior to 3.0, this class implemented Cloneable but did not implement the
072 * clone method so could not be used. From 3.0 onwards it no longer implements
073 * the interface.
074 *
075 * @since 2.2
076 * @deprecated as of 3.6, use commons-text
077 * <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/StrBuilder.html">
078 * StrBuilder</a> instead
079 */
080@Deprecated
081public class StrBuilder implements CharSequence, Appendable, Serializable, Builder<String> {
082
083    /**
084     * The extra capacity for new builders.
085     */
086    static final int CAPACITY = 32;
087
088    /**
089     * Required for serialization support.
090     *
091     * @see java.io.Serializable
092     */
093    private static final long serialVersionUID = 7628716375283629643L;
094
095    /** Internal data storage. */
096    protected char[] buffer; // TODO make private?
097    /** Current size of the buffer. */
098    protected int size; // TODO make private?
099    /** The new line. */
100    private String newLine;
101    /** The null text. */
102    private String nullText;
103
104    //-----------------------------------------------------------------------
105    /**
106     * Constructor that creates an empty builder initial capacity 32 characters.
107     */
108    public StrBuilder() {
109        this(CAPACITY);
110    }
111
112    /**
113     * Constructor that creates an empty builder the specified initial capacity.
114     *
115     * @param initialCapacity  the initial capacity, zero or less will be converted to 32
116     */
117    public StrBuilder(int initialCapacity) {
118        super();
119        if (initialCapacity <= 0) {
120            initialCapacity = CAPACITY;
121        }
122        buffer = new char[initialCapacity];
123    }
124
125    /**
126     * Constructor that creates a builder from the string, allocating
127     * 32 extra characters for growth.
128     *
129     * @param str  the string to copy, null treated as blank string
130     */
131    public StrBuilder(final String str) {
132        super();
133        if (str == null) {
134            buffer = new char[CAPACITY];
135        } else {
136            buffer = new char[str.length() + CAPACITY];
137            append(str);
138        }
139    }
140
141    //-----------------------------------------------------------------------
142    /**
143     * Gets the text to be appended when a new line is added.
144     *
145     * @return the new line text, null means use system default
146     */
147    public String getNewLineText() {
148        return newLine;
149    }
150
151    /**
152     * Sets the text to be appended when a new line is added.
153     *
154     * @param newLine  the new line text, null means use system default
155     * @return this, to enable chaining
156     */
157    public StrBuilder setNewLineText(final String newLine) {
158        this.newLine = newLine;
159        return this;
160    }
161
162    //-----------------------------------------------------------------------
163    /**
164     * Gets the text to be appended when null is added.
165     *
166     * @return the null text, null means no append
167     */
168    public String getNullText() {
169        return nullText;
170    }
171
172    /**
173     * Sets the text to be appended when null is added.
174     *
175     * @param nullText  the null text, null means no append
176     * @return this, to enable chaining
177     */
178    public StrBuilder setNullText(String nullText) {
179        if (nullText != null && nullText.isEmpty()) {
180            nullText = null;
181        }
182        this.nullText = nullText;
183        return this;
184    }
185
186    //-----------------------------------------------------------------------
187    /**
188     * Gets the length of the string builder.
189     *
190     * @return the length
191     */
192    @Override
193    public int length() {
194        return size;
195    }
196
197    /**
198     * Updates the length of the builder by either dropping the last characters
199     * or adding filler of Unicode zero.
200     *
201     * @param length  the length to set to, must be zero or positive
202     * @return this, to enable chaining
203     * @throws IndexOutOfBoundsException if the length is negative
204     */
205    public StrBuilder setLength(final int length) {
206        if (length < 0) {
207            throw new StringIndexOutOfBoundsException(length);
208        }
209        if (length < size) {
210            size = length;
211        } else if (length > size) {
212            ensureCapacity(length);
213            final int oldEnd = size;
214            final int newEnd = length;
215            size = length;
216            for (int i = oldEnd; i < newEnd; i++) {
217                buffer[i] = CharUtils.NUL;
218            }
219        }
220        return this;
221    }
222
223    //-----------------------------------------------------------------------
224    /**
225     * Gets the current size of the internal character array buffer.
226     *
227     * @return the capacity
228     */
229    public int capacity() {
230        return buffer.length;
231    }
232
233    /**
234     * Checks the capacity and ensures that it is at least the size specified.
235     *
236     * @param capacity  the capacity to ensure
237     * @return this, to enable chaining
238     */
239    public StrBuilder ensureCapacity(final int capacity) {
240        if (capacity > buffer.length) {
241            final char[] old = buffer;
242            buffer = new char[capacity * 2];
243            System.arraycopy(old, 0, buffer, 0, size);
244        }
245        return this;
246    }
247
248    /**
249     * Minimizes the capacity to the actual length of the string.
250     *
251     * @return this, to enable chaining
252     */
253    public StrBuilder minimizeCapacity() {
254        if (buffer.length > length()) {
255            final char[] old = buffer;
256            buffer = new char[length()];
257            System.arraycopy(old, 0, buffer, 0, size);
258        }
259        return this;
260    }
261
262    //-----------------------------------------------------------------------
263    /**
264     * Gets the length of the string builder.
265     * <p>
266     * This method is the same as {@link #length()} and is provided to match the
267     * API of Collections.
268     *
269     * @return the length
270     */
271    public int size() {
272        return size;
273    }
274
275    /**
276     * Checks is the string builder is empty (convenience Collections API style method).
277     * <p>
278     * This method is the same as checking {@link #length()} and is provided to match the
279     * API of Collections.
280     *
281     * @return <code>true</code> if the size is <code>0</code>.
282     */
283    public boolean isEmpty() {
284        return size == 0;
285    }
286
287    /**
288     * Clears the string builder (convenience Collections API style method).
289     * <p>
290     * This method does not reduce the size of the internal character buffer.
291     * To do that, call <code>clear()</code> followed by {@link #minimizeCapacity()}.
292     * <p>
293     * This method is the same as {@link #setLength(int)} called with zero
294     * and is provided to match the API of Collections.
295     *
296     * @return this, to enable chaining
297     */
298    public StrBuilder clear() {
299        size = 0;
300        return this;
301    }
302
303    //-----------------------------------------------------------------------
304    /**
305     * Gets the character at the specified index.
306     *
307     * @see #setCharAt(int, char)
308     * @see #deleteCharAt(int)
309     * @param index  the index to retrieve, must be valid
310     * @return the character at the index
311     * @throws IndexOutOfBoundsException if the index is invalid
312     */
313    @Override
314    public char charAt(final int index) {
315        if (index < 0 || index >= length()) {
316            throw new StringIndexOutOfBoundsException(index);
317        }
318        return buffer[index];
319    }
320
321    /**
322     * Sets the character at the specified index.
323     *
324     * @see #charAt(int)
325     * @see #deleteCharAt(int)
326     * @param index  the index to set
327     * @param ch  the new character
328     * @return this, to enable chaining
329     * @throws IndexOutOfBoundsException if the index is invalid
330     */
331    public StrBuilder setCharAt(final int index, final char ch) {
332        if (index < 0 || index >= length()) {
333            throw new StringIndexOutOfBoundsException(index);
334        }
335        buffer[index] = ch;
336        return this;
337    }
338
339    /**
340     * Deletes the character at the specified index.
341     *
342     * @see #charAt(int)
343     * @see #setCharAt(int, char)
344     * @param index  the index to delete
345     * @return this, to enable chaining
346     * @throws IndexOutOfBoundsException if the index is invalid
347     */
348    public StrBuilder deleteCharAt(final int index) {
349        if (index < 0 || index >= size) {
350            throw new StringIndexOutOfBoundsException(index);
351        }
352        deleteImpl(index, index + 1, 1);
353        return this;
354    }
355
356    //-----------------------------------------------------------------------
357    /**
358     * Copies the builder's character array into a new character array.
359     *
360     * @return a new array that represents the contents of the builder
361     */
362    public char[] toCharArray() {
363        if (size == 0) {
364            return ArrayUtils.EMPTY_CHAR_ARRAY;
365        }
366        final char chars[] = new char[size];
367        System.arraycopy(buffer, 0, chars, 0, size);
368        return chars;
369    }
370
371    /**
372     * Copies part of the builder's character array into a new character array.
373     *
374     * @param startIndex  the start index, inclusive, must be valid
375     * @param endIndex  the end index, exclusive, must be valid except that
376     *  if too large it is treated as end of string
377     * @return a new array that holds part of the contents of the builder
378     * @throws IndexOutOfBoundsException if startIndex is invalid,
379     *  or if endIndex is invalid (but endIndex greater than size is valid)
380     */
381    public char[] toCharArray(final int startIndex, int endIndex) {
382        endIndex = validateRange(startIndex, endIndex);
383        final int len = endIndex - startIndex;
384        if (len == 0) {
385            return ArrayUtils.EMPTY_CHAR_ARRAY;
386        }
387        final char chars[] = new char[len];
388        System.arraycopy(buffer, startIndex, chars, 0, len);
389        return chars;
390    }
391
392    /**
393     * Copies the character array into the specified array.
394     *
395     * @param destination  the destination array, null will cause an array to be created
396     * @return the input array, unless that was null or too small
397     */
398    public char[] getChars(char[] destination) {
399        final int len = length();
400        if (destination == null || destination.length < len) {
401            destination = new char[len];
402        }
403        System.arraycopy(buffer, 0, destination, 0, len);
404        return destination;
405    }
406
407    /**
408     * Copies the character array into the specified array.
409     *
410     * @param startIndex  first index to copy, inclusive, must be valid
411     * @param endIndex  last index, exclusive, must be valid
412     * @param destination  the destination array, must not be null or too small
413     * @param destinationIndex  the index to start copying in destination
414     * @throws NullPointerException if the array is null
415     * @throws IndexOutOfBoundsException if any index is invalid
416     */
417    public void getChars(final int startIndex, final int endIndex, final char destination[], final int destinationIndex) {
418        if (startIndex < 0) {
419            throw new StringIndexOutOfBoundsException(startIndex);
420        }
421        if (endIndex < 0 || endIndex > length()) {
422            throw new StringIndexOutOfBoundsException(endIndex);
423        }
424        if (startIndex > endIndex) {
425            throw new StringIndexOutOfBoundsException("end < start");
426        }
427        System.arraycopy(buffer, startIndex, destination, destinationIndex, endIndex - startIndex);
428    }
429
430    //-----------------------------------------------------------------------
431    /**
432     * If possible, reads chars from the provided {@link Readable} directly into underlying
433     * character buffer without making extra copies.
434     *
435     * @param readable  object to read from
436     * @return the number of characters read
437     * @throws IOException if an I/O error occurs
438     *
439     * @since 3.4
440     * @see #appendTo(Appendable)
441     */
442    public int readFrom(final Readable readable) throws IOException {
443        final int oldSize = size;
444        if (readable instanceof Reader) {
445            final Reader r = (Reader) readable;
446            ensureCapacity(size + 1);
447            int read;
448            while ((read = r.read(buffer, size, buffer.length - size)) != -1) {
449                size += read;
450                ensureCapacity(size + 1);
451            }
452        } else if (readable instanceof CharBuffer) {
453            final CharBuffer cb = (CharBuffer) readable;
454            final int remaining = cb.remaining();
455            ensureCapacity(size + remaining);
456            cb.get(buffer, size, remaining);
457            size += remaining;
458        } else {
459            while (true) {
460                ensureCapacity(size + 1);
461                final CharBuffer buf = CharBuffer.wrap(buffer, size, buffer.length - size);
462                final int read = readable.read(buf);
463                if (read == -1) {
464                    break;
465                }
466                size += read;
467            }
468        }
469        return size - oldSize;
470    }
471
472    //-----------------------------------------------------------------------
473    /**
474     * Appends the new line string to this string builder.
475     * <p>
476     * The new line string can be altered using {@link #setNewLineText(String)}.
477     * This might be used to force the output to always use Unix line endings
478     * even when on Windows.
479     *
480     * @return this, to enable chaining
481     */
482    public StrBuilder appendNewLine() {
483        if (newLine == null)  {
484            append(System.lineSeparator());
485            return this;
486        }
487        return append(newLine);
488    }
489
490    /**
491     * Appends the text representing <code>null</code> to this string builder.
492     *
493     * @return this, to enable chaining
494     */
495    public StrBuilder appendNull() {
496        if (nullText == null)  {
497            return this;
498        }
499        return append(nullText);
500    }
501
502    /**
503     * Appends an object to this string builder.
504     * Appending null will call {@link #appendNull()}.
505     *
506     * @param obj  the object to append
507     * @return this, to enable chaining
508     */
509    public StrBuilder append(final Object obj) {
510        if (obj == null) {
511            return appendNull();
512        }
513        if (obj instanceof CharSequence) {
514            return append((CharSequence) obj);
515        }
516        return append(obj.toString());
517    }
518
519    /**
520     * Appends a CharSequence to this string builder.
521     * Appending null will call {@link #appendNull()}.
522     *
523     * @param seq  the CharSequence to append
524     * @return this, to enable chaining
525     * @since 3.0
526     */
527    @Override
528    public StrBuilder append(final CharSequence seq) {
529        if (seq == null) {
530            return appendNull();
531        }
532        if (seq instanceof StrBuilder) {
533            return append((StrBuilder) seq);
534        }
535        if (seq instanceof StringBuilder) {
536            return append((StringBuilder) seq);
537        }
538        if (seq instanceof StringBuffer) {
539            return append((StringBuffer) seq);
540        }
541        if (seq instanceof CharBuffer) {
542            return append((CharBuffer) seq);
543        }
544        return append(seq.toString());
545    }
546
547    /**
548     * Appends part of a CharSequence to this string builder.
549     * Appending null will call {@link #appendNull()}.
550     *
551     * @param seq  the CharSequence to append
552     * @param startIndex  the start index, inclusive, must be valid
553     * @param length  the length to append, must be valid
554     * @return this, to enable chaining
555     * @since 3.0
556     */
557    @Override
558    public StrBuilder append(final CharSequence seq, final int startIndex, final int length) {
559        if (seq == null) {
560            return appendNull();
561        }
562        return append(seq.toString(), startIndex, length);
563    }
564
565    /**
566     * Appends a string to this string builder.
567     * Appending null will call {@link #appendNull()}.
568     *
569     * @param str  the string to append
570     * @return this, to enable chaining
571     */
572    public StrBuilder append(final String str) {
573        if (str == null) {
574            return appendNull();
575        }
576        final int strLen = str.length();
577        if (strLen > 0) {
578            final int len = length();
579            ensureCapacity(len + strLen);
580            str.getChars(0, strLen, buffer, len);
581            size += strLen;
582        }
583        return this;
584    }
585
586
587    /**
588     * Appends part of a string to this string builder.
589     * Appending null will call {@link #appendNull()}.
590     *
591     * @param str  the string to append
592     * @param startIndex  the start index, inclusive, must be valid
593     * @param length  the length to append, must be valid
594     * @return this, to enable chaining
595     */
596    public StrBuilder append(final String str, final int startIndex, final int length) {
597        if (str == null) {
598            return appendNull();
599        }
600        if (startIndex < 0 || startIndex > str.length()) {
601            throw new StringIndexOutOfBoundsException("startIndex must be valid");
602        }
603        if (length < 0 || (startIndex + length) > str.length()) {
604            throw new StringIndexOutOfBoundsException("length must be valid");
605        }
606        if (length > 0) {
607            final int len = length();
608            ensureCapacity(len + length);
609            str.getChars(startIndex, startIndex + length, buffer, len);
610            size += length;
611        }
612        return this;
613    }
614
615    /**
616     * Calls {@link String#format(String, Object...)} and appends the result.
617     *
618     * @param format the format string
619     * @param objs the objects to use in the format string
620     * @return {@code this} to enable chaining
621     * @see String#format(String, Object...)
622     * @since 3.2
623     */
624    public StrBuilder append(final String format, final Object... objs) {
625        return append(String.format(format, objs));
626    }
627
628    /**
629     * Appends the contents of a char buffer to this string builder.
630     * Appending null will call {@link #appendNull()}.
631     *
632     * @param buf  the char buffer to append
633     * @return this, to enable chaining
634     * @since 3.4
635     */
636    public StrBuilder append(final CharBuffer buf) {
637        if (buf == null) {
638            return appendNull();
639        }
640        if (buf.hasArray()) {
641            final int length = buf.remaining();
642            final int len = length();
643            ensureCapacity(len + length);
644            System.arraycopy(buf.array(), buf.arrayOffset() + buf.position(), buffer, len, length);
645            size += length;
646        } else {
647            append(buf.toString());
648        }
649        return this;
650    }
651
652    /**
653     * Appends the contents of a char buffer to this string builder.
654     * Appending null will call {@link #appendNull()}.
655     *
656     * @param buf  the char buffer to append
657     * @param startIndex  the start index, inclusive, must be valid
658     * @param length  the length to append, must be valid
659     * @return this, to enable chaining
660     * @since 3.4
661     */
662    public StrBuilder append(final CharBuffer buf, final int startIndex, final int length) {
663        if (buf == null) {
664            return appendNull();
665        }
666        if (buf.hasArray()) {
667            final int totalLength = buf.remaining();
668            if (startIndex < 0 || startIndex > totalLength) {
669                throw new StringIndexOutOfBoundsException("startIndex must be valid");
670            }
671            if (length < 0 || (startIndex + length) > totalLength) {
672                throw new StringIndexOutOfBoundsException("length must be valid");
673            }
674            final int len = length();
675            ensureCapacity(len + length);
676            System.arraycopy(buf.array(), buf.arrayOffset() + buf.position() + startIndex, buffer, len, length);
677            size += length;
678        } else {
679            append(buf.toString(), startIndex, length);
680        }
681        return this;
682    }
683
684    /**
685     * Appends a string buffer to this string builder.
686     * Appending null will call {@link #appendNull()}.
687     *
688     * @param str  the string buffer to append
689     * @return this, to enable chaining
690     */
691    public StrBuilder append(final StringBuffer str) {
692        if (str == null) {
693            return appendNull();
694        }
695        final int strLen = str.length();
696        if (strLen > 0) {
697            final int len = length();
698            ensureCapacity(len + strLen);
699            str.getChars(0, strLen, buffer, len);
700            size += strLen;
701        }
702        return this;
703    }
704
705    /**
706     * Appends part of a string buffer to this string builder.
707     * Appending null will call {@link #appendNull()}.
708     *
709     * @param str  the string to append
710     * @param startIndex  the start index, inclusive, must be valid
711     * @param length  the length to append, must be valid
712     * @return this, to enable chaining
713     */
714    public StrBuilder append(final StringBuffer str, final int startIndex, final int length) {
715        if (str == null) {
716            return appendNull();
717        }
718        if (startIndex < 0 || startIndex > str.length()) {
719            throw new StringIndexOutOfBoundsException("startIndex must be valid");
720        }
721        if (length < 0 || (startIndex + length) > str.length()) {
722            throw new StringIndexOutOfBoundsException("length must be valid");
723        }
724        if (length > 0) {
725            final int len = length();
726            ensureCapacity(len + length);
727            str.getChars(startIndex, startIndex + length, buffer, len);
728            size += length;
729        }
730        return this;
731    }
732
733    /**
734     * Appends a StringBuilder to this string builder.
735     * Appending null will call {@link #appendNull()}.
736     *
737     * @param str the StringBuilder to append
738     * @return this, to enable chaining
739     * @since 3.2
740     */
741    public StrBuilder append(final StringBuilder str) {
742        if (str == null) {
743            return appendNull();
744        }
745        final int strLen = str.length();
746        if (strLen > 0) {
747            final int len = length();
748            ensureCapacity(len + strLen);
749            str.getChars(0, strLen, buffer, len);
750            size += strLen;
751        }
752        return this;
753    }
754
755    /**
756     * Appends part of a StringBuilder to this string builder.
757     * Appending null will call {@link #appendNull()}.
758     *
759     * @param str the StringBuilder to append
760     * @param startIndex the start index, inclusive, must be valid
761     * @param length the length to append, must be valid
762     * @return this, to enable chaining
763     * @since 3.2
764     */
765    public StrBuilder append(final StringBuilder str, final int startIndex, final int length) {
766        if (str == null) {
767            return appendNull();
768        }
769        if (startIndex < 0 || startIndex > str.length()) {
770            throw new StringIndexOutOfBoundsException("startIndex must be valid");
771        }
772        if (length < 0 || (startIndex + length) > str.length()) {
773            throw new StringIndexOutOfBoundsException("length must be valid");
774        }
775        if (length > 0) {
776            final int len = length();
777            ensureCapacity(len + length);
778            str.getChars(startIndex, startIndex + length, buffer, len);
779            size += length;
780        }
781        return this;
782    }
783
784    /**
785     * Appends another string builder to this string builder.
786     * Appending null will call {@link #appendNull()}.
787     *
788     * @param str  the string builder to append
789     * @return this, to enable chaining
790     */
791    public StrBuilder append(final StrBuilder str) {
792        if (str == null) {
793            return appendNull();
794        }
795        final int strLen = str.length();
796        if (strLen > 0) {
797            final int len = length();
798            ensureCapacity(len + strLen);
799            System.arraycopy(str.buffer, 0, buffer, len, strLen);
800            size += strLen;
801        }
802        return this;
803    }
804
805    /**
806     * Appends part of a string builder to this string builder.
807     * Appending null will call {@link #appendNull()}.
808     *
809     * @param str  the string to append
810     * @param startIndex  the start index, inclusive, must be valid
811     * @param length  the length to append, must be valid
812     * @return this, to enable chaining
813     */
814    public StrBuilder append(final StrBuilder str, final int startIndex, final int length) {
815        if (str == null) {
816            return appendNull();
817        }
818        if (startIndex < 0 || startIndex > str.length()) {
819            throw new StringIndexOutOfBoundsException("startIndex must be valid");
820        }
821        if (length < 0 || (startIndex + length) > str.length()) {
822            throw new StringIndexOutOfBoundsException("length must be valid");
823        }
824        if (length > 0) {
825            final int len = length();
826            ensureCapacity(len + length);
827            str.getChars(startIndex, startIndex + length, buffer, len);
828            size += length;
829        }
830        return this;
831    }
832
833    /**
834     * Appends a char array to the string builder.
835     * Appending null will call {@link #appendNull()}.
836     *
837     * @param chars  the char array to append
838     * @return this, to enable chaining
839     */
840    public StrBuilder append(final char[] chars) {
841        if (chars == null) {
842            return appendNull();
843        }
844        final int strLen = chars.length;
845        if (strLen > 0) {
846            final int len = length();
847            ensureCapacity(len + strLen);
848            System.arraycopy(chars, 0, buffer, len, strLen);
849            size += strLen;
850        }
851        return this;
852    }
853
854    /**
855     * Appends a char array to the string builder.
856     * Appending null will call {@link #appendNull()}.
857     *
858     * @param chars  the char array to append
859     * @param startIndex  the start index, inclusive, must be valid
860     * @param length  the length to append, must be valid
861     * @return this, to enable chaining
862     */
863    public StrBuilder append(final char[] chars, final int startIndex, final int length) {
864        if (chars == null) {
865            return appendNull();
866        }
867        if (startIndex < 0 || startIndex > chars.length) {
868            throw new StringIndexOutOfBoundsException("Invalid startIndex: " + length);
869        }
870        if (length < 0 || (startIndex + length) > chars.length) {
871            throw new StringIndexOutOfBoundsException("Invalid length: " + length);
872        }
873        if (length > 0) {
874            final int len = length();
875            ensureCapacity(len + length);
876            System.arraycopy(chars, startIndex, buffer, len, length);
877            size += length;
878        }
879        return this;
880    }
881
882    /**
883     * Appends a boolean value to the string builder.
884     *
885     * @param value  the value to append
886     * @return this, to enable chaining
887     */
888    public StrBuilder append(final boolean value) {
889        if (value) {
890            ensureCapacity(size + 4);
891            buffer[size++] = 't';
892            buffer[size++] = 'r';
893            buffer[size++] = 'u';
894            buffer[size++] = 'e';
895        } else {
896            ensureCapacity(size + 5);
897            buffer[size++] = 'f';
898            buffer[size++] = 'a';
899            buffer[size++] = 'l';
900            buffer[size++] = 's';
901            buffer[size++] = 'e';
902        }
903        return this;
904    }
905
906    /**
907     * Appends a char value to the string builder.
908     *
909     * @param ch  the value to append
910     * @return this, to enable chaining
911     * @since 3.0
912     */
913    @Override
914    public StrBuilder append(final char ch) {
915        final int len = length();
916        ensureCapacity(len + 1);
917        buffer[size++] = ch;
918        return this;
919    }
920
921    /**
922     * Appends an int value to the string builder using <code>String.valueOf</code>.
923     *
924     * @param value  the value to append
925     * @return this, to enable chaining
926     */
927    public StrBuilder append(final int value) {
928        return append(String.valueOf(value));
929    }
930
931    /**
932     * Appends a long value to the string builder using <code>String.valueOf</code>.
933     *
934     * @param value  the value to append
935     * @return this, to enable chaining
936     */
937    public StrBuilder append(final long value) {
938        return append(String.valueOf(value));
939    }
940
941    /**
942     * Appends a float value to the string builder using <code>String.valueOf</code>.
943     *
944     * @param value  the value to append
945     * @return this, to enable chaining
946     */
947    public StrBuilder append(final float value) {
948        return append(String.valueOf(value));
949    }
950
951    /**
952     * Appends a double value to the string builder using <code>String.valueOf</code>.
953     *
954     * @param value  the value to append
955     * @return this, to enable chaining
956     */
957    public StrBuilder append(final double value) {
958        return append(String.valueOf(value));
959    }
960
961    //-----------------------------------------------------------------------
962    /**
963     * Appends an object followed by a new line to this string builder.
964     * Appending null will call {@link #appendNull()}.
965     *
966     * @param obj  the object to append
967     * @return this, to enable chaining
968     * @since 2.3
969     */
970    public StrBuilder appendln(final Object obj) {
971        return append(obj).appendNewLine();
972    }
973
974    /**
975     * Appends a string followed by a new line to this string builder.
976     * Appending null will call {@link #appendNull()}.
977     *
978     * @param str  the string to append
979     * @return this, to enable chaining
980     * @since 2.3
981     */
982    public StrBuilder appendln(final String str) {
983        return append(str).appendNewLine();
984    }
985
986    /**
987     * Appends part of a string followed by a new line to this string builder.
988     * Appending null will call {@link #appendNull()}.
989     *
990     * @param str  the string to append
991     * @param startIndex  the start index, inclusive, must be valid
992     * @param length  the length to append, must be valid
993     * @return this, to enable chaining
994     * @since 2.3
995     */
996    public StrBuilder appendln(final String str, final int startIndex, final int length) {
997        return append(str, startIndex, length).appendNewLine();
998    }
999
1000    /**
1001     * Calls {@link String#format(String, Object...)} and appends the result.
1002     *
1003     * @param format the format string
1004     * @param objs the objects to use in the format string
1005     * @return {@code this} to enable chaining
1006     * @see String#format(String, Object...)
1007     * @since 3.2
1008     */
1009    public StrBuilder appendln(final String format, final Object... objs) {
1010        return append(format, objs).appendNewLine();
1011    }
1012
1013    /**
1014     * Appends a string buffer followed by a new line to this string builder.
1015     * Appending null will call {@link #appendNull()}.
1016     *
1017     * @param str  the string buffer to append
1018     * @return this, to enable chaining
1019     * @since 2.3
1020     */
1021    public StrBuilder appendln(final StringBuffer str) {
1022        return append(str).appendNewLine();
1023    }
1024
1025    /**
1026     * Appends a string builder followed by a new line to this string builder.
1027     * Appending null will call {@link #appendNull()}.
1028     *
1029     * @param str  the string builder to append
1030     * @return this, to enable chaining
1031     * @since 3.2
1032     */
1033    public StrBuilder appendln(final StringBuilder str) {
1034        return append(str).appendNewLine();
1035    }
1036
1037    /**
1038     * Appends part of a string builder followed by a new line to this string builder.
1039     * Appending null will call {@link #appendNull()}.
1040     *
1041     * @param str  the string builder to append
1042     * @param startIndex  the start index, inclusive, must be valid
1043     * @param length  the length to append, must be valid
1044     * @return this, to enable chaining
1045     * @since 3.2
1046     */
1047    public StrBuilder appendln(final StringBuilder str, final int startIndex, final int length) {
1048        return append(str, startIndex, length).appendNewLine();
1049    }
1050
1051    /**
1052     * Appends part of a string buffer followed by a new line to this string builder.
1053     * Appending null will call {@link #appendNull()}.
1054     *
1055     * @param str  the string to append
1056     * @param startIndex  the start index, inclusive, must be valid
1057     * @param length  the length to append, must be valid
1058     * @return this, to enable chaining
1059     * @since 2.3
1060     */
1061    public StrBuilder appendln(final StringBuffer str, final int startIndex, final int length) {
1062        return append(str, startIndex, length).appendNewLine();
1063    }
1064
1065    /**
1066     * Appends another string builder followed by a new line to this string builder.
1067     * Appending null will call {@link #appendNull()}.
1068     *
1069     * @param str  the string builder to append
1070     * @return this, to enable chaining
1071     * @since 2.3
1072     */
1073    public StrBuilder appendln(final StrBuilder str) {
1074        return append(str).appendNewLine();
1075    }
1076
1077    /**
1078     * Appends part of a string builder followed by a new line to this string builder.
1079     * Appending null will call {@link #appendNull()}.
1080     *
1081     * @param str  the string to append
1082     * @param startIndex  the start index, inclusive, must be valid
1083     * @param length  the length to append, must be valid
1084     * @return this, to enable chaining
1085     * @since 2.3
1086     */
1087    public StrBuilder appendln(final StrBuilder str, final int startIndex, final int length) {
1088        return append(str, startIndex, length).appendNewLine();
1089    }
1090
1091    /**
1092     * Appends a char array followed by a new line to the string builder.
1093     * Appending null will call {@link #appendNull()}.
1094     *
1095     * @param chars  the char array to append
1096     * @return this, to enable chaining
1097     * @since 2.3
1098     */
1099    public StrBuilder appendln(final char[] chars) {
1100        return append(chars).appendNewLine();
1101    }
1102
1103    /**
1104     * Appends a char array followed by a new line to the string builder.
1105     * Appending null will call {@link #appendNull()}.
1106     *
1107     * @param chars  the char array to append
1108     * @param startIndex  the start index, inclusive, must be valid
1109     * @param length  the length to append, must be valid
1110     * @return this, to enable chaining
1111     * @since 2.3
1112     */
1113    public StrBuilder appendln(final char[] chars, final int startIndex, final int length) {
1114        return append(chars, startIndex, length).appendNewLine();
1115    }
1116
1117    /**
1118     * Appends a boolean value followed by a new line to the string builder.
1119     *
1120     * @param value  the value to append
1121     * @return this, to enable chaining
1122     * @since 2.3
1123     */
1124    public StrBuilder appendln(final boolean value) {
1125        return append(value).appendNewLine();
1126    }
1127
1128    /**
1129     * Appends a char value followed by a new line to the string builder.
1130     *
1131     * @param ch  the value to append
1132     * @return this, to enable chaining
1133     * @since 2.3
1134     */
1135    public StrBuilder appendln(final char ch) {
1136        return append(ch).appendNewLine();
1137    }
1138
1139    /**
1140     * Appends an int value followed by a new line to the string builder using <code>String.valueOf</code>.
1141     *
1142     * @param value  the value to append
1143     * @return this, to enable chaining
1144     * @since 2.3
1145     */
1146    public StrBuilder appendln(final int value) {
1147        return append(value).appendNewLine();
1148    }
1149
1150    /**
1151     * Appends a long value followed by a new line to the string builder using <code>String.valueOf</code>.
1152     *
1153     * @param value  the value to append
1154     * @return this, to enable chaining
1155     * @since 2.3
1156     */
1157    public StrBuilder appendln(final long value) {
1158        return append(value).appendNewLine();
1159    }
1160
1161    /**
1162     * Appends a float value followed by a new line to the string builder using <code>String.valueOf</code>.
1163     *
1164     * @param value  the value to append
1165     * @return this, to enable chaining
1166     * @since 2.3
1167     */
1168    public StrBuilder appendln(final float value) {
1169        return append(value).appendNewLine();
1170    }
1171
1172    /**
1173     * Appends a double value followed by a new line to the string builder using <code>String.valueOf</code>.
1174     *
1175     * @param value  the value to append
1176     * @return this, to enable chaining
1177     * @since 2.3
1178     */
1179    public StrBuilder appendln(final double value) {
1180        return append(value).appendNewLine();
1181    }
1182
1183    //-----------------------------------------------------------------------
1184    /**
1185     * Appends each item in an array to the builder without any separators.
1186     * Appending a null array will have no effect.
1187     * Each object is appended using {@link #append(Object)}.
1188     *
1189     * @param <T>  the element type
1190     * @param array  the array to append
1191     * @return this, to enable chaining
1192     * @since 2.3
1193     */
1194    public <T> StrBuilder appendAll(@SuppressWarnings("unchecked") final T... array) {
1195        /*
1196         * @SuppressWarnings used to hide warning about vararg usage. We cannot
1197         * use @SafeVarargs, since this method is not final. Using @SupressWarnings
1198         * is fine, because it isn't inherited by subclasses, so each subclass must
1199         * vouch for itself whether its use of 'array' is safe.
1200         */
1201        if (array != null && array.length > 0) {
1202            for (final Object element : array) {
1203                append(element);
1204            }
1205        }
1206        return this;
1207    }
1208
1209    /**
1210     * Appends each item in an iterable to the builder without any separators.
1211     * Appending a null iterable will have no effect.
1212     * Each object is appended using {@link #append(Object)}.
1213     *
1214     * @param iterable  the iterable to append
1215     * @return this, to enable chaining
1216     * @since 2.3
1217     */
1218    public StrBuilder appendAll(final Iterable<?> iterable) {
1219        if (iterable != null) {
1220            for (final Object o : iterable) {
1221                append(o);
1222            }
1223        }
1224        return this;
1225    }
1226
1227    /**
1228     * Appends each item in an iterator to the builder without any separators.
1229     * Appending a null iterator will have no effect.
1230     * Each object is appended using {@link #append(Object)}.
1231     *
1232     * @param it  the iterator to append
1233     * @return this, to enable chaining
1234     * @since 2.3
1235     */
1236    public StrBuilder appendAll(final Iterator<?> it) {
1237        if (it != null) {
1238            while (it.hasNext()) {
1239                append(it.next());
1240            }
1241        }
1242        return this;
1243    }
1244
1245    //-----------------------------------------------------------------------
1246    /**
1247     * Appends an array placing separators between each value, but
1248     * not before the first or after the last.
1249     * Appending a null array will have no effect.
1250     * Each object is appended using {@link #append(Object)}.
1251     *
1252     * @param array  the array to append
1253     * @param separator  the separator to use, null means no separator
1254     * @return this, to enable chaining
1255     */
1256    public StrBuilder appendWithSeparators(final Object[] array, final String separator) {
1257        if (array != null && array.length > 0) {
1258            final String sep = Objects.toString(separator, "");
1259            append(array[0]);
1260            for (int i = 1; i < array.length; i++) {
1261                append(sep);
1262                append(array[i]);
1263            }
1264        }
1265        return this;
1266    }
1267
1268    /**
1269     * Appends an iterable placing separators between each value, but
1270     * not before the first or after the last.
1271     * Appending a null iterable will have no effect.
1272     * Each object is appended using {@link #append(Object)}.
1273     *
1274     * @param iterable  the iterable to append
1275     * @param separator  the separator to use, null means no separator
1276     * @return this, to enable chaining
1277     */
1278    public StrBuilder appendWithSeparators(final Iterable<?> iterable, final String separator) {
1279        if (iterable != null) {
1280            final String sep = Objects.toString(separator, "");
1281            final Iterator<?> it = iterable.iterator();
1282            while (it.hasNext()) {
1283                append(it.next());
1284                if (it.hasNext()) {
1285                    append(sep);
1286                }
1287            }
1288        }
1289        return this;
1290    }
1291
1292    /**
1293     * Appends an iterator placing separators between each value, but
1294     * not before the first or after the last.
1295     * Appending a null iterator will have no effect.
1296     * Each object is appended using {@link #append(Object)}.
1297     *
1298     * @param it  the iterator to append
1299     * @param separator  the separator to use, null means no separator
1300     * @return this, to enable chaining
1301     */
1302    public StrBuilder appendWithSeparators(final Iterator<?> it, final String separator) {
1303        if (it != null) {
1304            final String sep = Objects.toString(separator, "");
1305            while (it.hasNext()) {
1306                append(it.next());
1307                if (it.hasNext()) {
1308                    append(sep);
1309                }
1310            }
1311        }
1312        return this;
1313    }
1314
1315    //-----------------------------------------------------------------------
1316    /**
1317     * Appends a separator if the builder is currently non-empty.
1318     * Appending a null separator will have no effect.
1319     * The separator is appended using {@link #append(String)}.
1320     * <p>
1321     * This method is useful for adding a separator each time around the
1322     * loop except the first.
1323     * <pre>
1324     * for (Iterator it = list.iterator(); it.hasNext(); ) {
1325     *   appendSeparator(",");
1326     *   append(it.next());
1327     * }
1328     * </pre>
1329     * Note that for this simple example, you should use
1330     * {@link #appendWithSeparators(Iterable, String)}.
1331     *
1332     * @param separator  the separator to use, null means no separator
1333     * @return this, to enable chaining
1334     * @since 2.3
1335     */
1336    public StrBuilder appendSeparator(final String separator) {
1337        return appendSeparator(separator, null);
1338    }
1339
1340    /**
1341     * Appends one of both separators to the StrBuilder.
1342     * If the builder is currently empty it will append the defaultIfEmpty-separator
1343     * Otherwise it will append the standard-separator
1344     *
1345     * Appending a null separator will have no effect.
1346     * The separator is appended using {@link #append(String)}.
1347     * <p>
1348     * This method is for example useful for constructing queries
1349     * <pre>
1350     * StrBuilder whereClause = new StrBuilder();
1351     * if(searchCommand.getPriority() != null) {
1352     *  whereClause.appendSeparator(" and", " where");
1353     *  whereClause.append(" priority = ?")
1354     * }
1355     * if(searchCommand.getComponent() != null) {
1356     *  whereClause.appendSeparator(" and", " where");
1357     *  whereClause.append(" component = ?")
1358     * }
1359     * selectClause.append(whereClause)
1360     * </pre>
1361     *
1362     * @param standard the separator if builder is not empty, null means no separator
1363     * @param defaultIfEmpty the separator if builder is empty, null means no separator
1364     * @return this, to enable chaining
1365     * @since 2.5
1366     */
1367    public StrBuilder appendSeparator(final String standard, final String defaultIfEmpty) {
1368        final String str = isEmpty() ? defaultIfEmpty : standard;
1369        if (str != null) {
1370            append(str);
1371        }
1372        return this;
1373    }
1374
1375    /**
1376     * Appends a separator if the builder is currently non-empty.
1377     * The separator is appended using {@link #append(char)}.
1378     * <p>
1379     * This method is useful for adding a separator each time around the
1380     * loop except the first.
1381     * <pre>
1382     * for (Iterator it = list.iterator(); it.hasNext(); ) {
1383     *   appendSeparator(',');
1384     *   append(it.next());
1385     * }
1386     * </pre>
1387     * Note that for this simple example, you should use
1388     * {@link #appendWithSeparators(Iterable, String)}.
1389     *
1390     * @param separator  the separator to use
1391     * @return this, to enable chaining
1392     * @since 2.3
1393     */
1394    public StrBuilder appendSeparator(final char separator) {
1395        if (size() > 0) {
1396            append(separator);
1397        }
1398        return this;
1399    }
1400
1401    /**
1402     * Append one of both separators to the builder
1403     * If the builder is currently empty it will append the defaultIfEmpty-separator
1404     * Otherwise it will append the standard-separator
1405     *
1406     * The separator is appended using {@link #append(char)}.
1407     * @param standard the separator if builder is not empty
1408     * @param defaultIfEmpty the separator if builder is empty
1409     * @return this, to enable chaining
1410     * @since 2.5
1411     */
1412    public StrBuilder appendSeparator(final char standard, final char defaultIfEmpty) {
1413        if (size() > 0) {
1414            append(standard);
1415        } else {
1416            append(defaultIfEmpty);
1417        }
1418        return this;
1419    }
1420    /**
1421     * Appends a separator to the builder if the loop index is greater than zero.
1422     * Appending a null separator will have no effect.
1423     * The separator is appended using {@link #append(String)}.
1424     * <p>
1425     * This method is useful for adding a separator each time around the
1426     * loop except the first.
1427     * </p>
1428     * <pre>
1429     * for (int i = 0; i &lt; list.size(); i++) {
1430     *   appendSeparator(",", i);
1431     *   append(list.get(i));
1432     * }
1433     * </pre>
1434     * Note that for this simple example, you should use
1435     * {@link #appendWithSeparators(Iterable, String)}.
1436     *
1437     * @param separator  the separator to use, null means no separator
1438     * @param loopIndex  the loop index
1439     * @return this, to enable chaining
1440     * @since 2.3
1441     */
1442    public StrBuilder appendSeparator(final String separator, final int loopIndex) {
1443        if (separator != null && loopIndex > 0) {
1444            append(separator);
1445        }
1446        return this;
1447    }
1448
1449    /**
1450     * Appends a separator to the builder if the loop index is greater than zero.
1451     * The separator is appended using {@link #append(char)}.
1452     * <p>
1453     * This method is useful for adding a separator each time around the
1454     * loop except the first.
1455     * </p>
1456     * <pre>
1457     * for (int i = 0; i &lt; list.size(); i++) {
1458     *   appendSeparator(",", i);
1459     *   append(list.get(i));
1460     * }
1461     * </pre>
1462     * Note that for this simple example, you should use
1463     * {@link #appendWithSeparators(Iterable, String)}.
1464     *
1465     * @param separator  the separator to use
1466     * @param loopIndex  the loop index
1467     * @return this, to enable chaining
1468     * @since 2.3
1469     */
1470    public StrBuilder appendSeparator(final char separator, final int loopIndex) {
1471        if (loopIndex > 0) {
1472            append(separator);
1473        }
1474        return this;
1475    }
1476
1477    //-----------------------------------------------------------------------
1478    /**
1479     * Appends the pad character to the builder the specified number of times.
1480     *
1481     * @param length  the length to append, negative means no append
1482     * @param padChar  the character to append
1483     * @return this, to enable chaining
1484     */
1485    public StrBuilder appendPadding(final int length, final char padChar) {
1486        if (length >= 0) {
1487            ensureCapacity(size + length);
1488            for (int i = 0; i < length; i++) {
1489                buffer[size++] = padChar;
1490            }
1491        }
1492        return this;
1493    }
1494
1495    //-----------------------------------------------------------------------
1496    /**
1497     * Appends an object to the builder padding on the left to a fixed width.
1498     * The <code>toString</code> of the object is used.
1499     * If the object is larger than the length, the left hand side is lost.
1500     * If the object is null, the null text value is used.
1501     *
1502     * @param obj  the object to append, null uses null text
1503     * @param width  the fixed field width, zero or negative has no effect
1504     * @param padChar  the pad character to use
1505     * @return this, to enable chaining
1506     */
1507    public StrBuilder appendFixedWidthPadLeft(final Object obj, final int width, final char padChar) {
1508        if (width > 0) {
1509            ensureCapacity(size + width);
1510            String str = (obj == null ? getNullText() : obj.toString());
1511            if (str == null) {
1512                str = StringUtils.EMPTY;
1513            }
1514            final int strLen = str.length();
1515            if (strLen >= width) {
1516                str.getChars(strLen - width, strLen, buffer, size);
1517            } else {
1518                final int padLen = width - strLen;
1519                for (int i = 0; i < padLen; i++) {
1520                    buffer[size + i] = padChar;
1521                }
1522                str.getChars(0, strLen, buffer, size + padLen);
1523            }
1524            size += width;
1525        }
1526        return this;
1527    }
1528
1529    /**
1530     * Appends an object to the builder padding on the left to a fixed width.
1531     * The <code>String.valueOf</code> of the <code>int</code> value is used.
1532     * If the formatted value is larger than the length, the left hand side is lost.
1533     *
1534     * @param value  the value to append
1535     * @param width  the fixed field width, zero or negative has no effect
1536     * @param padChar  the pad character to use
1537     * @return this, to enable chaining
1538     */
1539    public StrBuilder appendFixedWidthPadLeft(final int value, final int width, final char padChar) {
1540        return appendFixedWidthPadLeft(String.valueOf(value), width, padChar);
1541    }
1542
1543    /**
1544     * Appends an object to the builder padding on the right to a fixed length.
1545     * The <code>toString</code> of the object is used.
1546     * If the object is larger than the length, the right hand side is lost.
1547     * If the object is null, null text value is used.
1548     *
1549     * @param obj  the object to append, null uses null text
1550     * @param width  the fixed field width, zero or negative has no effect
1551     * @param padChar  the pad character to use
1552     * @return this, to enable chaining
1553     */
1554    public StrBuilder appendFixedWidthPadRight(final Object obj, final int width, final char padChar) {
1555        if (width > 0) {
1556            ensureCapacity(size + width);
1557            String str = (obj == null ? getNullText() : obj.toString());
1558            if (str == null) {
1559                str = StringUtils.EMPTY;
1560            }
1561            final int strLen = str.length();
1562            if (strLen >= width) {
1563                str.getChars(0, width, buffer, size);
1564            } else {
1565                final int padLen = width - strLen;
1566                str.getChars(0, strLen, buffer, size);
1567                for (int i = 0; i < padLen; i++) {
1568                    buffer[size + strLen + i] = padChar;
1569                }
1570            }
1571            size += width;
1572        }
1573        return this;
1574    }
1575
1576    /**
1577     * Appends an object to the builder padding on the right to a fixed length.
1578     * The <code>String.valueOf</code> of the <code>int</code> value is used.
1579     * If the object is larger than the length, the right hand side is lost.
1580     *
1581     * @param value  the value to append
1582     * @param width  the fixed field width, zero or negative has no effect
1583     * @param padChar  the pad character to use
1584     * @return this, to enable chaining
1585     */
1586    public StrBuilder appendFixedWidthPadRight(final int value, final int width, final char padChar) {
1587        return appendFixedWidthPadRight(String.valueOf(value), width, padChar);
1588    }
1589
1590    //-----------------------------------------------------------------------
1591    /**
1592     * Inserts the string representation of an object into this builder.
1593     * Inserting null will use the stored null text value.
1594     *
1595     * @param index  the index to add at, must be valid
1596     * @param obj  the object to insert
1597     * @return this, to enable chaining
1598     * @throws IndexOutOfBoundsException if the index is invalid
1599     */
1600    public StrBuilder insert(final int index, final Object obj) {
1601        if (obj == null) {
1602            return insert(index, nullText);
1603        }
1604        return insert(index, obj.toString());
1605    }
1606
1607    /**
1608     * Inserts the string into this builder.
1609     * Inserting null will use the stored null text value.
1610     *
1611     * @param index  the index to add at, must be valid
1612     * @param str  the string to insert
1613     * @return this, to enable chaining
1614     * @throws IndexOutOfBoundsException if the index is invalid
1615     */
1616    public StrBuilder insert(final int index, String str) {
1617        validateIndex(index);
1618        if (str == null) {
1619            str = nullText;
1620        }
1621        if (str != null) {
1622            final int strLen = str.length();
1623            if (strLen > 0) {
1624                final int newSize = size + strLen;
1625                ensureCapacity(newSize);
1626                System.arraycopy(buffer, index, buffer, index + strLen, size - index);
1627                size = newSize;
1628                str.getChars(0, strLen, buffer, index);
1629            }
1630        }
1631        return this;
1632    }
1633
1634    /**
1635     * Inserts the character array into this builder.
1636     * Inserting null will use the stored null text value.
1637     *
1638     * @param index  the index to add at, must be valid
1639     * @param chars  the char array to insert
1640     * @return this, to enable chaining
1641     * @throws IndexOutOfBoundsException if the index is invalid
1642     */
1643    public StrBuilder insert(final int index, final char chars[]) {
1644        validateIndex(index);
1645        if (chars == null) {
1646            return insert(index, nullText);
1647        }
1648        final int len = chars.length;
1649        if (len > 0) {
1650            ensureCapacity(size + len);
1651            System.arraycopy(buffer, index, buffer, index + len, size - index);
1652            System.arraycopy(chars, 0, buffer, index, len);
1653            size += len;
1654        }
1655        return this;
1656    }
1657
1658    /**
1659     * Inserts part of the character array into this builder.
1660     * Inserting null will use the stored null text value.
1661     *
1662     * @param index  the index to add at, must be valid
1663     * @param chars  the char array to insert
1664     * @param offset  the offset into the character array to start at, must be valid
1665     * @param length  the length of the character array part to copy, must be positive
1666     * @return this, to enable chaining
1667     * @throws IndexOutOfBoundsException if any index is invalid
1668     */
1669    public StrBuilder insert(final int index, final char chars[], final int offset, final int length) {
1670        validateIndex(index);
1671        if (chars == null) {
1672            return insert(index, nullText);
1673        }
1674        if (offset < 0 || offset > chars.length) {
1675            throw new StringIndexOutOfBoundsException("Invalid offset: " + offset);
1676        }
1677        if (length < 0 || offset + length > chars.length) {
1678            throw new StringIndexOutOfBoundsException("Invalid length: " + length);
1679        }
1680        if (length > 0) {
1681            ensureCapacity(size + length);
1682            System.arraycopy(buffer, index, buffer, index + length, size - index);
1683            System.arraycopy(chars, offset, buffer, index, length);
1684            size += length;
1685        }
1686        return this;
1687    }
1688
1689    /**
1690     * Inserts the value into this builder.
1691     *
1692     * @param index  the index to add at, must be valid
1693     * @param value  the value to insert
1694     * @return this, to enable chaining
1695     * @throws IndexOutOfBoundsException if the index is invalid
1696     */
1697    public StrBuilder insert(int index, final boolean value) {
1698        validateIndex(index);
1699        if (value) {
1700            ensureCapacity(size + 4);
1701            System.arraycopy(buffer, index, buffer, index + 4, size - index);
1702            buffer[index++] = 't';
1703            buffer[index++] = 'r';
1704            buffer[index++] = 'u';
1705            buffer[index] = 'e';
1706            size += 4;
1707        } else {
1708            ensureCapacity(size + 5);
1709            System.arraycopy(buffer, index, buffer, index + 5, size - index);
1710            buffer[index++] = 'f';
1711            buffer[index++] = 'a';
1712            buffer[index++] = 'l';
1713            buffer[index++] = 's';
1714            buffer[index] = 'e';
1715            size += 5;
1716        }
1717        return this;
1718    }
1719
1720    /**
1721     * Inserts the value into this builder.
1722     *
1723     * @param index  the index to add at, must be valid
1724     * @param value  the value to insert
1725     * @return this, to enable chaining
1726     * @throws IndexOutOfBoundsException if the index is invalid
1727     */
1728    public StrBuilder insert(final int index, final char value) {
1729        validateIndex(index);
1730        ensureCapacity(size + 1);
1731        System.arraycopy(buffer, index, buffer, index + 1, size - index);
1732        buffer[index] = value;
1733        size++;
1734        return this;
1735    }
1736
1737    /**
1738     * Inserts the value into this builder.
1739     *
1740     * @param index  the index to add at, must be valid
1741     * @param value  the value to insert
1742     * @return this, to enable chaining
1743     * @throws IndexOutOfBoundsException if the index is invalid
1744     */
1745    public StrBuilder insert(final int index, final int value) {
1746        return insert(index, String.valueOf(value));
1747    }
1748
1749    /**
1750     * Inserts the value into this builder.
1751     *
1752     * @param index  the index to add at, must be valid
1753     * @param value  the value to insert
1754     * @return this, to enable chaining
1755     * @throws IndexOutOfBoundsException if the index is invalid
1756     */
1757    public StrBuilder insert(final int index, final long value) {
1758        return insert(index, String.valueOf(value));
1759    }
1760
1761    /**
1762     * Inserts the value into this builder.
1763     *
1764     * @param index  the index to add at, must be valid
1765     * @param value  the value to insert
1766     * @return this, to enable chaining
1767     * @throws IndexOutOfBoundsException if the index is invalid
1768     */
1769    public StrBuilder insert(final int index, final float value) {
1770        return insert(index, String.valueOf(value));
1771    }
1772
1773    /**
1774     * Inserts the value into this builder.
1775     *
1776     * @param index  the index to add at, must be valid
1777     * @param value  the value to insert
1778     * @return this, to enable chaining
1779     * @throws IndexOutOfBoundsException if the index is invalid
1780     */
1781    public StrBuilder insert(final int index, final double value) {
1782        return insert(index, String.valueOf(value));
1783    }
1784
1785    //-----------------------------------------------------------------------
1786    /**
1787     * Internal method to delete a range without validation.
1788     *
1789     * @param startIndex  the start index, must be valid
1790     * @param endIndex  the end index (exclusive), must be valid
1791     * @param len  the length, must be valid
1792     * @throws IndexOutOfBoundsException if any index is invalid
1793     */
1794    private void deleteImpl(final int startIndex, final int endIndex, final int len) {
1795        System.arraycopy(buffer, endIndex, buffer, startIndex, size - endIndex);
1796        size -= len;
1797    }
1798
1799    /**
1800     * Deletes the characters between the two specified indices.
1801     *
1802     * @param startIndex  the start index, inclusive, must be valid
1803     * @param endIndex  the end index, exclusive, must be valid except
1804     *  that if too large it is treated as end of string
1805     * @return this, to enable chaining
1806     * @throws IndexOutOfBoundsException if the index is invalid
1807     */
1808    public StrBuilder delete(final int startIndex, int endIndex) {
1809        endIndex = validateRange(startIndex, endIndex);
1810        final int len = endIndex - startIndex;
1811        if (len > 0) {
1812            deleteImpl(startIndex, endIndex, len);
1813        }
1814        return this;
1815    }
1816
1817    //-----------------------------------------------------------------------
1818    /**
1819     * Deletes the character wherever it occurs in the builder.
1820     *
1821     * @param ch  the character to delete
1822     * @return this, to enable chaining
1823     */
1824    public StrBuilder deleteAll(final char ch) {
1825        for (int i = 0; i < size; i++) {
1826            if (buffer[i] == ch) {
1827                final int start = i;
1828                while (++i < size) {
1829                    if (buffer[i] != ch) {
1830                        break;
1831                    }
1832                }
1833                final int len = i - start;
1834                deleteImpl(start, i, len);
1835                i -= len;
1836            }
1837        }
1838        return this;
1839    }
1840
1841    /**
1842     * Deletes the character wherever it occurs in the builder.
1843     *
1844     * @param ch  the character to delete
1845     * @return this, to enable chaining
1846     */
1847    public StrBuilder deleteFirst(final char ch) {
1848        for (int i = 0; i < size; i++) {
1849            if (buffer[i] == ch) {
1850                deleteImpl(i, i + 1, 1);
1851                break;
1852            }
1853        }
1854        return this;
1855    }
1856
1857    //-----------------------------------------------------------------------
1858    /**
1859     * Deletes the string wherever it occurs in the builder.
1860     *
1861     * @param str  the string to delete, null causes no action
1862     * @return this, to enable chaining
1863     */
1864    public StrBuilder deleteAll(final String str) {
1865        final int len = (str == null ? 0 : str.length());
1866        if (len > 0) {
1867            int index = indexOf(str, 0);
1868            while (index >= 0) {
1869                deleteImpl(index, index + len, len);
1870                index = indexOf(str, index);
1871            }
1872        }
1873        return this;
1874    }
1875
1876    /**
1877     * Deletes the string wherever it occurs in the builder.
1878     *
1879     * @param str  the string to delete, null causes no action
1880     * @return this, to enable chaining
1881     */
1882    public StrBuilder deleteFirst(final String str) {
1883        final int len = (str == null ? 0 : str.length());
1884        if (len > 0) {
1885            final int index = indexOf(str, 0);
1886            if (index >= 0) {
1887                deleteImpl(index, index + len, len);
1888            }
1889        }
1890        return this;
1891    }
1892
1893    //-----------------------------------------------------------------------
1894    /**
1895     * Deletes all parts of the builder that the matcher matches.
1896     * <p>
1897     * Matchers can be used to perform advanced deletion behaviour.
1898     * For example you could write a matcher to delete all occurrences
1899     * where the character 'a' is followed by a number.
1900     *
1901     * @param matcher  the matcher to use to find the deletion, null causes no action
1902     * @return this, to enable chaining
1903     */
1904    public StrBuilder deleteAll(final StrMatcher matcher) {
1905        return replace(matcher, null, 0, size, -1);
1906    }
1907
1908    /**
1909     * Deletes the first match within the builder using the specified matcher.
1910     * <p>
1911     * Matchers can be used to perform advanced deletion behaviour.
1912     * For example you could write a matcher to delete
1913     * where the character 'a' is followed by a number.
1914     *
1915     * @param matcher  the matcher to use to find the deletion, null causes no action
1916     * @return this, to enable chaining
1917     */
1918    public StrBuilder deleteFirst(final StrMatcher matcher) {
1919        return replace(matcher, null, 0, size, 1);
1920    }
1921
1922    //-----------------------------------------------------------------------
1923    /**
1924     * Internal method to delete a range without validation.
1925     *
1926     * @param startIndex  the start index, must be valid
1927     * @param endIndex  the end index (exclusive), must be valid
1928     * @param removeLen  the length to remove (endIndex - startIndex), must be valid
1929     * @param insertStr  the string to replace with, null means delete range
1930     * @param insertLen  the length of the insert string, must be valid
1931     * @throws IndexOutOfBoundsException if any index is invalid
1932     */
1933    private void replaceImpl(final int startIndex, final int endIndex, final int removeLen, final String insertStr, final int insertLen) {
1934        final int newSize = size - removeLen + insertLen;
1935        if (insertLen != removeLen) {
1936            ensureCapacity(newSize);
1937            System.arraycopy(buffer, endIndex, buffer, startIndex + insertLen, size - endIndex);
1938            size = newSize;
1939        }
1940        if (insertLen > 0) {
1941            insertStr.getChars(0, insertLen, buffer, startIndex);
1942        }
1943    }
1944
1945    /**
1946     * Replaces a portion of the string builder with another string.
1947     * The length of the inserted string does not have to match the removed length.
1948     *
1949     * @param startIndex  the start index, inclusive, must be valid
1950     * @param endIndex  the end index, exclusive, must be valid except
1951     *  that if too large it is treated as end of string
1952     * @param replaceStr  the string to replace with, null means delete range
1953     * @return this, to enable chaining
1954     * @throws IndexOutOfBoundsException if the index is invalid
1955     */
1956    public StrBuilder replace(final int startIndex, int endIndex, final String replaceStr) {
1957        endIndex = validateRange(startIndex, endIndex);
1958        final int insertLen = (replaceStr == null ? 0 : replaceStr.length());
1959        replaceImpl(startIndex, endIndex, endIndex - startIndex, replaceStr, insertLen);
1960        return this;
1961    }
1962
1963    //-----------------------------------------------------------------------
1964    /**
1965     * Replaces the search character with the replace character
1966     * throughout the builder.
1967     *
1968     * @param search  the search character
1969     * @param replace  the replace character
1970     * @return this, to enable chaining
1971     */
1972    public StrBuilder replaceAll(final char search, final char replace) {
1973        if (search != replace) {
1974            for (int i = 0; i < size; i++) {
1975                if (buffer[i] == search) {
1976                    buffer[i] = replace;
1977                }
1978            }
1979        }
1980        return this;
1981    }
1982
1983    /**
1984     * Replaces the first instance of the search character with the
1985     * replace character in the builder.
1986     *
1987     * @param search  the search character
1988     * @param replace  the replace character
1989     * @return this, to enable chaining
1990     */
1991    public StrBuilder replaceFirst(final char search, final char replace) {
1992        if (search != replace) {
1993            for (int i = 0; i < size; i++) {
1994                if (buffer[i] == search) {
1995                    buffer[i] = replace;
1996                    break;
1997                }
1998            }
1999        }
2000        return this;
2001    }
2002
2003    //-----------------------------------------------------------------------
2004    /**
2005     * Replaces the search string with the replace string throughout the builder.
2006     *
2007     * @param searchStr  the search string, null causes no action to occur
2008     * @param replaceStr  the replace string, null is equivalent to an empty string
2009     * @return this, to enable chaining
2010     */
2011    public StrBuilder replaceAll(final String searchStr, final String replaceStr) {
2012        final int searchLen = (searchStr == null ? 0 : searchStr.length());
2013        if (searchLen > 0) {
2014            final int replaceLen = (replaceStr == null ? 0 : replaceStr.length());
2015            int index = indexOf(searchStr, 0);
2016            while (index >= 0) {
2017                replaceImpl(index, index + searchLen, searchLen, replaceStr, replaceLen);
2018                index = indexOf(searchStr, index + replaceLen);
2019            }
2020        }
2021        return this;
2022    }
2023
2024    /**
2025     * Replaces the first instance of the search string with the replace string.
2026     *
2027     * @param searchStr  the search string, null causes no action to occur
2028     * @param replaceStr  the replace string, null is equivalent to an empty string
2029     * @return this, to enable chaining
2030     */
2031    public StrBuilder replaceFirst(final String searchStr, final String replaceStr) {
2032        final int searchLen = (searchStr == null ? 0 : searchStr.length());
2033        if (searchLen > 0) {
2034            final int index = indexOf(searchStr, 0);
2035            if (index >= 0) {
2036                final int replaceLen = (replaceStr == null ? 0 : replaceStr.length());
2037                replaceImpl(index, index + searchLen, searchLen, replaceStr, replaceLen);
2038            }
2039        }
2040        return this;
2041    }
2042
2043    //-----------------------------------------------------------------------
2044    /**
2045     * Replaces all matches within the builder with the replace string.
2046     * <p>
2047     * Matchers can be used to perform advanced replace behaviour.
2048     * For example you could write a matcher to replace all occurrences
2049     * where the character 'a' is followed by a number.
2050     *
2051     * @param matcher  the matcher to use to find the deletion, null causes no action
2052     * @param replaceStr  the replace string, null is equivalent to an empty string
2053     * @return this, to enable chaining
2054     */
2055    public StrBuilder replaceAll(final StrMatcher matcher, final String replaceStr) {
2056        return replace(matcher, replaceStr, 0, size, -1);
2057    }
2058
2059    /**
2060     * Replaces the first match within the builder with the replace string.
2061     * <p>
2062     * Matchers can be used to perform advanced replace behaviour.
2063     * For example you could write a matcher to replace
2064     * where the character 'a' is followed by a number.
2065     *
2066     * @param matcher  the matcher to use to find the deletion, null causes no action
2067     * @param replaceStr  the replace string, null is equivalent to an empty string
2068     * @return this, to enable chaining
2069     */
2070    public StrBuilder replaceFirst(final StrMatcher matcher, final String replaceStr) {
2071        return replace(matcher, replaceStr, 0, size, 1);
2072    }
2073
2074    // -----------------------------------------------------------------------
2075    /**
2076     * Advanced search and replaces within the builder using a matcher.
2077     * <p>
2078     * Matchers can be used to perform advanced behaviour.
2079     * For example you could write a matcher to delete all occurrences
2080     * where the character 'a' is followed by a number.
2081     *
2082     * @param matcher  the matcher to use to find the deletion, null causes no action
2083     * @param replaceStr  the string to replace the match with, null is a delete
2084     * @param startIndex  the start index, inclusive, must be valid
2085     * @param endIndex  the end index, exclusive, must be valid except
2086     *  that if too large it is treated as end of string
2087     * @param replaceCount  the number of times to replace, -1 for replace all
2088     * @return this, to enable chaining
2089     * @throws IndexOutOfBoundsException if start index is invalid
2090     */
2091    public StrBuilder replace(
2092            final StrMatcher matcher, final String replaceStr,
2093            final int startIndex, int endIndex, final int replaceCount) {
2094        endIndex = validateRange(startIndex, endIndex);
2095        return replaceImpl(matcher, replaceStr, startIndex, endIndex, replaceCount);
2096    }
2097
2098    /**
2099     * Replaces within the builder using a matcher.
2100     * <p>
2101     * Matchers can be used to perform advanced behaviour.
2102     * For example you could write a matcher to delete all occurrences
2103     * where the character 'a' is followed by a number.
2104     *
2105     * @param matcher  the matcher to use to find the deletion, null causes no action
2106     * @param replaceStr  the string to replace the match with, null is a delete
2107     * @param from  the start index, must be valid
2108     * @param to  the end index (exclusive), must be valid
2109     * @param replaceCount  the number of times to replace, -1 for replace all
2110     * @return this, to enable chaining
2111     * @throws IndexOutOfBoundsException if any index is invalid
2112     */
2113    private StrBuilder replaceImpl(
2114            final StrMatcher matcher, final String replaceStr,
2115            final int from, int to, int replaceCount) {
2116        if (matcher == null || size == 0) {
2117            return this;
2118        }
2119        final int replaceLen = (replaceStr == null ? 0 : replaceStr.length());
2120        for (int i = from; i < to && replaceCount != 0; i++) {
2121            final char[] buf = buffer;
2122            final int removeLen = matcher.isMatch(buf, i, from, to);
2123            if (removeLen > 0) {
2124                replaceImpl(i, i + removeLen, removeLen, replaceStr, replaceLen);
2125                to = to - removeLen + replaceLen;
2126                i = i + replaceLen - 1;
2127                if (replaceCount > 0) {
2128                    replaceCount--;
2129                }
2130            }
2131        }
2132        return this;
2133    }
2134
2135    //-----------------------------------------------------------------------
2136    /**
2137     * Reverses the string builder placing each character in the opposite index.
2138     *
2139     * @return this, to enable chaining
2140     */
2141    public StrBuilder reverse() {
2142        if (size == 0) {
2143            return this;
2144        }
2145
2146        final int half = size / 2;
2147        final char[] buf = buffer;
2148        for (int leftIdx = 0, rightIdx = size - 1; leftIdx < half; leftIdx++,rightIdx--) {
2149            final char swap = buf[leftIdx];
2150            buf[leftIdx] = buf[rightIdx];
2151            buf[rightIdx] = swap;
2152        }
2153        return this;
2154    }
2155
2156    //-----------------------------------------------------------------------
2157    /**
2158     * Trims the builder by removing characters less than or equal to a space
2159     * from the beginning and end.
2160     *
2161     * @return this, to enable chaining
2162     */
2163    public StrBuilder trim() {
2164        if (size == 0) {
2165            return this;
2166        }
2167        int len = size;
2168        final char[] buf = buffer;
2169        int pos = 0;
2170        while (pos < len && buf[pos] <= ' ') {
2171            pos++;
2172        }
2173        while (pos < len && buf[len - 1] <= ' ') {
2174            len--;
2175        }
2176        if (len < size) {
2177            delete(len, size);
2178        }
2179        if (pos > 0) {
2180            delete(0, pos);
2181        }
2182        return this;
2183    }
2184
2185    //-----------------------------------------------------------------------
2186    /**
2187     * Checks whether this builder starts with the specified string.
2188     * <p>
2189     * Note that this method handles null input quietly, unlike String.
2190     *
2191     * @param str  the string to search for, null returns false
2192     * @return true if the builder starts with the string
2193     */
2194    public boolean startsWith(final String str) {
2195        if (str == null) {
2196            return false;
2197        }
2198        final int len = str.length();
2199        if (len == 0) {
2200            return true;
2201        }
2202        if (len > size) {
2203            return false;
2204        }
2205        for (int i = 0; i < len; i++) {
2206            if (buffer[i] != str.charAt(i)) {
2207                return false;
2208            }
2209        }
2210        return true;
2211    }
2212
2213    /**
2214     * Checks whether this builder ends with the specified string.
2215     * <p>
2216     * Note that this method handles null input quietly, unlike String.
2217     *
2218     * @param str  the string to search for, null returns false
2219     * @return true if the builder ends with the string
2220     */
2221    public boolean endsWith(final String str) {
2222        if (str == null) {
2223            return false;
2224        }
2225        final int len = str.length();
2226        if (len == 0) {
2227            return true;
2228        }
2229        if (len > size) {
2230            return false;
2231        }
2232        int pos = size - len;
2233        for (int i = 0; i < len; i++,pos++) {
2234            if (buffer[pos] != str.charAt(i)) {
2235                return false;
2236            }
2237        }
2238        return true;
2239    }
2240
2241    //-----------------------------------------------------------------------
2242    /**
2243     * {@inheritDoc}
2244     * @since 3.0
2245     */
2246    @Override
2247    public CharSequence subSequence(final int startIndex, final int endIndex) {
2248      if (startIndex < 0) {
2249          throw new StringIndexOutOfBoundsException(startIndex);
2250      }
2251      if (endIndex > size) {
2252          throw new StringIndexOutOfBoundsException(endIndex);
2253      }
2254      if (startIndex > endIndex) {
2255          throw new StringIndexOutOfBoundsException(endIndex - startIndex);
2256      }
2257      return substring(startIndex, endIndex);
2258    }
2259
2260    /**
2261     * Extracts a portion of this string builder as a string.
2262     *
2263     * @param start  the start index, inclusive, must be valid
2264     * @return the new string
2265     * @throws IndexOutOfBoundsException if the index is invalid
2266     */
2267    public String substring(final int start) {
2268        return substring(start, size);
2269    }
2270
2271    /**
2272     * Extracts a portion of this string builder as a string.
2273     * <p>
2274     * Note: This method treats an endIndex greater than the length of the
2275     * builder as equal to the length of the builder, and continues
2276     * without error, unlike StringBuffer or String.
2277     *
2278     * @param startIndex  the start index, inclusive, must be valid
2279     * @param endIndex  the end index, exclusive, must be valid except
2280     *  that if too large it is treated as end of string
2281     * @return the new string
2282     * @throws IndexOutOfBoundsException if the index is invalid
2283     */
2284    public String substring(final int startIndex, int endIndex) {
2285        endIndex = validateRange(startIndex, endIndex);
2286        return new String(buffer, startIndex, endIndex - startIndex);
2287    }
2288
2289    /**
2290     * Extracts the leftmost characters from the string builder without
2291     * throwing an exception.
2292     * <p>
2293     * This method extracts the left <code>length</code> characters from
2294     * the builder. If this many characters are not available, the whole
2295     * builder is returned. Thus the returned string may be shorter than the
2296     * length requested.
2297     *
2298     * @param length  the number of characters to extract, negative returns empty string
2299     * @return the new string
2300     */
2301    public String leftString(final int length) {
2302        if (length <= 0) {
2303            return StringUtils.EMPTY;
2304        } else if (length >= size) {
2305            return new String(buffer, 0, size);
2306        } else {
2307            return new String(buffer, 0, length);
2308        }
2309    }
2310
2311    /**
2312     * Extracts the rightmost characters from the string builder without
2313     * throwing an exception.
2314     * <p>
2315     * This method extracts the right <code>length</code> characters from
2316     * the builder. If this many characters are not available, the whole
2317     * builder is returned. Thus the returned string may be shorter than the
2318     * length requested.
2319     *
2320     * @param length  the number of characters to extract, negative returns empty string
2321     * @return the new string
2322     */
2323    public String rightString(final int length) {
2324        if (length <= 0) {
2325            return StringUtils.EMPTY;
2326        } else if (length >= size) {
2327            return new String(buffer, 0, size);
2328        } else {
2329            return new String(buffer, size - length, length);
2330        }
2331    }
2332
2333    /**
2334     * Extracts some characters from the middle of the string builder without
2335     * throwing an exception.
2336     * <p>
2337     * This method extracts <code>length</code> characters from the builder
2338     * at the specified index.
2339     * If the index is negative it is treated as zero.
2340     * If the index is greater than the builder size, it is treated as the builder size.
2341     * If the length is negative, the empty string is returned.
2342     * If insufficient characters are available in the builder, as much as possible is returned.
2343     * Thus the returned string may be shorter than the length requested.
2344     *
2345     * @param index  the index to start at, negative means zero
2346     * @param length  the number of characters to extract, negative returns empty string
2347     * @return the new string
2348     */
2349    public String midString(int index, final int length) {
2350        if (index < 0) {
2351            index = 0;
2352        }
2353        if (length <= 0 || index >= size) {
2354            return StringUtils.EMPTY;
2355        }
2356        if (size <= index + length) {
2357            return new String(buffer, index, size - index);
2358        }
2359        return new String(buffer, index, length);
2360    }
2361
2362    //-----------------------------------------------------------------------
2363    /**
2364     * Checks if the string builder contains the specified char.
2365     *
2366     * @param ch  the character to find
2367     * @return true if the builder contains the character
2368     */
2369    public boolean contains(final char ch) {
2370        final char[] thisBuf = buffer;
2371        for (int i = 0; i < this.size; i++) {
2372            if (thisBuf[i] == ch) {
2373                return true;
2374            }
2375        }
2376        return false;
2377    }
2378
2379    /**
2380     * Checks if the string builder contains the specified string.
2381     *
2382     * @param str  the string to find
2383     * @return true if the builder contains the string
2384     */
2385    public boolean contains(final String str) {
2386        return indexOf(str, 0) >= 0;
2387    }
2388
2389    /**
2390     * Checks if the string builder contains a string matched using the
2391     * specified matcher.
2392     * <p>
2393     * Matchers can be used to perform advanced searching behaviour.
2394     * For example you could write a matcher to search for the character
2395     * 'a' followed by a number.
2396     *
2397     * @param matcher  the matcher to use, null returns -1
2398     * @return true if the matcher finds a match in the builder
2399     */
2400    public boolean contains(final StrMatcher matcher) {
2401        return indexOf(matcher, 0) >= 0;
2402    }
2403
2404    //-----------------------------------------------------------------------
2405    /**
2406     * Searches the string builder to find the first reference to the specified char.
2407     *
2408     * @param ch  the character to find
2409     * @return the first index of the character, or -1 if not found
2410     */
2411    public int indexOf(final char ch) {
2412        return indexOf(ch, 0);
2413    }
2414
2415    /**
2416     * Searches the string builder to find the first reference to the specified char.
2417     *
2418     * @param ch  the character to find
2419     * @param startIndex  the index to start at, invalid index rounded to edge
2420     * @return the first index of the character, or -1 if not found
2421     */
2422    public int indexOf(final char ch, int startIndex) {
2423        startIndex = (startIndex < 0 ? 0 : startIndex);
2424        if (startIndex >= size) {
2425            return -1;
2426        }
2427        final char[] thisBuf = buffer;
2428        for (int i = startIndex; i < size; i++) {
2429            if (thisBuf[i] == ch) {
2430                return i;
2431            }
2432        }
2433        return -1;
2434    }
2435
2436    /**
2437     * Searches the string builder to find the first reference to the specified string.
2438     * <p>
2439     * Note that a null input string will return -1, whereas the JDK throws an exception.
2440     *
2441     * @param str  the string to find, null returns -1
2442     * @return the first index of the string, or -1 if not found
2443     */
2444    public int indexOf(final String str) {
2445        return indexOf(str, 0);
2446    }
2447
2448    /**
2449     * Searches the string builder to find the first reference to the specified
2450     * string starting searching from the given index.
2451     * <p>
2452     * Note that a null input string will return -1, whereas the JDK throws an exception.
2453     *
2454     * @param str  the string to find, null returns -1
2455     * @param startIndex  the index to start at, invalid index rounded to edge
2456     * @return the first index of the string, or -1 if not found
2457     */
2458    public int indexOf(final String str, int startIndex) {
2459        startIndex = (startIndex < 0 ? 0 : startIndex);
2460        if (str == null || startIndex >= size) {
2461            return -1;
2462        }
2463        final int strLen = str.length();
2464        if (strLen == 1) {
2465            return indexOf(str.charAt(0), startIndex);
2466        }
2467        if (strLen == 0) {
2468            return startIndex;
2469        }
2470        if (strLen > size) {
2471            return -1;
2472        }
2473        final char[] thisBuf = buffer;
2474        final int len = size - strLen + 1;
2475        outer:
2476        for (int i = startIndex; i < len; i++) {
2477            for (int j = 0; j < strLen; j++) {
2478                if (str.charAt(j) != thisBuf[i + j]) {
2479                    continue outer;
2480                }
2481            }
2482            return i;
2483        }
2484        return -1;
2485    }
2486
2487    /**
2488     * Searches the string builder using the matcher to find the first match.
2489     * <p>
2490     * Matchers can be used to perform advanced searching behaviour.
2491     * For example you could write a matcher to find the character 'a'
2492     * followed by a number.
2493     *
2494     * @param matcher  the matcher to use, null returns -1
2495     * @return the first index matched, or -1 if not found
2496     */
2497    public int indexOf(final StrMatcher matcher) {
2498        return indexOf(matcher, 0);
2499    }
2500
2501    /**
2502     * Searches the string builder using the matcher to find the first
2503     * match searching from the given index.
2504     * <p>
2505     * Matchers can be used to perform advanced searching behaviour.
2506     * For example you could write a matcher to find the character 'a'
2507     * followed by a number.
2508     *
2509     * @param matcher  the matcher to use, null returns -1
2510     * @param startIndex  the index to start at, invalid index rounded to edge
2511     * @return the first index matched, or -1 if not found
2512     */
2513    public int indexOf(final StrMatcher matcher, int startIndex) {
2514        startIndex = (startIndex < 0 ? 0 : startIndex);
2515        if (matcher == null || startIndex >= size) {
2516            return -1;
2517        }
2518        final int len = size;
2519        final char[] buf = buffer;
2520        for (int i = startIndex; i < len; i++) {
2521            if (matcher.isMatch(buf, i, startIndex, len) > 0) {
2522                return i;
2523            }
2524        }
2525        return -1;
2526    }
2527
2528    //-----------------------------------------------------------------------
2529    /**
2530     * Searches the string builder to find the last reference to the specified char.
2531     *
2532     * @param ch  the character to find
2533     * @return the last index of the character, or -1 if not found
2534     */
2535    public int lastIndexOf(final char ch) {
2536        return lastIndexOf(ch, size - 1);
2537    }
2538
2539    /**
2540     * Searches the string builder to find the last reference to the specified char.
2541     *
2542     * @param ch  the character to find
2543     * @param startIndex  the index to start at, invalid index rounded to edge
2544     * @return the last index of the character, or -1 if not found
2545     */
2546    public int lastIndexOf(final char ch, int startIndex) {
2547        startIndex = (startIndex >= size ? size - 1 : startIndex);
2548        if (startIndex < 0) {
2549            return -1;
2550        }
2551        for (int i = startIndex; i >= 0; i--) {
2552            if (buffer[i] == ch) {
2553                return i;
2554            }
2555        }
2556        return -1;
2557    }
2558
2559    /**
2560     * Searches the string builder to find the last reference to the specified string.
2561     * <p>
2562     * Note that a null input string will return -1, whereas the JDK throws an exception.
2563     *
2564     * @param str  the string to find, null returns -1
2565     * @return the last index of the string, or -1 if not found
2566     */
2567    public int lastIndexOf(final String str) {
2568        return lastIndexOf(str, size - 1);
2569    }
2570
2571    /**
2572     * Searches the string builder to find the last reference to the specified
2573     * string starting searching from the given index.
2574     * <p>
2575     * Note that a null input string will return -1, whereas the JDK throws an exception.
2576     *
2577     * @param str  the string to find, null returns -1
2578     * @param startIndex  the index to start at, invalid index rounded to edge
2579     * @return the last index of the string, or -1 if not found
2580     */
2581    public int lastIndexOf(final String str, int startIndex) {
2582        startIndex = (startIndex >= size ? size - 1 : startIndex);
2583        if (str == null || startIndex < 0) {
2584            return -1;
2585        }
2586        final int strLen = str.length();
2587        if (strLen > 0 && strLen <= size) {
2588            if (strLen == 1) {
2589                return lastIndexOf(str.charAt(0), startIndex);
2590            }
2591
2592            outer:
2593            for (int i = startIndex - strLen + 1; i >= 0; i--) {
2594                for (int j = 0; j < strLen; j++) {
2595                    if (str.charAt(j) != buffer[i + j]) {
2596                        continue outer;
2597                    }
2598                }
2599                return i;
2600            }
2601
2602        } else if (strLen == 0) {
2603            return startIndex;
2604        }
2605        return -1;
2606    }
2607
2608    /**
2609     * Searches the string builder using the matcher to find the last match.
2610     * <p>
2611     * Matchers can be used to perform advanced searching behaviour.
2612     * For example you could write a matcher to find the character 'a'
2613     * followed by a number.
2614     *
2615     * @param matcher  the matcher to use, null returns -1
2616     * @return the last index matched, or -1 if not found
2617     */
2618    public int lastIndexOf(final StrMatcher matcher) {
2619        return lastIndexOf(matcher, size);
2620    }
2621
2622    /**
2623     * Searches the string builder using the matcher to find the last
2624     * match searching from the given index.
2625     * <p>
2626     * Matchers can be used to perform advanced searching behaviour.
2627     * For example you could write a matcher to find the character 'a'
2628     * followed by a number.
2629     *
2630     * @param matcher  the matcher to use, null returns -1
2631     * @param startIndex  the index to start at, invalid index rounded to edge
2632     * @return the last index matched, or -1 if not found
2633     */
2634    public int lastIndexOf(final StrMatcher matcher, int startIndex) {
2635        startIndex = (startIndex >= size ? size - 1 : startIndex);
2636        if (matcher == null || startIndex < 0) {
2637            return -1;
2638        }
2639        final char[] buf = buffer;
2640        final int endIndex = startIndex + 1;
2641        for (int i = startIndex; i >= 0; i--) {
2642            if (matcher.isMatch(buf, i, 0, endIndex) > 0) {
2643                return i;
2644            }
2645        }
2646        return -1;
2647    }
2648
2649    //-----------------------------------------------------------------------
2650    /**
2651     * Creates a tokenizer that can tokenize the contents of this builder.
2652     * <p>
2653     * This method allows the contents of this builder to be tokenized.
2654     * The tokenizer will be setup by default to tokenize on space, tab,
2655     * newline and formfeed (as per StringTokenizer). These values can be
2656     * changed on the tokenizer class, before retrieving the tokens.
2657     * <p>
2658     * The returned tokenizer is linked to this builder. You may intermix
2659     * calls to the builder and tokenizer within certain limits, however
2660     * there is no synchronization. Once the tokenizer has been used once,
2661     * it must be {@link StrTokenizer#reset() reset} to pickup the latest
2662     * changes in the builder. For example:
2663     * <pre>
2664     * StrBuilder b = new StrBuilder();
2665     * b.append("a b ");
2666     * StrTokenizer t = b.asTokenizer();
2667     * String[] tokens1 = t.getTokenArray();  // returns a,b
2668     * b.append("c d ");
2669     * String[] tokens2 = t.getTokenArray();  // returns a,b (c and d ignored)
2670     * t.reset();              // reset causes builder changes to be picked up
2671     * String[] tokens3 = t.getTokenArray();  // returns a,b,c,d
2672     * </pre>
2673     * In addition to simply intermixing appends and tokenization, you can also
2674     * call the set methods on the tokenizer to alter how it tokenizes. Just
2675     * remember to call reset when you want to pickup builder changes.
2676     * <p>
2677     * Calling {@link StrTokenizer#reset(String)} or {@link StrTokenizer#reset(char[])}
2678     * with a non-null value will break the link with the builder.
2679     *
2680     * @return a tokenizer that is linked to this builder
2681     */
2682    public StrTokenizer asTokenizer() {
2683        return new StrBuilderTokenizer();
2684    }
2685
2686    //-----------------------------------------------------------------------
2687    /**
2688     * Gets the contents of this builder as a Reader.
2689     * <p>
2690     * This method allows the contents of the builder to be read
2691     * using any standard method that expects a Reader.
2692     * <p>
2693     * To use, simply create a <code>StrBuilder</code>, populate it with
2694     * data, call <code>asReader</code>, and then read away.
2695     * <p>
2696     * The internal character array is shared between the builder and the reader.
2697     * This allows you to append to the builder after creating the reader,
2698     * and the changes will be picked up.
2699     * Note however, that no synchronization occurs, so you must perform
2700     * all operations with the builder and the reader in one thread.
2701     * <p>
2702     * The returned reader supports marking, and ignores the flush method.
2703     *
2704     * @return a reader that reads from this builder
2705     */
2706    public Reader asReader() {
2707        return new StrBuilderReader();
2708    }
2709
2710    //-----------------------------------------------------------------------
2711    /**
2712     * Gets this builder as a Writer that can be written to.
2713     * <p>
2714     * This method allows you to populate the contents of the builder
2715     * using any standard method that takes a Writer.
2716     * <p>
2717     * To use, simply create a <code>StrBuilder</code>,
2718     * call <code>asWriter</code>, and populate away. The data is available
2719     * at any time using the methods of the <code>StrBuilder</code>.
2720     * <p>
2721     * The internal character array is shared between the builder and the writer.
2722     * This allows you to intermix calls that append to the builder and
2723     * write using the writer and the changes will be occur correctly.
2724     * Note however, that no synchronization occurs, so you must perform
2725     * all operations with the builder and the writer in one thread.
2726     * <p>
2727     * The returned writer ignores the close and flush methods.
2728     *
2729     * @return a writer that populates this builder
2730     */
2731    public Writer asWriter() {
2732        return new StrBuilderWriter();
2733    }
2734
2735    /**
2736     * Appends current contents of this <code>StrBuilder</code> to the
2737     * provided {@link Appendable}.
2738     * <p>
2739     * This method tries to avoid doing any extra copies of contents.
2740     *
2741     * @param appendable  the appendable to append data to
2742     * @throws IOException  if an I/O error occurs
2743     *
2744     * @since 3.4
2745     * @see #readFrom(Readable)
2746     */
2747    public void appendTo(final Appendable appendable) throws IOException {
2748        if (appendable instanceof Writer) {
2749            ((Writer) appendable).write(buffer, 0, size);
2750        } else if (appendable instanceof StringBuilder) {
2751            ((StringBuilder) appendable).append(buffer, 0, size);
2752        } else if (appendable instanceof StringBuffer) {
2753            ((StringBuffer) appendable).append(buffer, 0, size);
2754        } else if (appendable instanceof CharBuffer) {
2755            ((CharBuffer) appendable).put(buffer, 0, size);
2756        } else {
2757            appendable.append(this);
2758        }
2759    }
2760
2761    /**
2762     * Checks the contents of this builder against another to see if they
2763     * contain the same character content ignoring case.
2764     *
2765     * @param other  the object to check, null returns false
2766     * @return true if the builders contain the same characters in the same order
2767     */
2768    public boolean equalsIgnoreCase(final StrBuilder other) {
2769        if (this == other) {
2770            return true;
2771        }
2772        if (this.size != other.size) {
2773            return false;
2774        }
2775        final char thisBuf[] = this.buffer;
2776        final char otherBuf[] = other.buffer;
2777        for (int i = size - 1; i >= 0; i--) {
2778            final char c1 = thisBuf[i];
2779            final char c2 = otherBuf[i];
2780            if (c1 != c2 && Character.toUpperCase(c1) != Character.toUpperCase(c2)) {
2781                return false;
2782            }
2783        }
2784        return true;
2785    }
2786
2787    /**
2788     * Checks the contents of this builder against another to see if they
2789     * contain the same character content.
2790     *
2791     * @param other  the object to check, null returns false
2792     * @return true if the builders contain the same characters in the same order
2793     */
2794    public boolean equals(final StrBuilder other) {
2795        if (this == other) {
2796            return true;
2797        }
2798        if (other == null) {
2799            return false;
2800        }
2801        if (this.size != other.size) {
2802            return false;
2803        }
2804        final char thisBuf[] = this.buffer;
2805        final char otherBuf[] = other.buffer;
2806        for (int i = size - 1; i >= 0; i--) {
2807            if (thisBuf[i] != otherBuf[i]) {
2808                return false;
2809            }
2810        }
2811        return true;
2812    }
2813
2814    /**
2815     * Checks the contents of this builder against another to see if they
2816     * contain the same character content.
2817     *
2818     * @param obj  the object to check, null returns false
2819     * @return true if the builders contain the same characters in the same order
2820     */
2821    @Override
2822    public boolean equals(final Object obj) {
2823        return obj instanceof StrBuilder && equals((StrBuilder) obj);
2824    }
2825
2826    /**
2827     * Gets a suitable hash code for this builder.
2828     *
2829     * @return a hash code
2830     */
2831    @Override
2832    public int hashCode() {
2833        final char buf[] = buffer;
2834        int hash = 0;
2835        for (int i = size - 1; i >= 0; i--) {
2836            hash = 31 * hash + buf[i];
2837        }
2838        return hash;
2839    }
2840
2841    //-----------------------------------------------------------------------
2842    /**
2843     * Gets a String version of the string builder, creating a new instance
2844     * each time the method is called.
2845     * <p>
2846     * Note that unlike StringBuffer, the string version returned is
2847     * independent of the string builder.
2848     *
2849     * @return the builder as a String
2850     */
2851    @Override
2852    public String toString() {
2853        return new String(buffer, 0, size);
2854    }
2855
2856    /**
2857     * Gets a StringBuffer version of the string builder, creating a
2858     * new instance each time the method is called.
2859     *
2860     * @return the builder as a StringBuffer
2861     */
2862    public StringBuffer toStringBuffer() {
2863        return new StringBuffer(size).append(buffer, 0, size);
2864    }
2865
2866    /**
2867     * Gets a StringBuilder version of the string builder, creating a
2868     * new instance each time the method is called.
2869     *
2870     * @return the builder as a StringBuilder
2871     * @since 3.2
2872     */
2873    public StringBuilder toStringBuilder() {
2874        return new StringBuilder(size).append(buffer, 0, size);
2875    }
2876
2877    /**
2878     * Implement the {@link Builder} interface.
2879     * @return the builder as a String
2880     * @since 3.2
2881     * @see #toString()
2882     */
2883    @Override
2884    public String build() {
2885        return toString();
2886    }
2887
2888    //-----------------------------------------------------------------------
2889    /**
2890     * Validates parameters defining a range of the builder.
2891     *
2892     * @param startIndex  the start index, inclusive, must be valid
2893     * @param endIndex  the end index, exclusive, must be valid except
2894     *  that if too large it is treated as end of string
2895     * @return the new string
2896     * @throws IndexOutOfBoundsException if the index is invalid
2897     */
2898    protected int validateRange(final int startIndex, int endIndex) {
2899        if (startIndex < 0) {
2900            throw new StringIndexOutOfBoundsException(startIndex);
2901        }
2902        if (endIndex > size) {
2903            endIndex = size;
2904        }
2905        if (startIndex > endIndex) {
2906            throw new StringIndexOutOfBoundsException("end < start");
2907        }
2908        return endIndex;
2909    }
2910
2911    /**
2912     * Validates parameters defining a single index in the builder.
2913     *
2914     * @param index  the index, must be valid
2915     * @throws IndexOutOfBoundsException if the index is invalid
2916     */
2917    protected void validateIndex(final int index) {
2918        if (index < 0 || index > size) {
2919            throw new StringIndexOutOfBoundsException(index);
2920        }
2921    }
2922
2923    //-----------------------------------------------------------------------
2924    /**
2925     * Inner class to allow StrBuilder to operate as a tokenizer.
2926     */
2927    class StrBuilderTokenizer extends StrTokenizer {
2928
2929        /**
2930         * Default constructor.
2931         */
2932        StrBuilderTokenizer() {
2933            super();
2934        }
2935
2936        /** {@inheritDoc} */
2937        @Override
2938        protected List<String> tokenize(final char[] chars, final int offset, final int count) {
2939            if (chars == null) {
2940                return super.tokenize(StrBuilder.this.buffer, 0, StrBuilder.this.size());
2941            }
2942            return super.tokenize(chars, offset, count);
2943        }
2944
2945        /** {@inheritDoc} */
2946        @Override
2947        public String getContent() {
2948            final String str = super.getContent();
2949            if (str == null) {
2950                return StrBuilder.this.toString();
2951            }
2952            return str;
2953        }
2954    }
2955
2956    //-----------------------------------------------------------------------
2957    /**
2958     * Inner class to allow StrBuilder to operate as a reader.
2959     */
2960    class StrBuilderReader extends Reader {
2961        /** The current stream position. */
2962        private int pos;
2963        /** The last mark position. */
2964        private int mark;
2965
2966        /**
2967         * Default constructor.
2968         */
2969        StrBuilderReader() {
2970            super();
2971        }
2972
2973        /** {@inheritDoc} */
2974        @Override
2975        public void close() {
2976            // do nothing
2977        }
2978
2979        /** {@inheritDoc} */
2980        @Override
2981        public int read() {
2982            if (ready() == false) {
2983                return -1;
2984            }
2985            return StrBuilder.this.charAt(pos++);
2986        }
2987
2988        /** {@inheritDoc} */
2989        @Override
2990        public int read(final char b[], final int off, int len) {
2991            if (off < 0 || len < 0 || off > b.length ||
2992                    (off + len) > b.length || (off + len) < 0) {
2993                throw new IndexOutOfBoundsException();
2994            }
2995            if (len == 0) {
2996                return 0;
2997            }
2998            if (pos >= StrBuilder.this.size()) {
2999                return -1;
3000            }
3001            if (pos + len > size()) {
3002                len = StrBuilder.this.size() - pos;
3003            }
3004            StrBuilder.this.getChars(pos, pos + len, b, off);
3005            pos += len;
3006            return len;
3007        }
3008
3009        /** {@inheritDoc} */
3010        @Override
3011        public long skip(long n) {
3012            if (pos + n > StrBuilder.this.size()) {
3013                n = StrBuilder.this.size() - pos;
3014            }
3015            if (n < 0) {
3016                return 0;
3017            }
3018            pos += n;
3019            return n;
3020        }
3021
3022        /** {@inheritDoc} */
3023        @Override
3024        public boolean ready() {
3025            return pos < StrBuilder.this.size();
3026        }
3027
3028        /** {@inheritDoc} */
3029        @Override
3030        public boolean markSupported() {
3031            return true;
3032        }
3033
3034        /** {@inheritDoc} */
3035        @Override
3036        public void mark(final int readAheadLimit) {
3037            mark = pos;
3038        }
3039
3040        /** {@inheritDoc} */
3041        @Override
3042        public void reset() {
3043            pos = mark;
3044        }
3045    }
3046
3047    //-----------------------------------------------------------------------
3048    /**
3049     * Inner class to allow StrBuilder to operate as a writer.
3050     */
3051    class StrBuilderWriter extends Writer {
3052
3053        /**
3054         * Default constructor.
3055         */
3056        StrBuilderWriter() {
3057            super();
3058        }
3059
3060        /** {@inheritDoc} */
3061        @Override
3062        public void close() {
3063            // do nothing
3064        }
3065
3066        /** {@inheritDoc} */
3067        @Override
3068        public void flush() {
3069            // do nothing
3070        }
3071
3072        /** {@inheritDoc} */
3073        @Override
3074        public void write(final int c) {
3075            StrBuilder.this.append((char) c);
3076        }
3077
3078        /** {@inheritDoc} */
3079        @Override
3080        public void write(final char[] cbuf) {
3081            StrBuilder.this.append(cbuf);
3082        }
3083
3084        /** {@inheritDoc} */
3085        @Override
3086        public void write(final char[] cbuf, final int off, final int len) {
3087            StrBuilder.this.append(cbuf, off, len);
3088        }
3089
3090        /** {@inheritDoc} */
3091        @Override
3092        public void write(final String str) {
3093            StrBuilder.this.append(str);
3094        }
3095
3096        /** {@inheritDoc} */
3097        @Override
3098        public void write(final String str, final int off, final int len) {
3099            StrBuilder.this.append(str, off, len);
3100        }
3101    }
3102
3103}