org.simpleframework.xml.stream.OutputBuffer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of simple-xml Show documentation
Simple is a high performance XML serialization and configuration framework for Java
The newest version!
/*
 * OutputBuffer.java June 2007
 *
 * Copyright (C) 2007, Niall Gallagher 
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
 * implied. See the License for the specific language governing 
 * permissions and limitations under the License.
 */
 
package org.simpleframework.xml.stream;

import java.io.IOException;
import java.io.Writer;

/** 
 * This is primarily used to replace the StringBuffer 
 * class, as a way for the Formatter to store the start
 * tag for an XML element. This enables the start tag of the current
 * element to be removed without disrupting any of the other nodes
 * within the document. Once the contents of the output buffer have
 * been filled its contents can be emitted to the writer object.
 *
 * @author Niall Gallagher
 */
class OutputBuffer {      

   /** 
    * The characters that this buffer has accumulated.
    */
   private StringBuilder text;
   
   /** 
    * Constructor for OutputBuffer. The default 
    * OutputBuffer stores 16 characters before a
    * resize is needed to append extra characters. 
    */
   public OutputBuffer() {
      this.text = new StringBuilder();     
   }
   
   /** 
    * 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 characters.
    *
    * @param ch the character to be appended to the buffer
    */
   public void append(char ch){
      text.append(ch);
   }

   /** 
    * 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 value the string to be appended to this output buffer
    */  
   public void append(String value){
      text.append(value);
   }
   
   /** 
    * This will add a char array to 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 character arrays.
    *
    * @param value the character array to be appended to this
    */   
   public void append(char[] value){
      text.append(value, 0, value.length);
   }
   
   /** 
    * This will add a char array to 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 character arrays.
    *
    * @param value the character array to be appended to this
    * @param off the read offset for the array to begin reading
    * @param len the number of characters to append to this
    */   
   public void append(char[] value, int off, int len){
      text.append(value, off, 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 value the string to be appended to the output buffer
    * @param off the offset to begin reading from the string
    * @param len the number of characters to append to this
    */   
   public void append(String value, int off, int len){
      text.append(value, off, len);
   }
   
   /**
    * This method is used to write the contents of the buffer to the
    * specified Writer object. This is used when the
    * XML element is to be committed to the resulting XML document.
    * 
    * @param out this is the writer to write the buffered text to
    * 
    * @throws IOException thrown if there is an I/O problem
    */
   public void write(Writer out) throws IOException {
      out.append(text);      
   }
   
   /** 
    * This will empty the OutputBuffer so that it does
    * not contain any content. This is used to that when the buffer
    * is written to a specified Writer object nothing
    * is written out. This allows XML elements to be removed.
    */
   public void clear(){     
      text.setLength(0);
   }
}