com.hfg.util.StringBuilderPlus Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of com_hfg Show documentation
Show all versions of com_hfg Show documentation
com.hfg xml, html, svg, and bioinformatics utility library
package com.hfg.util;
import java.io.IOException;
import java.io.OutputStream;
//------------------------------------------------------------------------------
/**
* A StringBuilder with extra functionality [delimtedAppend(), printf(), appendln(),
* replaceAll(), and carriage return support].
*
* @author J. Alex Taylor, hairyfatguy.com
*/
//------------------------------------------------------------------------------
// com.hfg XML/HTML Coding Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// [email protected]
//------------------------------------------------------------------------------
// Can't extend StringBuilder since it is is a final class so we just have to wrap it.
public class StringBuilderPlus extends OutputStream implements CharSequence
{
private StringBuilder mBuffer;
private String mDelimiter = sDefaultDelimiter;
private String mLineSeparator = sDefaultLineSeparator;
private boolean mCarriageReturnEnabled;
private static String sDefaultDelimiter = ", ";
private static String sDefaultLineSeparator = System.getProperty("line.separator");
//##########################################################################
// CONSTRUCTORS
//##########################################################################
//--------------------------------------------------------------------------
public StringBuilderPlus()
{
mBuffer = new StringBuilder();
}
//--------------------------------------------------------------------------
public StringBuilderPlus(int inSize)
{
mBuffer = new StringBuilder(inSize);
}
//--------------------------------------------------------------------------
public StringBuilderPlus(CharSequence inContent)
{
mBuffer = new StringBuilder();
if (inContent != null)
{
mBuffer.append(inContent);
}
}
//##########################################################################
// PUBLIC METHODS
//##########################################################################
//--------------------------------------------------------------------------
/**
Sets an override for the default line separator of System.getProperty("line.separator").
*/
public static void setDefaultLineSeparator(String inValue)
{
sDefaultLineSeparator = inValue;
}
//--------------------------------------------------------------------------
public static void setDefaultDelimiter(String inValue)
{
sDefaultDelimiter = inValue;
}
//--------------------------------------------------------------------------
public StringBuilderPlus setLineSeparator(String inValue)
{
mLineSeparator = inValue;
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus setDelimiter(String inValue)
{
mDelimiter = inValue;
return this;
}
//--------------------------------------------------------------------------
public String getDelimiter()
{
return mDelimiter;
}
//--------------------------------------------------------------------------
public void moveCharAt(int inFromIndex, int intToIndex)
{
char charToMove = mBuffer.charAt(inFromIndex);
mBuffer.insert(inFromIndex < intToIndex ? intToIndex + 1 : intToIndex, charToMove);
mBuffer.deleteCharAt(inFromIndex < intToIndex ? inFromIndex : inFromIndex + 1);
}
//--------------------------------------------------------------------------
public StringBuilderPlus replaceAll(Character inTarget, Character inReplacement)
{
return replaceAll(inTarget + "", inReplacement != null ? inReplacement + "" : null);
}
//--------------------------------------------------------------------------
public StringBuilderPlus replaceAll(CharSequence inTarget, Character inReplacement)
{
return replaceAll(inTarget, inReplacement != null ? inReplacement + "" : null);
}
//--------------------------------------------------------------------------
public StringBuilderPlus replaceAll(Character inTarget, CharSequence inReplacement)
{
return replaceAll(inTarget + "", inReplacement);
}
//--------------------------------------------------------------------------
public StringBuilderPlus replaceAll(CharSequence inTarget, CharSequence inReplacement)
{
String replacement = inReplacement != null ? inReplacement + "" : "";
int index;
int fromIndex = 0;
while ((index = indexOf(inTarget + "", fromIndex)) >= 0)
{
replace(index, index + inTarget.length(), replacement);
fromIndex = index + replacement.length();
}
return this;
}
//--------------------------------------------------------------------------
/**
Causes any '\r' characters to be immediately interpreted as carriage returns.
* @return this StringBuilderPlus object to allow method chaining.
*/
public StringBuilderPlus enableCarriageReturnSupport()
{
mCarriageReturnEnabled = true;
// Process any pre-existing carriage returns
if (length() > 0
&& indexOf("\r") >= 0)
{
processAddedContentForCarriageReturns(toString());
}
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus disableCarriageReturnSupport()
{
mCarriageReturnEnabled = false;
return this;
}
//--------------------------------------------------------------------------
public boolean startsWith(String inValue)
{
return toString().startsWith(inValue);
}
//--------------------------------------------------------------------------
public boolean endsWith(String inValue)
{
return toString().endsWith(inValue);
}
// OutputStream methods
//--------------------------------------------------------------------------
@Override
public void write(int inByte)
throws IOException
{
append((char) inByte);
}
//--------------------------------------------------------------------------
@Override
public void write(byte inBytes[], int inOffset, int inLength)
{
append(new String(inBytes, inOffset, inLength));
}
//--------------------------------------------------------------------------
@Override
public void write(byte inBytes[])
{
append(new String(inBytes));
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(CharSequence inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(char inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(int inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(long inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(float inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(double inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delimitedAppend(Object inContent)
{
delimitIfNecessary();
append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus printf(String inFormatString, Object... inArgs)
{
return append(String.format(inFormatString, inArgs));
}
//--------------------------------------------------------------------------
public StringBuilderPlus appendln(CharSequence inContent)
{
append(inContent);
return appendln();
}
//--------------------------------------------------------------------------
public StringBuilderPlus appendln()
{
mBuffer.append(mLineSeparator);
return this;
}
// Methods from StringBuilder:
//--------------------------------------------------------------------------
public StringBuilderPlus append(Object inObj)
{
mBuffer.append(inObj);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(CharSequence inContent)
{
CharSequence content = inContent;
if (mCarriageReturnEnabled
&& inContent != null
&& inContent.toString().contains("\r"))
{
content = processAddedContentForCarriageReturns(inContent);
if (content.charAt(0) == '\r')
{
int lastLineFeedIndex = lastIndexOf("\n");
replace(lastLineFeedIndex + 1, length(), "");
// Remove the '\r' from the beginning of the added content
content = content.subSequence(1, content.length());
}
}
mBuffer.append(content);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(CharSequence inContent, int inStart, int inEnd)
{
mBuffer.append(inContent, inStart, inEnd);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(char[] inContent)
{
mBuffer.append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(char[] inContent, int inOffset, int inLen)
{
mBuffer.append(inContent, inOffset, inLen);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(boolean inContent)
{
mBuffer.append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(char inContent)
{
if (mCarriageReturnEnabled
&& inContent == '\r')
{
append(inContent + "");
}
else
{
mBuffer.append(inContent);
}
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(int inContent)
{
mBuffer.append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(long inContent)
{
mBuffer.append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(float inContent)
{
mBuffer.append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus append(double inContent)
{
mBuffer.append(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus appendCodePoint(int inContent)
{
mBuffer.appendCodePoint(inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus delete(int inStart, int inEnd)
{
mBuffer.delete(inStart, inEnd);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus deleteCharAt(int inIndex)
{
mBuffer.deleteCharAt(inIndex);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus replace(int inStart, int inEnd, String inReplacement)
{
mBuffer.replace(inStart, inEnd, inReplacement);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, char[] inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, char[] inContent, int inOffset, int inLen)
{
mBuffer.insert(inIndex, inContent, inOffset, inLen);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, Object inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, CharSequence inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, CharSequence inContent, int inStart, int inEnd)
{
mBuffer.insert(inIndex, inContent, inStart, inEnd);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, boolean inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, char inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, int inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, long inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, float inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus insert(int inIndex, double inContent)
{
mBuffer.insert(inIndex, inContent);
return this;
}
//--------------------------------------------------------------------------
public int indexOf(String inString)
{
return mBuffer.indexOf(inString);
}
//--------------------------------------------------------------------------
public int indexOf(String inString, int inFromIndex)
{
return mBuffer.indexOf(inString, inFromIndex);
}
//--------------------------------------------------------------------------
public int lastIndexOf(String inString)
{
return mBuffer.lastIndexOf(inString);
}
//--------------------------------------------------------------------------
public int lastIndexOf(String inString, int inFromIndex)
{
return mBuffer.lastIndexOf(inString, inFromIndex);
}
//--------------------------------------------------------------------------
public StringBuilderPlus reverse()
{
mBuffer.reverse();
return this;
}
//--------------------------------------------------------------------------
@Override
public String toString()
{
return mBuffer.toString();
}
//--------------------------------------------------------------------------
public int length()
{
return mBuffer.length();
}
//--------------------------------------------------------------------------
public int capacity()
{
return mBuffer.capacity();
}
//--------------------------------------------------------------------------
public StringBuilderPlus ensureCapacity(int inMinimumCapacity)
{
mBuffer.ensureCapacity(inMinimumCapacity);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus trimToSize()
{
mBuffer.trimToSize();
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus setLength(int inNewLength)
{
mBuffer.setLength(inNewLength);
return this;
}
//--------------------------------------------------------------------------
public char charAt(int inIndex)
{
return mBuffer.charAt(inIndex);
}
//--------------------------------------------------------------------------
public int codePointAt(int inIndex)
{
return mBuffer.codePointAt(inIndex);
}
//--------------------------------------------------------------------------
public int codePointBefore(int inIndex)
{
return mBuffer.codePointBefore(inIndex);
}
//--------------------------------------------------------------------------
public int codePointCount(int inBeginIndex, int inEndIndex)
{
return mBuffer.codePointCount(inBeginIndex, inEndIndex);
}
//--------------------------------------------------------------------------
public int offsetByCodePoints(int inIndex, int inCodePointOffset)
{
return mBuffer.offsetByCodePoints(inIndex, inCodePointOffset);
}
//--------------------------------------------------------------------------
public StringBuilderPlus getChars(int inSrcBegin, int inSrcEnd, char[] inDest, int inDestBegin)
{
mBuffer.getChars(inSrcBegin, inSrcEnd, inDest, inDestBegin);
return this;
}
//--------------------------------------------------------------------------
public StringBuilderPlus setCharAt(int inIndex, char inChar)
{
mBuffer.setCharAt(inIndex, inChar);
return this;
}
//--------------------------------------------------------------------------
public String substring(int inStart)
{
return mBuffer.substring(inStart);
}
//--------------------------------------------------------------------------
public String substring(int inStart, int inEnd)
{
return mBuffer.substring(inStart, inEnd);
}
//--------------------------------------------------------------------------
public CharSequence subSequence(int inStart, int inEnd)
{
return mBuffer.subSequence(inStart, inEnd);
}
//##########################################################################
// PRIVATE METHODS
//##########################################################################
//--------------------------------------------------------------------------
private void delimitIfNecessary()
{
if (length() > 0)
{
append(mDelimiter);
}
}
//--------------------------------------------------------------------------
private CharSequence processAddedContentForCarriageReturns(CharSequence inContent)
{
StringBuilderPlus buffer = new StringBuilderPlus(inContent);
int index = buffer.indexOf("\r", 1);
while (index > 0)
{
int lastLineFeedIndex = buffer.substring(0, index).lastIndexOf('\n');
buffer.replace(lastLineFeedIndex + 1, index + (lastLineFeedIndex < 0 ? 0 : 1), "");
index = buffer.indexOf("\r", lastLineFeedIndex);
}
return buffer;
}
}