net.intelie.liverig.witsml.server.QueryParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of liverig-witsml Show documentation
liverig witsml
The newest version!
package net.intelie.liverig.witsml.server;

import net.intelie.liverig.util.XMLInputFactoryFactory;
import net.intelie.liverig.util.XMLStreamReaderAutoCloseable;
import net.intelie.liverig.witsml.WITSMLException;
import net.intelie.liverig.witsml.objects.ApiVers;

import javax.xml.XMLConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.StringReader;
import java.util.*;

import static javax.xml.stream.XMLStreamConstants.*;
import static net.intelie.liverig.witsml.WITSMLException.PARSE_ERROR;

public class QueryParser {
    private String collection, version;
    private ApiVers apiVers;
    private final List queries = new ArrayList<>();

    public String collection() {
        return collection;
    }

    public String version() {
        return version;
    }

    public ApiVers apiVers() {
        return apiVers;
    }

    public List queries() {
        return queries;
    }

    public void parse(String xml) throws WITSMLException {
        try (XMLStreamReaderAutoCloseable reader = XMLInputFactoryFactory.createXMLStreamReader(new StringReader(xml))) {
            parse(reader.get());
        } catch (XMLStreamException e) {
            throw new WITSMLException(PARSE_ERROR, e);
        }
    }

    private void parse(XMLStreamReader reader) throws XMLStreamException {
        if (collection != null)
            throw new IllegalStateException();

        int level = 0;  // 0 = document, 1 = collection, 2 = object
        Query query = null;
        boolean logCurveInfo = false;
        String mnemonic = null;
        List data = null;
        StringBuilder stringBuilder = null;
        String localName;

        while (reader.hasNext()) {
            reader.next();

            switch (reader.getEventType()) {
                case START_ELEMENT:
                    level++;
                    localName = reader.getLocalName();

                    if (query != null) {
                        if (level == 3)
                            query.requested.add(localName);
                        else if (logCurveInfo && level == 4)
                            query.logCurveInfoRequested.add(localName);
                    }

                    if (level == 1) {
                        collection = localName;
                        version = reader.getAttributeValue(XMLConstants.NULL_NS_URI, "version");
                    } else if (level == 2 && (localName + 's').equals(collection))
                        query = new Query(localName,
                                reader.getAttributeValue(XMLConstants.NULL_NS_URI, "uidWell"),
                                reader.getAttributeValue(XMLConstants.NULL_NS_URI, "uidWellbore"),
                                reader.getAttributeValue(XMLConstants.NULL_NS_URI, "uid"));
                    else if (query != null && level == 3 && ("startIndex".equals(localName) || "endIndex".equals(localName) ||
                            "stepIncrement".equals(localName) ||
                            "startDateTimeIndex".equals(localName) || "endDateTimeIndex".equals(localName))
                            || "indexType".equals(localName))
                        stringBuilder = new StringBuilder();
                    else if (query != null && level == 3 && "logCurveInfo".equals(localName))
                        logCurveInfo = true;
                    else if (logCurveInfo && level == 4 && ("mnemonic".equals(localName) ||
                            "unit".equals(localName) || "columnIndex".equals(localName)))
                        stringBuilder = new StringBuilder();
                    else if (query != null && level == 3 && "logData".equals(localName))
                        data = new ArrayList<>();
                    else if (data != null && level == 4 && ("mnemonicList".equals(localName) || "unitList".equals(localName) ||
                            "data".equals(localName)))
                        stringBuilder = new StringBuilder();

                    if (query != null && level == 3 && "startIndex".equals(localName))
                        query.startIndexUom = reader.getAttributeValue(XMLConstants.NULL_NS_URI, "uom");
                    if (query != null && level == 3 && "endIndex".equals(localName))
                        query.endIndexUom = reader.getAttributeValue(XMLConstants.NULL_NS_URI, "uom");
                    if (query != null && level == 3 && "stepIncrement".equals(localName))
                        query.stepIncrementUom = reader.getAttributeValue(XMLConstants.NULL_NS_URI, "uom");

                    break;
                case END_ELEMENT:
                    localName = reader.getLocalName();

                    if (level == 2 && query != null) {
                        apiVers = ApiVers.findByVersion(version);
                        query.setApiVers(apiVers);
                        queries.add(query);
                        query = null;
                    } else if (level == 3 && query != null && stringBuilder != null) {
                        if ("startIndex".equals(localName))
                            query.startIndex = stringBuilder.toString();
                        else if ("endIndex".equals(localName))
                            query.endIndex = stringBuilder.toString();
                        else if ("stepIncrement".equals(localName))
                            query.stepIncrement = stringBuilder.toString();
                        else if ("startDateTimeIndex".equals(localName))
                            query.startDateTimeIndex = stringBuilder.toString();
                        else if ("endDateTimeIndex".equals(localName))
                            query.endDateTimeIndex = stringBuilder.toString();
                        else if ("indexType".equals(localName))
                            query.indexType = stringBuilder.toString();
                        stringBuilder = null;
                    } else if (level == 3 && query != null && logCurveInfo && "logCurveInfo".equals(localName)) {
                        mnemonic = null;
                        logCurveInfo = false;
                    } else if (level == 4 && query != null && logCurveInfo && stringBuilder != null) {
                        if ("mnemonic".equals(localName))
                            mnemonic = stringBuilder.toString();
                        else if (mnemonic != null && "unit".equals(localName)) {
                            if (query.units == null)
                                query.units = new LinkedHashMap<>();
                            query.units.put(mnemonic, stringBuilder.toString());
                        } else if (mnemonic != null && "columnIndex".equals(localName)) {
                            if (query.columns == null)
                                query.columns = new LinkedHashMap<>();
                            query.columns.put(mnemonic, stringBuilder.toString());
                        }
                        stringBuilder = null;
                    } else if (level == 3 && query != null && data != null && "logData".equals(localName)) {
                        query.data = data;
                        data = null;
                    } else if (level == 4 && query != null && data != null && stringBuilder != null) {
                        if ("mnemonicList".equals(localName))
                            query.mnemonicList = stringBuilder.toString();
                        else if ("unitList".equals(localName))
                            query.unitList = stringBuilder.toString();
                        else if ("data".equals(localName))
                            data.add(stringBuilder.toString());
                        stringBuilder = null;
                    }

                    level--;
                    break;
                case CHARACTERS:
                case CDATA:
                    if (stringBuilder != null)
                        stringBuilder.append(reader.getTextCharacters(), reader.getTextStart(), reader.getTextLength());
                    break;
                case ENTITY_REFERENCE:
                    if (stringBuilder != null)
                        stringBuilder.append(reader.getText());
                    break;
                default:
                    break;
            }
        }

        assert level == 0 && query == null && !logCurveInfo && mnemonic == null && data == null && stringBuilder == null;
    }

    public static class Query {
        private final String object, uidWell, uidWellbore, uid;
        private final Set requested = new HashSet<>(), logCurveInfoRequested = new HashSet<>();
        private String indexType;
        private String startIndex, startIndexUom, endIndex, endIndexUom;
        private String stepIncrement, stepIncrementUom;
        private String startDateTimeIndex, endDateTimeIndex;
        private Map units;
        private Map columns;
        private String mnemonicList, unitList;
        private List data;
        private ApiVers apiVers;
        private String returnElements;

        public Query(String object, String uidWell, String uidWellbore, String uid) {
            this.object = object;
            this.uidWell = uidWell;
            this.uidWellbore = uidWellbore;
            this.uid = uid;
        }

        public String getObject() {
            return object;
        }

        public String getUidWell() {
            return uidWell;
        }

        public String getUidWellbore() {
            return uidWellbore;
        }

        public String getUid() {
            return uid;
        }

        public Set getRequested() {
            return requested;
        }

        public Set getLogCurveInfoRequested() {
            return logCurveInfoRequested;
        }

        public String getStartIndex() {
            return startIndex;
        }

        public void setStartIndex(String startIndex) {
            this.startIndex = startIndex;
        }

        public String getStartIndexUom() {
            return startIndexUom;
        }

        public void setStartIndexUom(String startIndexUom) {
            this.startIndexUom = startIndexUom;
        }

        public String getEndIndex() {
            return endIndex;
        }

        public void setEndIndex(String endIndex) {
            this.endIndex = endIndex;
        }

        public String getEndIndexUom() {
            return endIndexUom;
        }

        public void setEndIndexUom(String endIndexUom) {
            this.endIndexUom = endIndexUom;
        }

        public String getStepIncrement() {
            return stepIncrement;
        }

        public void setStepIncrement(String stepIncrement) {
            this.stepIncrement = stepIncrement;
        }

        public String getStepIncrementUom() {
            return stepIncrementUom;
        }

        public void setStepIncrementUom(String stepIncrementUom) {
            this.stepIncrementUom = stepIncrementUom;
        }

        public String getStartDateTimeIndex() {
            return startDateTimeIndex;
        }

        public void setStartDateTimeIndex(String startDateTimeIndex) {
            this.startDateTimeIndex = startDateTimeIndex;
        }

        public String getEndDateTimeIndex() {
            return endDateTimeIndex;
        }

        public void setEndDateTimeIndex(String endDateTimeIndex) {
            this.endDateTimeIndex = endDateTimeIndex;
        }

        public Map getUnits() {
            return units;
        }

        public void setUnits(Map units) {
            this.units = units;
        }

        public Map getColumns() {
            return columns;
        }

        public void setColumns(Map columns) {
            this.columns = columns;
        }

        public String getMnemonicList() {
            return mnemonicList;
        }

        public void setMnemonicList(String mnemonicList) {
            this.mnemonicList = mnemonicList;
        }

        public String getUnitList() {
            return unitList;
        }

        public void setUnitList(String unitList) {
            this.unitList = unitList;
        }

        public List getData() {
            return data;
        }

        public void setData(List data) {
            this.data = data;
        }

        public String getIndexType() {
            return indexType;
        }

        public void setIndexType(String indexType) {
            this.indexType = indexType;
        }

        public ApiVers getApiVers() {
            return apiVers;
        }

        public void setApiVers(ApiVers apiVers) {
            this.apiVers = apiVers;
        }

        public String getReturnElements() {
            return returnElements;
        }

        public void setReturnElements(String returnElements) {
            this.returnElements = returnElements;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Query query = (Query) o;
            return Objects.equals(object, query.object) &&
                    Objects.equals(uidWell, query.uidWell) &&
                    Objects.equals(uidWellbore, query.uidWellbore) &&
                    Objects.equals(uid, query.uid) &&
                    Objects.equals(requested, query.requested) &&
                    Objects.equals(logCurveInfoRequested, query.logCurveInfoRequested) &&
                    Objects.equals(indexType, query.indexType) &&
                    Objects.equals(startIndex, query.startIndex) &&
                    Objects.equals(startIndexUom, query.startIndexUom) &&
                    Objects.equals(endIndex, query.endIndex) &&
                    Objects.equals(endIndexUom, query.endIndexUom) &&
                    Objects.equals(stepIncrement, query.stepIncrement) &&
                    Objects.equals(stepIncrementUom, query.stepIncrementUom) &&
                    Objects.equals(startDateTimeIndex, query.startDateTimeIndex) &&
                    Objects.equals(endDateTimeIndex, query.endDateTimeIndex) &&
                    Objects.equals(units, query.units) &&
                    Objects.equals(columns, query.columns) &&
                    Objects.equals(mnemonicList, query.mnemonicList) &&
                    Objects.equals(unitList, query.unitList) &&
                    Objects.equals(data, query.data) &&
                    apiVers == query.apiVers &&
                    Objects.equals(returnElements, query.returnElements);
        }

        @Override
        public int hashCode() {
            return Objects.hash(object, uidWell, uidWellbore, uid, requested, logCurveInfoRequested, indexType, startIndex, startIndexUom, endIndex, endIndexUom, stepIncrement, stepIncrementUom, startDateTimeIndex, endDateTimeIndex, units, columns, mnemonicList, unitList, data, apiVers, returnElements);
        }
    }
}