com.github.powerlibraries.io.builder.StringOutBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of iopower Show documentation
Power Libraries is a small project to collect some repeatedly needed or otherwise useful Java 8 classes in a collection of tiny libraries. IO Power is the first and really tiny library of the Power Libraries. It contains some simple helper method for opening Input- and Outputstreams. The main purpose of IO Power is to make opening streams, readers and writers less cluttered and simple to understand.
The newest version!
package com.github.powerlibraries.io.builder;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Objects;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

import com.github.powerlibraries.io.IOConfig;
import com.github.powerlibraries.io.builder.targets.StringTarget;
import com.github.powerlibraries.io.helper.stringout.SBDataOutputStream;
import com.github.powerlibraries.io.helper.stringout.SBObjectOutputStream;
import com.github.powerlibraries.io.helper.stringout.SBOutputStream;
import com.github.powerlibraries.io.helper.stringout.SBPrintWriter;
import com.github.powerlibraries.io.helper.stringout.SBWriter;
import com.github.powerlibraries.io.helper.stringout.SBZipOutputStream;

/**
 * This builder is used to create an output chain. In contrast to the normal {@link OutBuilder} this class
 * returns custom writers and streams that allow you to directly access the underlying byte buffer that is 
 * used as a final element in the chain and to directly return strings. 
 * 
 * @see OutBuilder
 * @author Manuel Hegner
 *
 */
public class StringOutBuilder extends BaseOutBuilder {

	private StringTarget target;
	
	public StringOutBuilder() {
		super(new StringTarget(IOConfig.getDefaultCharset()));
		this.target=(StringTarget) super.getTarget();
	}
	
	@Override
	public SBOutputStream asStream() throws IOException {
		return new SBOutputStream(createOutputStream(), target.getLastStream());
	}
	
	@Override
	public SBWriter asWriter() throws IOException {
		return new SBWriter(new OutputStreamWriter(createOutputStream(), getCharset()), target.getLastStream());
	}
	
	@Override
	public SBPrintWriter asPrint() throws IOException {
		return new SBPrintWriter(super.asWriter(), target.getLastStream());
	}
	
	@Override
	public SBObjectOutputStream asObjects() throws IOException {
		return new SBObjectOutputStream(new BufferedOutputStream(createOutputStream()), target.getLastStream());
	}
	
	@Override
	public SBDataOutputStream asData() throws IOException {
		return new SBDataOutputStream(new BufferedOutputStream(createOutputStream()), target.getLastStream());
	}
	
	@Override
	public SBZipOutputStream asZip() throws IOException {
		return new SBZipOutputStream(new BufferedOutputStream(createOutputStream()), target.getLastStream());
	}
	
	
	
	
	//WRITE METHODS THAT RETURN THE BYTE ARRAYS
	/**
	 * This method writes the given Object to the output by calling {@link Objects#toString()}.
	 * @param o the object to write to the output
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String write(Object o) throws IOException {
		try(SBWriter out=this.asWriter()) {
			out.write(Objects.toString(o));
			return out.getResult();
		}
	}
	
	/**
	 * This method writes the given {@link Iterable} to the output by calling {@link Objects#toString()} on each
	 * of the elements and writing them on seperate lines.
	 * @param iterable the {@link Iterable} to write to the output
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String writeLines(Iterable iterable) throws IOException {
		return writeLines(iterable.iterator());
	}
	
	/**
	 * This method writes the given array to the output by calling {@link Objects#toString()} on each
	 * of the elements and writing them on seperate lines.
	 * @param array the array to write to the output
	 * @param  the array element type
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public  String writeLines(T[] array) throws IOException {
		try(SBWriter out=this.asWriter()) {
			for(int i=0;i0)
					out.newLine();
				out.write(Objects.toString(array[i]));
			}
			return out.getResult();
		}
	}
	
	/**
	 * This method writes the given remaining content of the {@link Iterator} to the output by calling 
	 * {@link Objects#toString()} on each of the elements and writing them on seperate lines.
	 * @param iterator the {@link Iterator} to write to the output
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String writeLines(Iterator iterator) throws IOException {
		try(SBWriter out=this.asWriter()) {
			while(iterator.hasNext()) {
				out.write(Objects.toString(iterator.next()));
				if(iterator.hasNext())
					out.newLine();
			}
			return out.getResult();
		}
	}
	
	/**
	 * This method writes the given array from offset to offset+length to the defined {@link OutputStream} and closes it.
	 * @param bytes the byte array to write
	 * @param offset the offset in the byte array
	 * @param length the length of the bytes to write
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 */
	public String writeBytes(byte[] bytes, int offset, int length) throws IOException {
		try(SBOutputStream out = this.asStream()) {
			out.write(bytes, offset, length);
			return out.getResult();
		}
	}
	
	/**
	 * This method writes the given array completely  to the {@link OutputStream} and closes it.
	 * @param bytes the byte array to write
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 */
	public String writeBytes(byte[] bytes) throws IOException {
		return writeBytes(bytes, 0, bytes.length);
	}
	
	/**
	 * This method writes the given XML document to the output. It uses a 
	 * default {@link TransformerFactory} and {@link Transformer}.
	 * @param document the document to write
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @throws TransformerException if an unrecoverable error occurs during the course of the transformation
	 * @return the resulting string
	 */
	public String writeXML(Document document) throws IOException, TransformerException {
		Transformer transformer = TransformerFactory.newInstance().newTransformer();
		return writeXML(document, transformer);
	}
	
	/**
	 * This method writes the given XML document to the output.
	 * @param document the document to write
	 * @param transformer the transformer to use
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @throws TransformerException if an unrecoverable error occurs during the course of the transformation
	 * @return the resulting string
	 */
	public String writeXML(Document document, Transformer transformer) throws IOException, TransformerException {
		try(SBOutputStream out=this.asStream()) {
			transformer.transform(new DOMSource(document), new StreamResult(out));
			return out.getResult();
		}
	}
	
	/**
	 * Copies the content of the given {@link InputStream} to this output
	 * @param in the {@link InputStream} to copy from
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String copyFrom(InputStream in) throws IOException {
		try(SBOutputStream out=this.asStream();
				InputStream input=in;) {
			byte[] buffer = new byte[8192];
			int len = 0;
			while ((len=input.read(buffer)) != -1)
				out.write(buffer, 0, len);
			return out.getResult();
		}
	}
	
	/**
	 * Copies the content of the given {@link Reader} to this output
	 * @param in the {@link Reader} to copy from
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String copyFrom(Reader in) throws IOException {
		try(SBWriter out=this.asWriter();
				Reader input=in;) {
			char[] buffer = new char[4096];
			int len = 0;
			while ((len=input.read(buffer)) != -1)
				out.write(buffer, 0, len);
			return out.getResult();
		}
	}
	
	/**
	 * This method simply writes the given object to the underlying output
	 * using an {@link ObjectOutputStream}.
	 * @param object the object to serialize
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String writeObject(Object object) throws IOException {
		try(SBObjectOutputStream out=this.asObjects()) {
			out.writeObject(object);
			return out.getResult();
		}
	}
	
	/**
	 * This method writes the given objects to the underlying output
	 * using an {@link ObjectOutputStream}. It does this by simply calling
	 * {@link ObjectOutputStream#writeObject(Object)} with each given object.
	 * @param objects the objects to serialize
	 * @throws IOException if any element of the chain throws an {@link IOException}
	 * @return the resulting string
	 */
	public String writeObjects(Object... objects) throws IOException {
		try(SBObjectOutputStream out=this.asObjects()) {
			out.writeInt(objects.length);
			for(Object o:objects) {
				try {
					out.writeObject(o);
				} catch(IOException e) {
					throw new IOException("Error while trying to serialize object "+Objects.toString(o), e);
				}
			}
			return out.getResult();
		}
	}
	
	@Override
	protected void setCharset(Charset charset) {
		super.setCharset(charset);
		target.getLastStream().setCharset(charset);
	}
}