cdc.applic.mountability.impl.io.DataXml Maven / Gradle / Ivy

Go to download
package cdc.applic.mountability.impl.io;

import java.io.IOException;

import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;

import cdc.applic.expressions.Expression;
import cdc.applic.expressions.Formatting;
import cdc.applic.mountability.Interchangeability;
import cdc.applic.mountability.impl.Data;
import cdc.applic.mountability.impl.UsePoint;
import cdc.applic.mountability.impl.Variant;
import cdc.applic.publication.ExpressionFormatter;
import cdc.io.xml.AbstractStAXLoader;
import cdc.io.xml.AbstractStAXParser;
import cdc.io.xml.XmlWriter;
import cdc.util.lang.FailureReaction;

public final class DataXml {
    private static final String MOUNTABILITY_DATA = "mountability-data";
    private static final String USE_POINT = "use-point";
    private static final String VARIANT = "variant";
    private static final String ID = "id";
    private static final String INTERCHANGEABILITY = "interchangeability";
    private static final String APPLICABILITY = "applicability";
    private static final String MOUNTABILITY = "mountability";
    private static final String FORMATTED_MOUNTABILITY = "formatted-mountability";

    private DataXml() {
    }

    public static class Printer {
        private Formatting formatting = Formatting.LONG_NARROW;
        private ExpressionFormatter formatter = null;

        public Printer() {
            super();
        }

        public Printer setFormatting(Formatting formatting) {
            this.formatting = formatting;
            return this;
        }

        public Printer setFormatter(ExpressionFormatter formatter) {
            this.formatter = formatter;
            return this;
        }

        public void write(XmlWriter writer,
                          Data data) throws IOException {
            final String namespace = "https://www.gitlab.com/cdc-java";
            final String schema = "https://www.gitlab.com/cdc-java/applic-mountability.xsd";
            writer.beginDocument();
            writer.beginElement(MOUNTABILITY_DATA);
            writer.addDefaultNamespace(namespace);
            writer.addNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance");
            writer.addAttribute("xsi:schemaLocation", namespace + " " + schema);

            for (final UsePoint usePoint : data.getUsePoints()) {
                writeUsePoint(writer, usePoint);
            }

            writer.endElement();
            writer.endDocument();
        }

        private void writeUsePoint(XmlWriter writer,
                                   UsePoint usePoint) throws IOException {
            writer.beginElement(USE_POINT);
            if (usePoint.getId() != null) {
                writer.addAttribute(ID, usePoint.getId());
            }
            for (final Variant variant : usePoint.getVariants()) {
                writeVariant(writer, variant);
            }
            writer.endElement();
        }

        private void writeVariant(XmlWriter writer,
                                  Variant variant) throws IOException {
            writer.beginElement(VARIANT);
            if (variant.getId() != null) {
                writer.addAttribute(ID, variant.getId());
            }
            if (variant.getInterchangeability() != null) {
                writer.addAttribute(INTERCHANGEABILITY, variant.getInterchangeability());
            }
            writer.addAttribute(APPLICABILITY, variant.getApplicability());
            if (variant.getMountability() != null) {
                writer.addAttribute(MOUNTABILITY, variant.getMountability().toInfix(formatting));
                if (formatter != null) {
                    writer.addAttribute(FORMATTED_MOUNTABILITY, formatter.formatAsString(variant.getMountability()));
                }
            }
            writer.endElement();
        }
    }

    public static class StAXLoader extends AbstractStAXLoader {
        public StAXLoader(FailureReaction reaction) {
            super((reader,
                   systemId) -> new Parser(reader, systemId, reaction));
        }

        private static class Parser extends AbstractStAXParser {
            protected Parser(XMLStreamReader reader,
                             String systemId,
                             FailureReaction reaction) {
                super(reader, systemId, reaction);
            }

            @Override
            protected Data parse() throws XMLStreamException {
                trace("parse()");
                // Move to root start tag
                nextTag();

                if (isStartElement(MOUNTABILITY_DATA)) {
                    final Data result = parseMountabilityData();
                    next();
                    return result;
                } else {
                    throw unexpectedEvent();
                }
            }

            private Data parseMountabilityData() throws XMLStreamException {
                trace("parseMountabilityData()");
                final Data data = new Data();
                nextTag();
                while (isStartElement(USE_POINT)) {
                    parseUsePoint(data);
                    nextTag();
                }
                return data;
            }

            private void parseUsePoint(Data data) throws XMLStreamException {
                trace("parseUsePoint()");
                expectStartElement("parseUsePoint()", USE_POINT);
                final String id = getAttributeValue(ID, null);
                final UsePoint usePoint = new UsePoint(id);
                nextTag();
                while (isStartElement(VARIANT)) {
                    parseVariant(usePoint);
                    nextTag();
                }
                expectEndElement("parseUsePoint()", USE_POINT);

                data.addUsePoint(usePoint);
            }

            private void parseVariant(UsePoint usePoint) throws XMLStreamException {
                trace("parseVariant()");
                expectStartElement("parseVariant()", VARIANT);
                final String id = getAttributeValue(ID, null);
                final Interchangeability interchangeability =
                        getAttributeAsEnum(INTERCHANGEABILITY, Interchangeability.class, null);
                final String applicability = getAttributeValue(APPLICABILITY, null);
                final String mountability = getAttributeValue(MOUNTABILITY, null);
                nextTag();
                expectEndElement("parseVariant()", VARIANT);

                usePoint.addVariant(id,
                                    interchangeability,
                                    new Expression(applicability),
                                    mountability == null ? null : new Expression(mountability));
            }
        }
    }
}