Added FCSAndQuery serialization.
Change-Id: I5a1bc12a5e308a6ae6a040f6492a0d479da7aceb
diff --git a/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/FCSSRUQueryParser.java b/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/FCSSRUQueryParser.java
new file mode 100644
index 0000000..1ca4edd
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/FCSSRUQueryParser.java
@@ -0,0 +1,217 @@
+package de.ids_mannheim.korap.query.parse.fcsql;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+
+import de.ids_mannheim.korap.query.parse.fcsql.KoralSequence.Distance;
+import de.ids_mannheim.korap.query.serialize.FCSQLQueryProcessor;
+import de.ids_mannheim.korap.query.serialize.util.StatusCodes;
+import eu.clarin.sru.server.fcs.parser.Expression;
+import eu.clarin.sru.server.fcs.parser.ExpressionAnd;
+import eu.clarin.sru.server.fcs.parser.Operator;
+import eu.clarin.sru.server.fcs.parser.QueryNode;
+import eu.clarin.sru.server.fcs.parser.QuerySegment;
+import eu.clarin.sru.server.fcs.parser.RegexFlag;
+
+public class FCSSRUQueryParser {
+
+ private static final String FOUNDRY_CNX = "cnx";
+ private static final String FOUNDRY_OPENNLP = "opennlp";
+ private static final String FOUNDRY_TT = "tt";
+ private static final String FOUNDRY_MATE = "mate";
+ private static final String FOUNDRY_XIP = "xip";
+
+ private List<String> supportedFoundries = Arrays
+ .asList(new String[] { FOUNDRY_CNX, FOUNDRY_OPENNLP, FOUNDRY_TT,
+ FOUNDRY_MATE, FOUNDRY_XIP });
+
+ private FCSQLQueryProcessor processor;
+
+ public FCSSRUQueryParser (FCSQLQueryProcessor processor) {
+ this.processor = processor;
+ }
+
+ public Object parseQueryNode(QueryNode queryNode) {
+
+ if (queryNode instanceof QuerySegment) {
+ return parseQuerySegment((QuerySegment) queryNode);
+ // } else if (queryNode instanceof QueryGroup) {
+ //
+ // } else if (queryNode instanceof QuerySequence) {
+ //
+ // } else if (queryNode instanceof QueryDisjunction) {
+ //
+ // } else if (queryNode instanceof QueryWithWithin) {
+
+ }
+ else {
+ processor.addError(StatusCodes.QUERY_TOO_COMPLEX,
+ "FCS diagnostic 11:" + queryNode.getNodeType().name()
+ + " is currently unsupported.");
+ return null;
+ }
+ }
+
+ private Object parseQuerySegment(QuerySegment segment) {
+ if ((segment.getMinOccurs() == 1) && (segment.getMaxOccurs() == 1)) {
+ return parseExpression(segment.getExpression());
+ }
+ else {
+ processor.addError(StatusCodes.QUERY_TOO_COMPLEX,
+ "FCS diagnostic 11: Query is too complex.");
+ return null;
+ }
+ }
+
+ private Object parseExpression(QueryNode queryNode) {
+ if (queryNode instanceof Expression) {
+ Expression expression = (Expression) queryNode;
+ return parseSimpleExpression(expression);
+ }
+ else if (queryNode instanceof ExpressionAnd) {
+ ExpressionAnd expressionAnd = (ExpressionAnd) queryNode;
+ return parseExpressionAnd(expressionAnd);
+ }
+ // else if (queryNode instanceof ExpressionGroup) {
+ //
+ // }
+ // else if (queryNode instanceof ExpressionNot) {
+ //
+ // }
+ // else if (queryNode instanceof ExpressionOr) {
+ //
+ // }
+ // else if (queryNode instanceof ExpressionWildcard) {
+ //
+ // }
+ else {
+ processor.addError(StatusCodes.QUERY_TOO_COMPLEX,
+ "FCS diagnostic 11: Query is too complex.");
+ return null;
+ }
+ }
+
+ private Object parseExpressionAnd(ExpressionAnd expressionAnd) {
+ KoralSequence koralSequence = new KoralSequence();
+ List<Object> operands = new ArrayList<Object>();
+ for (QueryNode child : expressionAnd.getChildren()) {
+ operands.add(parseExpression(child));
+ }
+
+ List<Distance> distances = new ArrayList<Distance>();
+ Distance d = koralSequence.new Distance("s", 0, 0);
+ distances.add(d);
+
+ koralSequence.setOperands(operands);
+ koralSequence.setDistances(distances);
+ return koralSequence;
+ }
+
+ private Object parseSimpleExpression(Expression expression) {
+ KoralTerm koralTerm = new KoralTerm();
+ koralTerm.setQueryTerm(expression.getRegexValue());
+ parseLayerIdentifier(koralTerm, expression.getLayerIdentifier());
+ parseQualifier(koralTerm, expression.getLayerQualifier());
+ parseOperator(koralTerm, expression.getOperator());
+ parseRegexFlags(koralTerm, expression.getRegexFlags());
+ return koralTerm;
+ }
+
+ private void parseLayerIdentifier(KoralTerm koralTerm, String identifier) {
+ String layer = null;
+ if (identifier == null) {
+ processor.addError(StatusCodes.MALFORMED_QUERY,
+ "FCS diagnostic 10: Layer identifier is missing.");
+ koralTerm.setInvalid(true);
+ }
+ else if (identifier.equals("text")) {
+ layer = "orth";
+ }
+ else if (identifier.equals("pos")) {
+ layer = "p";
+ }
+ else if (identifier.equals("lemma")) {
+ layer = "l";
+ }
+ else {
+ processor.addError(StatusCodes.UNKNOWN_QUERY_ELEMENT,
+ "SRU diagnostic 48: Layer " + identifier
+ + " is unsupported.");
+ koralTerm.setInvalid(true);
+ }
+
+ koralTerm.setLayer(layer);
+ }
+
+ private void parseQualifier(KoralTerm koralTerm, String qualifier) {
+ String layer = koralTerm.getLayer();
+ if (layer == null) {
+ koralTerm.setInvalid(true);
+ return;
+ }
+ // Set default foundry
+ if (qualifier == null) {
+ if (layer.equals("orth")) {
+ qualifier = FOUNDRY_OPENNLP;
+ }
+ else {
+ qualifier = FOUNDRY_TT;
+ }
+ }
+ else if (qualifier.equals(FOUNDRY_OPENNLP) && layer.equals("l")) {
+ processor
+ .addError(StatusCodes.UNKNOWN_QUERY_ELEMENT,
+ "SRU diagnostic 48: Layer lemma with qualifier opennlp is unsupported.");
+ koralTerm.setInvalid(true);
+ }
+ else if (!supportedFoundries.contains(qualifier)) {
+ processor.addError(StatusCodes.UNKNOWN_QUERY_ELEMENT,
+ "SRU diagnostic 48: Qualifier " + qualifier
+ + " is unsupported.");
+ koralTerm.setInvalid(true);
+ }
+
+ koralTerm.setFoundry(qualifier);
+ }
+
+ private void parseOperator(KoralTerm koralTerm, Operator operator) {
+ String matchOperator = null;
+ if (operator == null || operator == Operator.EQUALS) {
+ matchOperator = "match:eq";
+ }
+ else if (operator == Operator.NOT_EQUALS) {
+ matchOperator = "match:ne";
+ }
+ else {
+ processor
+ .addError(StatusCodes.UNKNOWN_QUERY_ELEMENT,
+ "SRU diagnostic 37:" + operator.name()
+ + " is unsupported.");
+ koralTerm.setInvalid(true);
+ }
+ koralTerm.setOperator(matchOperator);
+ }
+
+ private void parseRegexFlags(KoralTerm koralTerm, Set<RegexFlag> set) {
+ // default case sensitive
+ if (set != null) {
+ for (RegexFlag f : set) {
+ if (f == RegexFlag.CASE_SENSITVE) {
+ koralTerm.setCaseSensitive(true);
+ }
+ else if (f == RegexFlag.CASE_INSENSITVE) {
+ koralTerm.setCaseSensitive(false);
+ }
+ else {
+ processor.addError(StatusCodes.UNKNOWN_QUERY_ELEMENT,
+ "SRU diagnostic 48:" + f.name()
+ + " is unsupported.");
+ koralTerm.setInvalid(true);
+ }
+ }
+ }
+ }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/KoralSequence.java b/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/KoralSequence.java
new file mode 100644
index 0000000..31bd159
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/KoralSequence.java
@@ -0,0 +1,71 @@
+package de.ids_mannheim.korap.query.parse.fcsql;
+
+import java.util.List;
+
+public class KoralSequence {
+
+ private boolean inOrder = false;
+ private List<Object> operands;
+ private List<Distance> distances;
+
+ public boolean isInOrder() {
+ return inOrder;
+ }
+
+ public void setInOrder(boolean inOrder) {
+ this.inOrder = inOrder;
+ }
+
+ public List<Object> getOperands() {
+ return operands;
+ }
+
+ public void setOperands(List<Object> operands) {
+ this.operands = operands;
+ }
+
+ public List<Distance> getDistances() {
+ return distances;
+ }
+
+ public void setDistances(List<Distance> distances) {
+ this.distances = distances;
+ }
+
+ public class Distance {
+ private String key;
+ private String min;
+ private String max;
+
+ public Distance (String key, int min, int max) {
+ this.key = key;
+ this.min = String.valueOf(min);
+ this.max = String.valueOf(max);
+ }
+
+ public String getKey() {
+ return key;
+ }
+
+ public void setKey(String key) {
+ this.key = key;
+ }
+
+ public String getMin() {
+ return min;
+ }
+
+ public void setMin(String min) {
+ this.min = min;
+ }
+
+ public String getMax() {
+ return max;
+ }
+
+ public void setMax(String max) {
+ this.max = max;
+ }
+
+ }
+}
diff --git a/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/KoralTerm.java b/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/KoralTerm.java
new file mode 100644
index 0000000..1ae2e09
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/parse/fcsql/KoralTerm.java
@@ -0,0 +1,61 @@
+package de.ids_mannheim.korap.query.parse.fcsql;
+
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import de.ids_mannheim.korap.query.serialize.FCSQLQueryProcessor;
+import de.ids_mannheim.korap.query.serialize.util.StatusCodes;
+import eu.clarin.sru.server.fcs.parser.Operator;
+import eu.clarin.sru.server.fcs.parser.RegexFlag;
+
+public class KoralTerm {
+
+ private String layer;
+ private String foundry;
+ private String operator;
+ private String queryTerm;
+ private boolean caseSensitive = true;
+ private boolean invalid = false;
+
+
+ public String getLayer() {
+ return layer;
+ }
+ public void setLayer(String layer) {
+ this.layer = layer;
+ }
+ public String getFoundry() {
+ return foundry;
+ }
+ public void setFoundry(String foundry) {
+ this.foundry = foundry;
+ }
+ public String getOperator() {
+ return operator;
+ }
+ public void setOperator(String operator) {
+ this.operator = operator;
+ }
+ public String getQueryTerm() {
+ return queryTerm;
+ }
+ public void setQueryTerm(String queryTerm) {
+ this.queryTerm = queryTerm;
+ }
+ public boolean isCaseSensitive() {
+ return caseSensitive;
+ }
+ public void setCaseSensitive(boolean isCaseSensitive) {
+ this.caseSensitive = isCaseSensitive;
+ }
+ public boolean isInvalid() {
+ return invalid;
+ }
+ public void setInvalid(boolean invalid) {
+ this.invalid = invalid;
+ }
+
+}
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/FCSQLQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/FCSQLQueryProcessor.java
index 7e0c199..0785237 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/FCSQLQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/FCSQLQueryProcessor.java
@@ -4,266 +4,168 @@
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-import java.util.Set;
+import de.ids_mannheim.korap.query.parse.fcsql.FCSSRUQueryParser;
+import de.ids_mannheim.korap.query.parse.fcsql.KoralSequence;
+import de.ids_mannheim.korap.query.parse.fcsql.KoralSequence.Distance;
+import de.ids_mannheim.korap.query.parse.fcsql.KoralTerm;
import de.ids_mannheim.korap.query.serialize.util.StatusCodes;
import eu.clarin.sru.server.SRUQueryBase;
-import eu.clarin.sru.server.SRUVersion;
import eu.clarin.sru.server.fcs.Constants;
-import eu.clarin.sru.server.fcs.parser.Expression;
-import eu.clarin.sru.server.fcs.parser.Operator;
import eu.clarin.sru.server.fcs.parser.QueryNode;
import eu.clarin.sru.server.fcs.parser.QueryParser;
import eu.clarin.sru.server.fcs.parser.QueryParserException;
-import eu.clarin.sru.server.fcs.parser.QuerySegment;
-import eu.clarin.sru.server.fcs.parser.RegexFlag;
+/**
+ * @author margaretha
+ *
+ */
public class FCSQLQueryProcessor extends AbstractQueryProcessor {
- public static final class FCSQuery extends SRUQueryBase<QueryNode> {
+ public static final class FCSSRUQuery extends SRUQueryBase<QueryNode> {
- private FCSQuery(String rawQuery, QueryNode parsedQuery) {
- super(rawQuery, parsedQuery);
- }
+ private FCSSRUQuery (String rawQuery, QueryNode parsedQuery) {
+ super(rawQuery, parsedQuery);
+ }
- @Override
- public String getQueryType() {
- return Constants.FCS_QUERY_TYPE_FCS;
- }
- }
+ @Override
+ public String getQueryType() {
+ return Constants.FCS_QUERY_TYPE_FCS;
+ }
+ }
- public enum Foundry {
- CNX, OPENNLP, TT, MATE, XIP;
- }
+ private static final String VERSION_2_0 = "2.0";
+ private static final String OPERATION_OR = "operation:or";
+ private static final String OPERATION_SEQUENCE = "operation:sequence";
+ private static final String OPERATION_POSITION = "operation:position";
- private static final String KORAP_CONTEXT = "http://ids-mannheim.de/ns/KorAP/json-ld/v0.1/context.jsonld";
- private String version;
- private List<Foundry> supportedFoundries;
- private final QueryParser parser = new QueryParser();
+ private final QueryParser fcsParser = new QueryParser();
+ private String version;
- public FCSQLQueryProcessor(String query, String version) {
- if (version == null) {
- addError(StatusCodes.MISSING_VERSION,
- "SRU Diagnostic 7: Version number is missing.");
- } else if (!version.equals(SRUVersion.VERSION_2_0)) {
- addError(StatusCodes.MISSING_VERSION,
- "SRU Diagnostic 5: Only supports SRU version 2.0.");
- }
- this.version = version;
+ public FCSQLQueryProcessor (String query, String version) {
+ super();
+ this.version = version;
+ process(query);
+ }
- this.requestMap = new LinkedHashMap<>();
- requestMap.put("@context", KORAP_CONTEXT);
+ @Override
+ public Map<String, Object> getRequestMap() {
+ return this.requestMap;
+ }
- this.supportedFoundries = new ArrayList<Foundry>(5);
- supportedFoundries.add(Foundry.CNX);
- supportedFoundries.add(Foundry.OPENNLP);
- supportedFoundries.add(Foundry.TT);
- supportedFoundries.add(Foundry.MATE);
- supportedFoundries.add(Foundry.XIP);
+ @Override
+ public void process(String query) {
+ if (isVersionValid()) {
+ FCSSRUQuery fcsSruQuery = parseQueryStringtoFCSQuery(query);
+ QueryNode fcsQueryNode = fcsSruQuery.getParsedQuery();
+ parseFCSQueryToKoralQuery(fcsQueryNode);
+ }
+ }
- process(query);
- }
+ private boolean isVersionValid() {
+ if (version == null || version.isEmpty()) {
+ addError(StatusCodes.MISSING_VERSION,
+ "SRU diagnostic 7: Version number is missing.");
+ return false;
+ }
+ else if (!version.equals(VERSION_2_0)) {
+ addError(StatusCodes.MISSING_VERSION,
+ "SRU diagnostic 5: Only supports SRU version 2.0.");
+ return false;
+ }
+ return true;
+ }
- @Override
- public Map<String, Object> getRequestMap() {
- return this.requestMap;
- }
+ private FCSSRUQuery parseQueryStringtoFCSQuery(String query) {
+ if ((query == null) || query.isEmpty())
+ addError(StatusCodes.NO_QUERY,
+ "SRU diagnostic 1: No query has been passed.");
+ FCSSRUQuery fcsQuery = null;
+ try {
+ QueryNode parsedQuery = fcsParser.parse(query);
+ fcsQuery = new FCSSRUQuery(query, parsedQuery);
+ }
+ catch (QueryParserException e) {
+ addError(StatusCodes.UNKNOWN_QUERY_ERROR, "FCS diagnostic 10: +"
+ + e.getMessage());
+ }
+ catch (Exception e) {
+ addError(StatusCodes.UNKNOWN_QUERY_ERROR, "FCS diagnostic 10: +"
+ + "Unexpected error while parsing query.");
+ }
+ return fcsQuery;
+ }
- @Override
- public void process(String query) {
- FCSQuery fcsQuery = parseQueryStringtoFCSQuery(query);
- QueryNode fcsQueryNode = fcsQuery.getParsedQuery();
- Map<String, Object> queryMap = parseFCSQuery(fcsQueryNode);
- requestMap.put("query", queryMap);
- }
+ private void parseFCSQueryToKoralQuery(QueryNode queryNode) {
+ FCSSRUQueryParser parser = new FCSSRUQueryParser(this);
+ Object o = parser.parseQueryNode(queryNode);
+ Map<String, Object> queryMap = buildQueryMap(o);
+ if (queryMap != null) requestMap.put("query", queryMap);
+ }
- private FCSQuery parseQueryStringtoFCSQuery(String query) {
- if ((query == null) || query.isEmpty())
- addError(StatusCodes.MALFORMED_QUERY,
- "SRU diagnostic 1: No query has been passed.");
- FCSQuery fcsQuery = null;
- try {
- QueryNode parsedQuery = parser.parse(query);
- fcsQuery = new FCSQuery(query, parsedQuery);
- } catch (QueryParserException e) {
- addError(StatusCodes.UNKNOWN_QUERY_ERROR, "FCS Diagnostic 10: +"
- + e.getMessage());
- }
- catch (Exception e) {
- addError(StatusCodes.UNKNOWN_QUERY_ERROR, "FCS Diagnostic 10: +"
- + "Unexpected error while parsing query.");
- }
- return fcsQuery;
- }
+ private Map<String, Object> buildQueryMap(Object o) {
+ if (o != null) {
+ if (o instanceof KoralTerm) {
+ KoralTerm koralTerm = (KoralTerm) o;
+ if (!koralTerm.isInvalid()) {
+ return createTermMap(koralTerm);
+ }
+ }
+ else if (o instanceof KoralSequence) {
+ KoralSequence koralSequence = (KoralSequence) o;
+ return createSequenceMap(koralSequence);
+ }
+ }
+ return null;
+ }
- private Map<String, Object> parseFCSQuery(QueryNode queryNode) {
- Map<String, Object> queryMap = parseQueryNode(queryNode);
- if (queryMap == null) {
- addError(StatusCodes.UNKNOWN_QUERY_ERROR, "SRU diagnostic 47:"
- + " Failed parsing query for unknown reasons.");
- }
- return queryMap;
+ private Map<String, Object> createSequenceMap(KoralSequence koralSequence) {
+ Map<String, Object> map = new LinkedHashMap<String, Object>();
+ map.put("@type", "koral:group");
+ map.put("operation", OPERATION_SEQUENCE);
+ map.put("inOrder", koralSequence.isInOrder());
- }
+ if (koralSequence.getDistances() != null) {
+ List<Map<String, Object>> distanceList = new ArrayList<Map<String, Object>>();
+ for (Distance d : koralSequence.getDistances()) {
+ distanceList.add(createDistanceMap(d));
+ }
+ map.put("distances", distanceList);
+ }
- private Map<String, Object> parseQueryNode(QueryNode queryNode) {
- Map<String, Object> queryMap = null;
+ List<Map<String, Object>> operandList = new ArrayList<Map<String, Object>>();
+ for (Object o : koralSequence.getOperands()) {
+ operandList.add(buildQueryMap(o));
+ }
+ map.put("operands", operandList);
+ return map;
+ }
- if (queryNode instanceof QuerySegment) {
- queryMap = parseQuerySegment((QuerySegment) queryNode);
-// } else if (queryNode instanceof QueryGroup) {
-//
-// } else if (queryNode instanceof QuerySequence) {
-//
-// } else if (queryNode instanceof QueryDisjunction) {
-//
-// } else if (queryNode instanceof QueryWithWithin) {
+ private Map<String, Object> createDistanceMap(Distance distance) {
+ Map<String, Object> distanceMap = new LinkedHashMap<String, Object>();
+ distanceMap.put("@type", "koral:distance");
+ distanceMap.put("key", distance.getKey());
+ distanceMap.put("min", distance.getMin());
+ distanceMap.put("max", distance.getMax());
+ return distanceMap;
- }else {
- addError(StatusCodes.QUERY_TOO_COMPLEX, "FCS diagnostic 11:"
- + queryNode.getNodeType().name()
- + " is currently unsupported.");
- }
+ }
- return queryMap;
- }
+ private Map<String, Object> createTermMap(KoralTerm fcsQuery) {
+ Map<String, Object> map = new LinkedHashMap<String, Object>();
+ map.put("@type", "koral:term");
+ if (!fcsQuery.isCaseSensitive()) {
+ map.put("caseInsensitive", "true");
+ }
+ map.put("key", fcsQuery.getQueryTerm());
+ map.put("foundry", fcsQuery.getFoundry());
+ map.put("layer", fcsQuery.getLayer());
+ map.put("match", fcsQuery.getOperator());
- private Map<String, Object> parseQuerySegment(QuerySegment segment) {
- Map<String, Object> queryMap = null;
-
- if ((segment.getMinOccurs() == 1) && (segment.getMaxOccurs() == 1)) {
- queryMap = parseExpression(segment.getExpression());
- } else {
- addError(StatusCodes.QUERY_TOO_COMPLEX, "FCS diagnostic 11:"
- + "Query is too complex.");
- }
- return queryMap;
- }
-
- private Map<String, Object> parseExpression(QueryNode queryNode) {
- Map<String, Object> queryMap = null;
-
- if (queryNode instanceof Expression) {
- Expression expression = (Expression) queryNode;
- queryMap = parseLayer(expression);
- }
- // else if (queryNode instanceof ExpressionAnd) {
- //
- // }
- // else if (queryNode instanceof ExpressionGroup) {
- //
- // }
- // else if (queryNode instanceof ExpressionNot) {
- //
- // }
- // else if (queryNode instanceof ExpressionOr) {
- //
- // }
- // else if (queryNode instanceof ExpressionWildcard) {
- //
- // }
- else {
- addError(StatusCodes.QUERY_TOO_COMPLEX, "FCS diagnostic 11:"
- + "Query is too complex.");
- }
- return queryMap;
- }
-
- private Map<String, Object> parseLayer(Expression expression) {
- String layer = parseLayerIdentifier(expression.getLayerIdentifier());
- String foundry = parseQualifier(expression.getLayerQualifier(), layer);
- String operator = parseOperator(expression.getOperator());
- boolean isCaseSensitive = parseRegexFlags(expression.getRegexFlags());
- String term = expression.getRegexValue();
-
- return writeTerm(term, foundry, layer, operator, isCaseSensitive);
- }
- private String parseLayerIdentifier(String identifier) {
- String layer = null;
- if (identifier == null) {
- // throw exception
- } else if (identifier.equals("text")) {
- layer = "orth";
- } else if (identifier.equals("pos")) {
- layer = "p";
- } else if (identifier.equals("lemma")) {
- layer = "l";
- } else {
- addError(StatusCodes.UNKNOWN_QUERY_ELEMENT, "SRU diagnostic 48:"
- + identifier + " is unsupported.");
- }
-
- return layer;
- }
-
- private String parseQualifier(String qualifier, String layer) {
- // Set default foundry
- if (qualifier == null) {
- if (layer.equals("orth")) {
- qualifier = Foundry.OPENNLP.name().toLowerCase();
- } else {
- qualifier = Foundry.TT.name().toLowerCase();
- }
- } else if (qualifier.equals(Foundry.OPENNLP.name().toLowerCase())
- && layer.equals("lemma")) {
- addError(StatusCodes.UNKNOWN_QUERY_ELEMENT, "SRU diagnostic 48:"
- + "Layer lemma with qualifier opennlp is unsupported.");
- } else if (!supportedFoundries.contains(qualifier)) {
- addError(StatusCodes.UNKNOWN_QUERY_ELEMENT, "SRU diagnostic 48:"
- + "Layer " + layer + " with qualifier" + qualifier
- + " is unsupported.");
- }
- return qualifier;
- }
-
- private String parseOperator(Operator operator) {
- String matchOperator = null;
- if (operator == null || operator == Operator.EQUALS) {
- matchOperator = "match:eq";
- } else if (operator == Operator.NOT_EQUALS) {
- matchOperator = "match:ne";
- } else {
- addError(StatusCodes.UNKNOWN_QUERY_ELEMENT, "SRU diagnostic 37:"
- + operator.name() + " is unsupported.");
- }
- return matchOperator;
- }
-
- private boolean parseRegexFlags(Set<RegexFlag> set) {
- // default case sensitive
- boolean flag = true;
- if (set != null) {
- for (RegexFlag f : set) {
- if (f == RegexFlag.CASE_SENSITVE) {
- continue;
- } else if (f == RegexFlag.CASE_INSENSITVE) {
- flag = false;
- } else {
- addError(StatusCodes.UNKNOWN_QUERY_ELEMENT,
- "SRU diagnostic 48:" + f.name()
- + " is unsupported.");
- }
- }
- }
- return flag;
- }
-
- private Map<String, Object> writeTerm(String term, String foundry,
- String layer, String operator, boolean isCaseSensitive) {
- Map<String, Object> map = new LinkedHashMap<String, Object>();
- map.put("@type", "koral:term");
- if (!isCaseSensitive) {
- map.put("caseInsensitive", "true");
- }
- map.put("key", term);
- map.put("foundry", foundry);
- map.put("layer", layer);
- map.put("match", operator);
-
- Map<String, Object> tokenMap = new LinkedHashMap<String, Object>();
- tokenMap.put("@type", "koral:token");
- tokenMap.put("wrap", map);
- return tokenMap;
- }
+ Map<String, Object> tokenMap = new LinkedHashMap<String, Object>();
+ tokenMap.put("@type", "koral:token");
+ tokenMap.put("wrap", map);
+ return tokenMap;
+ }
}