org.simpleframework.util.parse.ParseBuffer Maven / Gradle / Ivy
/*
* ParseBuffer.java February 2001
*
* Copyright (C) 2001, Niall Gallagher
*
* 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.
*
* 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
*/
package org.simpleframework.util.parse;
/**
* This is primarily used to replace the StringBuffer
* class, as a way for the Parser to store the char's
* for a specific region within the parse data that constitutes a
* desired value. The methods are not synchronized so it enables
* the char's to be taken quicker than the
* StringBuffer class.
*
* @author Niall Gallagher
*/
public class ParseBuffer {
/**
* This is used to quicken toString.
*/
protected String cache;
/**
* The char's this buffer accumulated.
*/
protected char[] buf;
/**
* This is the number of char's stored.
*/
protected int count;
/**
* Constructor for ParseBuffer. The default
* ParseBuffer stores 16 char's
* before a resize is needed to accommodate
* extra characters.
*/
public ParseBuffer(){
this(16);
}
/**
* This creates a ParseBuffer with a specific
* default size. The buffer will be created the with the
* length specified. The ParseBuffer can grow
* to accommodate a collection of char's larger
* the the size specified.
*
* @param size initial size of this ParseBuffer
*/
public ParseBuffer(int size){
this.buf = new char[size];
}
/**
* This will add a char to the end of the buffer.
* The buffer will not overflow with repeated uses of the
* append, it uses an ensureCapacity
* method which will allow the buffer to dynamically grow in
* size to accommodate more char's.
*
* @param c the char to be appended
*/
public void append(char c){
ensureCapacity(count+ 1);
buf[count++] = c;
}
/**
* This will add a String to the end of the buffer.
* The buffer will not overflow with repeated uses of the
* append, it uses an ensureCapacity
* method which will allow the buffer to dynamically grow in
* size to accommodate large String objects.
*
* @param text the String to be appended to this
*/
public void append(String text){
ensureCapacity(count+ text.length());
text.getChars(0,text.length(),buf,count);
count += text.length();
}
/**
* This will reset the buffer in such a way that the buffer is
* cleared of all contents and then has the given string appended.
* This is used when a value is to be set into the buffer value.
* See the append(String) method for reference.
*
* @param text this is the text that is to be appended to this
*/
public void reset(String text) {
clear();
append(text);
}
/**
* This will add a ParseBuffer to the end of this.
* The buffer will not overflow with repeated uses of the
* append, it uses an ensureCapacity
* method which will allow the buffer to dynamically grow in
* size to accommodate large ParseBuffer objects.
*
* @param text the ParseBuffer to be appended
*/
public void append(ParseBuffer text){
append(text.buf, 0, text.count);
}
/**
* This will reset the buffer in such a way that the buffer is
* cleared of all contents and then has the given string appended.
* This is used when a value is to be set into the buffer value.
* See the append(ParseBuffer) method for reference.
*
* @param text this is the text that is to be appended to this
*/
public void reset(ParseBuffer text) {
clear();
append(text);
}
/**
* This will add a char to the end of the buffer.
* The buffer will not overflow with repeated uses of the
* append, it uses an ensureCapacity
* method which will allow the buffer to dynamically grow in
* size to accommodate large char arrays.
*
* @param c the char array to be appended to this
* @param off the read offset for the array
* @param len the number of char's to add
*/
public void append(char[] c, int off, int len){
ensureCapacity(count+ len);
System.arraycopy(c,off,buf,count,len);
count+=len;
}
/**
* This will add a String to the end of the buffer.
* The buffer will not overflow with repeated uses of the
* append, it uses an ensureCapacity
* method which will allow the buffer to dynamically grow in
* size to accommodate large String objects.
*
* @param str the String to be appended to this
* @param off the read offset for the String
* @param len the number of char's to add
*/
public void append(String str, int off, int len){
ensureCapacity(count+ len);
str.getChars(off,len,buf,count);
count += len;
}
/**
* This will add a ParseBuffer to the end of this.
* The buffer will not overflow with repeated uses of the
* append, it uses an ensureCapacity
* method which will allow the buffer to dynamically grow in
* size to accommodate large ParseBuffer objects.
*
* @param text the ParseBuffer to be appended
* @param off the read offset for the ParseBuffer
* @param len the number of char's to add
*/
public void append(ParseBuffer text, int off, int len){
append(text.buf, off, len);
}
/**
* This ensure that there is enough space in the buffer to
* allow for more char's to be added. If
* the buffer is already larger than min then the buffer
* will not be expanded at all.
*
* @param min the minimum size needed
*/
protected void ensureCapacity(int min) {
if(buf.length < min) {
int size = buf.length * 2;
int max = Math.max(min, size);
char[] temp = new char[max];
System.arraycopy(buf, 0, temp, 0, count);
buf = temp;
}
}
/**
* This will empty the ParseBuffer so that the
* toString parameter will return null.
* This is used so that the same ParseBuffer can be
* recycled for different tokens.
*/
public void clear(){
cache = null;
count = 0;
}
/**
* This will return the number of bytes that have been appended
* to the ParseBuffer. This will return zero after
* the clear method has been invoked.
*
* @return the number of char's within the buffer
*/
public int length(){
return count;
}
/**
* This will return the characters that have been appended to the
* ParseBuffer as a String object.
* If the String object has been created before then
* a cached String object will be returned. This
* method will return null after clear is invoked.
*
* @return the char's appended as a String
*/
public String toString(){
if(count <= 0) {
return null;
}
if(cache != null) {
return cache;
}
cache = new String(buf,0,count);
return cache;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy