LegacyConverter.java

package gov.usgs.earthquake.eids;

import java.io.InputStream;
import java.util.Map;

import gov.usgs.earthquake.cube.CubeMessage;
import gov.usgs.earthquake.event.Converter;
import gov.usgs.earthquake.product.Content;
import gov.usgs.earthquake.product.Product;
import gov.usgs.util.StreamUtils;

import org.quakeml_1_2.Quakeml;
import gov.usgs.ansseqmsg.EQMessage;

/**
 * Utility class to translate between Quakeml, EQXML, and CUBE formats.
 */
public class LegacyConverter {

	/** Different format types */
	public static enum Format {
		/** Enum for Cube Format */
		CUBE,
		/** Enum for EQXML Format */
		EQXML,
		/** Enum for QUAKEML Format */
		QUAKEML
	};

	/** Cube Format */
	public static final Format CUBE = Format.CUBE;
	/** EQXML Format */
	public static final Format EQXML = Format.EQXML;
	/** QUAKEML Format */
	public static final Format QUAKEML = Format.QUAKEML;

	/** Path to EQXML content */
	public static final String EQXML_CONTENT_PATH = "eqxml.xml";
	/** Path to Quakeml content */
	public static final String QUAKEML_CONTENT_PATH = "quakeml.xml";

	private final Format outputFormat;
	private final Converter converter;

	/**
	 * Constructor
	 * @param outputFormat format you want to switch to
	 */
	public LegacyConverter(final Format outputFormat) {
		this.outputFormat = outputFormat;
		this.converter = new Converter();
	}

	/**
	 * @return converter that outputs cube.
	 */
	public static LegacyConverter cubeConverter() {
		return new LegacyConverter(CUBE);
	}

	/**
	 * @return converter that outputs eqxml.
	 */
	public static LegacyConverter eqxmlConverter() {
		return new LegacyConverter(EQXML);
	}

	/**
	 * @return converter that outputs quakeml.
	 */
	public static LegacyConverter quakemlConverter() {
		return new LegacyConverter(QUAKEML);
	}

	/**
	 * Handles conversion from a product containing either eqxml or quakeml
	 * contents to either eqxml, quakeml, or cube byte array.
	 *
	 * @param product
	 *            the product object to convert.
	 * @return byte array containing the output format, or null if unable to
	 *         convert.
	 * @throws Exception if error occurs
	 */
	public byte[] convert(final Product product) throws Exception {
		Map<String, Content> contents = product.getContents();
		InputStream input = null;
		try {
			if (contents.containsKey(QUAKEML_CONTENT_PATH)) {
				input = contents.get(QUAKEML_CONTENT_PATH).getInputStream();
				return convert(converter.getQuakeml(input));
			} else if (contents.containsKey(EQXML_CONTENT_PATH)) {
				input = contents.get(EQXML_CONTENT_PATH).getInputStream();
				return convert(converter.getEQMessage(input));
			} else {
				// unable to convert
				return null;
			}
		} finally {
			StreamUtils.closeStream(input);
		}
	}

	/**
	 * Handles conversion from an eqxml to either eqxml, quakeml, or cube byte
	 * array.
	 *
	 * @param eqxml
	 *            the eqxml object to convert.
	 * @return byte array containing output format, or null if unable to
	 *         convert.
	 * @throws Exception if error occurs
	 */
	public byte[] convert(EQMessage eqxml) throws Exception {
		if (eqxml == null) {
			return null;
		}
		try {
			if (outputFormat == EQXML) {
				return converter.getString(eqxml).getBytes();
			} else if (outputFormat == CUBE) {
				return converter.getString(converter.getCubeMessage(eqxml))
						.getBytes();
			} else if (outputFormat == QUAKEML) {
				return converter.getString(converter.getQuakeml(eqxml))
						.getBytes();
			} else {
				return null;
			}
		} catch (NullPointerException npe) {
			return null;
		}
	}

	/**
	 * Handles conversion from a quakeml message to either eqxml, quakeml, or
	 * cube byte array.
	 *
	 * @param quakeml
	 *            the quakeml object to convert.
	 * @return byte array containing output format, or null if unable to
	 *         convert.
	 * @throws Exception if error occurs
	 */
	public byte[] convert(Quakeml quakeml) throws Exception {
		if (quakeml == null) {
			return null;
		}
		try {
			if (outputFormat == EQXML) {
				return converter.getString(converter.getEQMessage(quakeml))
						.getBytes();
			} else if (outputFormat == CUBE) {
				return converter.getString(converter.getCubeMessage(quakeml))
						.getBytes();
			} else if (outputFormat == QUAKEML) {
				return converter.getString(quakeml).getBytes();
			} else {
				return null;
			}
		} catch (NullPointerException npe) {
			return null;
		}
	}

	/**
	 * Handles conversion from a cube message to either eqxml, quakeml, or cube
	 * byte array.
	 *
	 * @param cube
	 *            the cube object to convert.
	 * @return byte array containing output format, or null if unable to
	 *         convert.
	 * @throws Exception if error occurs
	 */
	public byte[] convert(CubeMessage cube) throws Exception {
		if (cube == null) {
			return null;
		}
		try {
			if (outputFormat == EQXML) {
				return converter.getString(converter.getEQMessage(cube))
						.getBytes();
			} else if (outputFormat == CUBE) {
				return converter.getString(cube).getBytes();
			} else if (outputFormat == QUAKEML) {
				return converter.getString(converter.getQuakeml(cube))
						.getBytes();
			} else {
				return null;
			}
		} catch (NullPointerException npe) {
			return null;
		}
	}

}