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;
        }
    }

}