externalised CQLF object generation: now in util class CqlfObjectGenerator instead of abstract superclass ("composition over inheritance")
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractQueryProcessor.java
index 2b899ab..5e3ef4f 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/AbstractQueryProcessor.java
@@ -17,8 +17,6 @@
public abstract void process(String query) throws QueryException;
- public static final Integer MAXIMUM_DISTANCE = 100;
-
Logger log;
/**
* The query
@@ -97,300 +95,4 @@
public Map<String, Object> getRequestMap() {
return requestMap;
}
-
- protected LinkedHashMap<String, Object> makeSpan() {
- LinkedHashMap<String, Object> span = new LinkedHashMap<String, Object>();
- span.put("@type", "korap:span");
- return span;
- }
-
- protected LinkedHashMap<String, Object> makeSpan(String key) {
- LinkedHashMap<String, Object> span = new LinkedHashMap<String, Object>();
- span.put("@type", "korap:span");
- span.put("key", key);
- return span;
- }
-
- protected LinkedHashMap<String, Object> makeTerm() {
- LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
- term.put("@type", "korap:term");
- return term;
- }
-
- protected LinkedHashMap<String, Object> makeTermGroup(String relation) {
- LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
- term.put("@type", "korap:termGroup");
- term.put("relation", "relation:"+relation);
- term.put("operands", new ArrayList<Object>());
- return term;
- }
-
- protected LinkedHashMap<String, Object> makeDoc() {
- LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
- term.put("@type", "korap:doc");
- return term;
- }
-
- protected LinkedHashMap<String, Object> makeDocGroup(String relation) {
- LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
- term.put("@type", "korap:docGroup");
- term.put("operation", "operation:"+relation);
- term.put("operands", new ArrayList<Object>());
- return term;
- }
-
- protected LinkedHashMap<String, Object> makeToken() {
- LinkedHashMap<String, Object> token = new LinkedHashMap<String, Object>();
- token.put("@type", "korap:token");
- return token;
- }
-
- protected LinkedHashMap<String, Object> makeGroup(String operation) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:group");
- group.put("operation", "operation:"+operation);
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeRepetition(Integer min, Integer max) {
- LinkedHashMap<String, Object> group = makeGroup("repetition");
- group.put("boundary", makeBoundary(min, max));
- group.put("min", min);
- if (max != null) {
- group.put("max", max);
- }
- addMessage(303, "Deprecated 2014-07-24: 'min' and 'max' to be supported until 3 months from deprecation date.");
- return group;
- }
-
- @Deprecated
- protected LinkedHashMap<String, Object> makePosition(String frame) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:group");
- group.put("operation", "operation:position");
- group.put("frame", "frame:"+frame);
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- protected LinkedHashMap<String, Object> makePosition(String[] allowedFrames, String[] classRefCheck) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:group");
- group.put("operation", "operation:position");
- group.put("frames", Arrays.asList(allowedFrames));
- group.put("operands", new ArrayList<Object>());
- // DEPRECATED 'frame'
- if (classRefCheck == null || classRefCheck.length==0) classRefCheck = new String[]{"classRefCheck:includes"};
- String frame = "";
-
- if (allowedFrames.length==0 && classRefCheck[0]=="classRefCheck:includes") {
- frame = "frame:contains";
- } else if (allowedFrames[0]=="frames:overlapsLeft" && allowedFrames[1]=="frames:overlapsRight" && classRefCheck[0]=="classRefCheck:intersects") {
- frame = "frame:overlaps";
- } else if (allowedFrames[0]=="frames:startswith" && classRefCheck[0]=="classRefCheck:includes") {
- frame = "frame:startswith";
- } else if (allowedFrames[0]=="frames:endswith" && classRefCheck[0]=="classRefCheck:includes") {
- frame = "frame:endswith";
- } else if (allowedFrames[0]=="frames:matches" && classRefCheck[0]=="classRefCheck:includes" && classRefCheck.length==1) {
- frame = "frame:matches";
- } else if (allowedFrames[0]=="frames:matches" && classRefCheck[0]=="classRefCheck:includes" && classRefCheck[1]=="classRefCheck:unequals") {
- frame = "frame:matches";
- } else if (allowedFrames[0]=="frames:matches" && classRefCheck[0]=="classRefCheck:equals") {
- frame = "frame:matches";
- } else if (allowedFrames[0]=="frames:contains" && classRefCheck[0]=="classRefCheck:includes") {
- frame = "frame:contains";
- } else if (allowedFrames[0]=="frames:startswith" && classRefCheck[0]=="classRefCheck:intersects") {
- frame = "frame:overlapsLeft";
- } else if (allowedFrames[0]=="frames:endswith" && classRefCheck[0]=="classRefCheck:intersects") {
- frame = "frame:overlapsRight";
- } else if (allowedFrames[0]=="frames:matches" && classRefCheck[0]=="classRefCheck:intersects") {
- frame = "frame:matches";
- } else if (allowedFrames[0]=="frames:matches" && classRefCheck[0]=="classRefCheck:unequals") {
- frame = "frame:matches";
- } else if (allowedFrames[0]=="frames:matches" && classRefCheck[0]=="classRefCheck:equals") {
- frame = "frame:matches";
- } else if (allowedFrames[0]=="frames:contains" && classRefCheck[0]=="classRefCheck:intersects") {
- frame = "frame:contains";
- }
- group.put("frame", frame);
- addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-09-22: 'frame' only to be supported until 3 months from deprecation date. " +
- "Position frames are now expressed through 'frames'.");
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeSpanClass(int classCount) {
- return makeSpanClass(classCount, true);
- }
-
- protected LinkedHashMap<String, Object> makeSpanClass(int classCount, boolean setBySystem) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:group");
- group.put("operation", "operation:class");
- if (setBySystem) {
- group.put("class", 128+classCount);
- group.put("classOut", 128+classCount);
- addMessage("A class has been introduced into the backend representation of " +
- "your query for later reference to a part of the query. The class id is "+(128+classCount));
- } else {
- group.put("class", classCount);
- group.put("classOut", classCount);
- }
- addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-10-07: 'class' only to be supported until 3 months from deprecation date. " +
- "Classes are now defined using the 'classOut' attribute.");
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeClassRefCheck(ArrayList<String> check, Integer[] classIn, int classOut) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:group");
- group.put("operation", "operation:class");
- group.put("classRefCheck", check);
- group.put("classIn", Arrays.asList(classIn));
- group.put("classOut", classOut);
- group.put("class", classOut);
- addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-10-07: 'class' only to be supported until 3 months from deprecation date. " +
- "Classes are now defined using the 'classOut' attribute.");
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeClassRefOp(String operation, Integer[] classIn, int classOut) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:group");
- group.put("operation", "operation:class");
- group.put("classRefOp", operation);
- group.put("classIn", Arrays.asList(classIn));
- group.put("classOut", classOut);
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- @Deprecated
- protected LinkedHashMap<String, Object> makeTreeRelation(String reltype) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:treeRelation");
- if (reltype != null) group.put("reltype", reltype);
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeRelation() {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:relation");
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeBoundary(Integer min, Integer max) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:boundary");
- group.put("min", min);
- if (max != null) {
- group.put("max", max);
- }
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeDistance(String key, Integer min, Integer max) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- if (key.equals("w")) {
- group.put("@type", "korap:distance");
- } else {
- group.put("@type", "cosmas:distance");
- }
- group.put("key", key);
- group.put("boundary", makeBoundary(min, max));
- group.put("min", min);
- if (max != null) {
- group.put("max", max);
- }
- addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-07-24: 'min' and 'max' to be supported until 3 months from deprecation date.");
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeReference(ArrayList<Integer> classRefs, String operation) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:reference");
- group.put("operation", "operation:"+operation);
- if (classRefs!= null && !classRefs.isEmpty()) {
- group.put("classRef", classRefs);
- }
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeReference(ArrayList<Integer> classRefs) {
- return makeReference(classRefs, "focus");
- }
-
- protected LinkedHashMap<String, Object> makeReference(int classRef, String operation, boolean setBySystem) {
- ArrayList<Integer> classRefs = new ArrayList<Integer>();
- if (setBySystem) classRef = classRef+128;
- classRefs.add(classRef);
- return makeReference(classRefs, operation);
- }
-
- protected LinkedHashMap<String, Object> makeReference(int classRef, boolean setBySystem) {
- ArrayList<Integer> classRefs = new ArrayList<Integer>();
- if (setBySystem) classRef = classRef+128;
- classRefs.add(classRef);
- return makeReference(classRefs, "focus");
- }
-
- protected LinkedHashMap<String, Object> makeReference(int classRef) {
- return makeReference(classRef, false);
- }
-
- protected LinkedHashMap<String, Object> makeResetReference() {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:reference");
- group.put("operation", "operation:focus");
- group.put("reset", true);
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- protected LinkedHashMap<String, Object> makeSpanReference(Integer[] spanRef, String operation) {
- LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
- group.put("@type", "korap:reference");
- group.put("operation", "operation:"+operation);
- group.put("spanRef", Arrays.asList(spanRef));
- group.put("operands", new ArrayList<Object>());
- return group;
- }
-
- protected void addOperandsToGroup(LinkedHashMap<String, Object> group) {
- ArrayList<Object> operands = new ArrayList<Object>();
- group.put("operands", operands);
- }
-
- protected LinkedHashMap<String, Object> wrapInReference(LinkedHashMap<String, Object> group, Integer classId) {
- LinkedHashMap<String, Object> refGroup = makeReference(classId);
- ArrayList<Object> operands = new ArrayList<Object>();
- operands.add(group);
- refGroup.put("operands", operands);
- return refGroup;
- }
-
- @SuppressWarnings("unchecked")
- protected LinkedHashMap<String, Object> wrapInClass(LinkedHashMap<String, Object> group, Integer classId) {
- LinkedHashMap<String, Object> classGroup = makeSpanClass(classId, true);
- ((ArrayList<Object>) classGroup.get("operands")).add(group);
- return classGroup;
- }
-
- /**
- * Ensures that a distance or quantification value does not exceed the allowed maximum value.
- * @param number
- * @return The input number if it is below the allowed maximum value, else the maximum value.
- */
- protected int cropToMaxValue(int number) {
- if (number > MAXIMUM_DISTANCE) {
- number = MAXIMUM_DISTANCE;
- String warning = String.format("You specified a distance between two segments that is greater than " +
- "the allowed max value of %d. Your query will be re-interpreted using a distance of %d.", MAXIMUM_DISTANCE, MAXIMUM_DISTANCE);
- addWarning(warning);
- log.warn("User warning: "+warning);
- }
- return number;
- }
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/AnnisQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/AnnisQueryProcessor.java
index 8f89546..07fe43e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/AnnisQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/AnnisQueryProcessor.java
@@ -23,6 +23,7 @@
import de.ids_mannheim.korap.query.parse.annis.AqlLexer;
import de.ids_mannheim.korap.query.parse.annis.AqlParser;
import de.ids_mannheim.korap.query.serialize.util.Antlr4DescriptiveErrorListener;
+import de.ids_mannheim.korap.query.serialize.util.CqlfObjectGenerator;
import de.ids_mannheim.korap.query.serialize.util.QueryException;
/**
@@ -70,7 +71,6 @@
* but are to be integrated into the AqlTree at a later point (namely as operands of the respective group). Therefore, store references to these
* nodes here and exclude the operands from being written into the query map individually.
*/
- private LinkedList<String> operandOnlyNodeRefs = new LinkedList<String>();
private List<ParseTree> globalLingTermNodes = new ArrayList<ParseTree>();
private int totalRelationCount;
/**
@@ -87,6 +87,7 @@
* @param parser The ANTLR parser instance that generated the parse tree
*/
public AnnisQueryProcessor(String query) {
+ CqlfObjectGenerator.setQueryProcessor(this);
try {
process(query);
} catch (QueryException e) {
@@ -227,7 +228,7 @@
private void processExprTop(ParseTree node) {
List<ParseTree> andTopExprs = getChildrenWithCat(node, "andTopExpr");
if (andTopExprs.size() > 1) {
- LinkedHashMap<String, Object> topOr = makeGroup("or");
+ LinkedHashMap<String, Object> topOr = CqlfObjectGenerator.makeGroup("or");
requestMap.put("query", topOr);
objectStack.push(topOr);
}
@@ -238,11 +239,11 @@
String firstChildNodeCat = getNodeCat(node.getChild(0));
LinkedHashMap<String, Object> object = null;
if (firstChildNodeCat.equals("node")) {
- object = makeSpan();
+ object = CqlfObjectGenerator.makeSpan();
} else if (firstChildNodeCat.equals("tok")) {
- object = makeToken();
+ object = CqlfObjectGenerator.makeToken();
if (node.getChildCount() > 1) { // empty tokens do not wrap a term
- LinkedHashMap<String, Object> term = makeTerm();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeTerm();
term.put("layer", "orth");
object.put("wrap", term);
}
@@ -251,17 +252,17 @@
// TODO generalize the list below -> look up layers associated with tokens rather than spans somewhere
HashMap<String, Object> qNameParse = parseQNameNode(node.getChild(0));
if (Arrays.asList(new String[]{"p", "lemma", "m", "orth"}).contains(qNameParse.get("layer"))) {
- object = makeToken();
- LinkedHashMap<String, Object> term = makeTerm();
+ object = CqlfObjectGenerator.makeToken();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeTerm();
object.put("wrap", term);
term.putAll(qNameParse);
} else {
- object = makeSpan();
+ object = CqlfObjectGenerator.makeSpan();
object.putAll(qNameParse);
}
} else if (firstChildNodeCat.equals("textSpec")) {
- object = makeToken();
- LinkedHashMap<String, Object> term = makeTerm();
+ object = CqlfObjectGenerator.makeToken();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeTerm();
object.put("wrap", term);
term.put("layer", "orth");
term.putAll(parseTextSpec(node.getChild(0)));
@@ -312,12 +313,12 @@
if (nodeReferencesTotal.get(ref) > 1) {
if (nodeReferencesProcessed.get(ref)==0) {
refClassMapping.put(ref, classCounter);
- operand = wrapInClass(operand, classCounter++);
+ operand = CqlfObjectGenerator.wrapInClass(operand, classCounter++);
} else if (nodeReferencesProcessed.get(ref)>0 && nodeReferencesTotal.get(ref)>1) {
try {
- operand = wrapInReference(operandStack.pop(), refClassMapping.get(ref));
+ operand = CqlfObjectGenerator.wrapInReference(operandStack.pop(), refClassMapping.get(ref));
} catch (NoSuchElementException e) {
- operand = makeReference(refClassMapping.get(ref));
+ operand = CqlfObjectGenerator.makeReference(refClassMapping.get(ref));
}
}
nodeReferencesProcessed.put(ref, nodeReferencesProcessed.get(ref)+1);
@@ -351,14 +352,14 @@
// This is modeled here...
if (reltype.equals("commonparent") || reltype.equals("commonancestor")) {
// make an (outer) group and an inner group containing the dummy node or previous relations
- group = makeGroup("relation");
- LinkedHashMap<String,Object> innerGroup = makeGroup("relation");
- LinkedHashMap<String,Object> relation = makeRelation();
- LinkedHashMap<String,Object> term = makeTerm();
+ group = CqlfObjectGenerator.makeGroup("relation");
+ LinkedHashMap<String,Object> innerGroup = CqlfObjectGenerator.makeGroup("relation");
+ LinkedHashMap<String,Object> relation = CqlfObjectGenerator.makeRelation();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
term.put("layer", "c");
relation.put("wrap", term);
// commonancestor is an indirect commonparent relation
- if (reltype.equals("commonancestor")) relation.put("boundary", makeBoundary(1, null));
+ if (reltype.equals("commonancestor")) relation.put("boundary", CqlfObjectGenerator.makeBoundary(1, null));
group.put("relation", relation);
innerGroup.put("relation", relation);
// Get operands list before possible re-assignment of 'group' (see following 'if')
@@ -366,23 +367,23 @@
ArrayList<Object> innerOperands = (ArrayList<Object>) innerGroup.get("operands");
// for lowest level, add the underspecified node as first operand and wrap it in a class group
if (i == 1) {
- innerOperands.add(wrapInClass(makeSpan(), classCounter));
+ innerOperands.add(CqlfObjectGenerator.wrapInClass(CqlfObjectGenerator.makeSpan(), classCounter));
// add the first operand and wrap the whole group in a focusing reference
innerOperands.add(operand1);
- innerGroup = wrapInReference(innerGroup, classCounter);
+ innerGroup = CqlfObjectGenerator.wrapInReference(innerGroup, classCounter);
outerOperands.add(innerGroup);
} else {
outerOperands.add(operandStack.pop());
}
// Lookahead: if next operator is not commonparent or commonancestor, wrap in class for accessibility
if (i < node.getChildCount()-2 && !getNodeCat(node.getChild(i+2).getChild(0)).startsWith("common")) {
- operand2 = wrapInClass(operand2, ++classCounter);
+ operand2 = CqlfObjectGenerator.wrapInClass(operand2, ++classCounter);
}
outerOperands.add(operand2);
// Wrap in another reference object in case other relations are following
if (i < node.getChildCount()-2) {
- group = wrapInReference(group, classCounter);
+ group = CqlfObjectGenerator.wrapInReference(group, classCounter);
}
// All other n-ary linguistic relations have special 'relation' attributes defined in CQLF and can be
// handled more easily...
@@ -395,12 +396,12 @@
groupType = "relation";
}
if (groupType.equals("relation") || groupType.equals("treeRelation")) {
- group = makeGroup(groupType);
+ group = CqlfObjectGenerator.makeGroup(groupType);
LinkedHashMap<String, Object> relation = new LinkedHashMap<String, Object>();
putAllButGroupType(relation, operatorGroup);
group.put("relation", relation);
} else if (groupType.equals("sequence")) {
- group = makeGroup(groupType);
+ group = CqlfObjectGenerator.makeGroup(groupType);
putAllButGroupType(group, operatorGroup);
} else if (groupType.equals("position")) {
group = new LinkedHashMap<String,Object>();
@@ -414,16 +415,16 @@
ParseTree rightChildSpec = getFirstChildWithCat(node.getChild(i).getChild(0), "@r");
if (leftChildSpec != null || rightChildSpec != null) {
String frame = (leftChildSpec!=null) ? "frames:startswith" : "frames:endswith";
- LinkedHashMap<String,Object> positionGroup = makePosition(new String[]{frame}, null);
- operand2 = wrapInClass(operand2, ++classCounter);
+ LinkedHashMap<String,Object> positionGroup = CqlfObjectGenerator.makePosition(new String[]{frame}, null);
+ operand2 = CqlfObjectGenerator.wrapInClass(operand2, ++classCounter);
((ArrayList<Object>) positionGroup.get("operands")).add(group);
- ((ArrayList<Object>) positionGroup.get("operands")).add(makeReference(classCounter,true));
+ ((ArrayList<Object>) positionGroup.get("operands")).add(CqlfObjectGenerator.makeReference(classCounter,true));
group = positionGroup;
}
// Wrap in reference object in case other relations are following
if (i < node.getChildCount()-2) {
- group = wrapInReference(group, classCounter);
+ group = CqlfObjectGenerator.wrapInReference(group, classCounter);
}
// Inject operands.
@@ -439,14 +440,14 @@
if (i == 1) {
// for the first operator, include both operands
if (operand1 != null) operands.add(operand1);
- if (operand2 != null) operands.add(wrapInClass(operand2, classCounter++));
+ if (operand2 != null) operands.add(CqlfObjectGenerator.wrapInClass(operand2, classCounter++));
// Don't put this into the super object directly but store on operandStack
// (because this group will have to be an operand of a subsequent operator)
operandStack.push(group);
// for all subsequent operators, only take the 2nd operand (first was already added by previous operator)
} else if (i < node.getChildCount()-2) {
// for all intermediate operators, include other previous groups and 2nd operand. Store this on the operandStack, too.
- if (operand2 != null) operands.add(wrapInClass(operand2, classCounter++));
+ if (operand2 != null) operands.add(CqlfObjectGenerator.wrapInClass(operand2, classCounter++));
operands.add(0, operandStack.pop());
operandStack.push(group);
} else if (i == node.getChildCount()-2) {
@@ -479,7 +480,7 @@
*/
private LinkedHashMap<String, Object> parseUnaryOperator(ParseTree node) {
LinkedHashMap<String, Object> attr = new LinkedHashMap<String, Object>();
- LinkedHashMap<String, Object> term = makeTerm();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeTerm();
String op = node.getChild(1).toStringTree(parser).substring(1);
if (op.equals("arity") || op.equals("tokenarity")) {
LinkedHashMap<String, Object> boundary = boundaryFromRangeSpec(node.getChild(3), false);
@@ -497,13 +498,13 @@
String operator = getNodeCat(operatorNode);
// DOMINANCE
if (operator.equals("dominance")) {
- relation = makeRelation();
+ relation = CqlfObjectGenerator.makeRelation();
relation.put("groupType", "relation");
ParseTree qName = getFirstChildWithCat(operatorNode, "qName");
ParseTree edgeSpecNode = getFirstChildWithCat(operatorNode, "edgeSpec");
ParseTree star = getFirstChildWithCat(operatorNode, "*");
ParseTree rangeSpec = getFirstChildWithCat(operatorNode, "rangeSpec");
- LinkedHashMap<String,Object> term = makeTerm();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
term.put("layer", "c");
if (qName != null) term = parseQNameNode(qName);
if (edgeSpecNode != null) {
@@ -513,31 +514,31 @@
((ArrayList<Object>) edgeSpec.get("operands")).add(term);
term = edgeSpec;
} else {
- term = makeTermGroup("and");
+ term = CqlfObjectGenerator.makeTermGroup("and");
ArrayList<Object> termGroupOperands = (ArrayList<Object>) term.get("operands");
termGroupOperands.add(edgeSpec);
- LinkedHashMap<String,Object> constTerm = makeTerm();
+ LinkedHashMap<String,Object> constTerm = CqlfObjectGenerator.makeTerm();
constTerm.put("layer", "c");
termGroupOperands.add(constTerm);
}
}
- if (star != null) relation.put("boundary", makeBoundary(0, null));
+ if (star != null) relation.put("boundary", CqlfObjectGenerator.makeBoundary(0, null));
if (rangeSpec != null) relation.put("boundary", boundaryFromRangeSpec(rangeSpec));
relation.put("wrap", term);
}
else if (operator.equals("pointing")) {
// String reltype = operatorNode.getChild(1).toStringTree(parser);
- relation = makeRelation();
+ relation = CqlfObjectGenerator.makeRelation();
relation.put("groupType", "relation");
ParseTree qName = getFirstChildWithCat(operatorNode, "qName");
ParseTree edgeSpec = getFirstChildWithCat(operatorNode, "edgeSpec");
ParseTree star = getFirstChildWithCat(operatorNode, "*");
ParseTree rangeSpec = getFirstChildWithCat(operatorNode, "rangeSpec");
// if (qName != null) relation.putAll(parseQNameNode(qName));
- LinkedHashMap<String,Object> term = makeTerm();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
if (qName != null) term.putAll(parseQNameNode(qName));
if (edgeSpec != null) term.putAll(parseEdgeSpec(edgeSpec));
- if (star != null) relation.put("boundary", makeBoundary(0, null));
+ if (star != null) relation.put("boundary", CqlfObjectGenerator.makeBoundary(0, null));
if (rangeSpec != null) relation.put("boundary", boundaryFromRangeSpec(rangeSpec));
relation.put("wrap", term);
}
@@ -548,7 +549,7 @@
ParseTree star = getFirstChildWithCat(operatorNode, "*");
ArrayList<Object> distances = new ArrayList<Object>();
if (star != null) {
- distances.add(makeDistance("w", 0, null));
+ distances.add(CqlfObjectGenerator.makeDistance("w", 0, null));
relation.put("distances", distances);
}
if (rangeSpec != null) {
@@ -586,7 +587,7 @@
}
// relation.put("frames", frames);
// relation.put("sharedClasses", sharedClasses);
- relation = makePosition(frames, new String[]{});
+ relation = CqlfObjectGenerator.makePosition(frames, new String[]{});
relation.put("groupType", "position");
}
else if (operator.equals("identity")) {
@@ -606,7 +607,7 @@
List<ParseTree> annos = getChildrenWithCat(edgeSpec, "edgeAnno");
if (annos.size() == 1) return parseEdgeAnno(annos.get(0));
else {
- LinkedHashMap<String,Object> termGroup = makeTermGroup("and");
+ LinkedHashMap<String,Object> termGroup = CqlfObjectGenerator.makeTermGroup("and");
ArrayList<Object> operands = (ArrayList<Object>) termGroup.get("operands");
for (ParseTree anno : annos) {
operands.add(parseEdgeAnno(anno));
@@ -639,7 +640,7 @@
if (expandToMax) max = null;
if (rangeSpec.getChildCount()==3)
max = Integer.parseInt(rangeSpec.getChild(2).toStringTree(parser));
- return makeBoundary(min, max);
+ return CqlfObjectGenerator.makeBoundary(min, max);
}
private LinkedHashMap<String, Object> parseDistance(ParseTree rangeSpec) {
@@ -647,7 +648,7 @@
Integer max = null;
if (rangeSpec.getChildCount()==3)
max = Integer.parseInt(rangeSpec.getChild(2).toStringTree(parser));
- return makeDistance("w", min, max);
+ return CqlfObjectGenerator.makeDistance("w", min, max);
}
private LinkedHashMap<String, Object> parseTextSpec(ParseTree node) {
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr3AbstractQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr3AbstractQueryProcessor.java
index 33adaca..4f0775f 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr3AbstractQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr3AbstractQueryProcessor.java
@@ -10,7 +10,7 @@
public abstract class Antlr3AbstractQueryProcessor extends AbstractQueryProcessor {
- public Parser parser;
+ protected Parser parser;
/**
* Returns the category (or 'label') of the root of a (sub-) ParseTree (ANTLR 3).
@@ -18,7 +18,7 @@
* @param node
* @return
*/
- public static String getNodeCat(Tree node) {
+ protected static String getNodeCat(Tree node) {
String nodeCat = node.toStringTree();
Pattern p = Pattern.compile("\\((.*?)\\s"); // from opening parenthesis to 1st whitespace
Matcher m = p.matcher(node.toStringTree());
@@ -35,7 +35,7 @@
* @param childCat The category of the potential child.
* @return true iff one or more children belong to the specified category
*/
- public static boolean hasChild(Tree node, String childCat) {
+ protected static boolean hasChild(Tree node, String childCat) {
for (int i = 0; i < node.getChildCount(); i++) {
if (getNodeCat(node.getChild(i)).equals(childCat)) {
return true;
@@ -43,8 +43,21 @@
}
return false;
}
+
+ protected boolean hasDescendant(Tree node, String childCat) {
+ for (int i = 0; i < node.getChildCount(); i++) {
+ Tree child = node.getChild(i);
+ if (getNodeCat(child).equals(childCat)) {
+ return true;
+ }
+ if (hasDescendant(child, childCat)) {
+ return true;
+ }
+ }
+ return false;
+ }
- public static List<Tree> getChildren(Tree node) {
+ protected static List<Tree> getChildren(Tree node) {
ArrayList<Tree> children = new ArrayList<Tree>();
for (int i = 0; i < node.getChildCount(); i++) {
children.add(node.getChild(i));
@@ -52,7 +65,7 @@
return children;
}
- public static List<Tree> getChildrenWithCat(Tree node, String nodeCat) {
+ protected static List<Tree> getChildrenWithCat(Tree node, String nodeCat) {
ArrayList<Tree> children = new ArrayList<Tree>();
for (int i = 0; i < node.getChildCount(); i++) {
if (getNodeCat(node.getChild(i)).equals(nodeCat)) {
@@ -62,12 +75,20 @@
return children;
}
- public static Tree getFirstChildWithCat(Tree node, String nodeCat) {
- for (int i = 0; i < node.getChildCount(); i++) {
- if (getNodeCat(node.getChild(i)).equals(nodeCat)) {
- return node.getChild(i);
- }
- }
+ protected static Tree getFirstChildWithCat(Tree node, String nodeCat) {
+ return getNthChildWithCat(node, nodeCat, 1);
+ }
+
+ protected static Tree getNthChildWithCat(Tree node, String nodeCat, int n) {
+ int counter = 0;
+ for (int i = 0; i < node.getChildCount(); i++) {
+ if (getNodeCat(node.getChild(i)).equals(nodeCat)) {
+ counter++;
+ if (counter == n) {
+ return node.getChild(i);
+ }
+ }
+ }
return null;
}
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr4AbstractQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr4AbstractQueryProcessor.java
index da09f3c..6873678 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr4AbstractQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/Antlr4AbstractQueryProcessor.java
@@ -1,7 +1,6 @@
package de.ids_mannheim.korap.query.serialize;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -22,7 +21,7 @@
* @param node
* @return
*/
- public String getNodeCat(ParseTree node) {
+ protected String getNodeCat(ParseTree node) {
String nodeCat = node.toStringTree(parser);
Pattern p = Pattern.compile("\\((.*?)\\s"); // from opening parenthesis to 1st whitespace
Matcher m = p.matcher(node.toStringTree(parser));
@@ -39,7 +38,7 @@
* @param childCat The category of the potential child.
* @return true iff one or more children belong to the specified category
*/
- public boolean hasChild(ParseTree node, String childCat) {
+ protected boolean hasChild(ParseTree node, String childCat) {
for (int i = 0; i < node.getChildCount(); i++) {
if (getNodeCat(node.getChild(i)).equals(childCat)) {
return true;
@@ -48,7 +47,7 @@
return false;
}
- public boolean hasDescendant(ParseTree node, String childCat) {
+ protected boolean hasDescendant(ParseTree node, String childCat) {
for (int i = 0; i < node.getChildCount(); i++) {
ParseTree child = node.getChild(i);
if (getNodeCat(child).equals(childCat)) {
@@ -62,7 +61,7 @@
}
- public static List<ParseTree> getChildren(ParseTree node) {
+ protected static List<ParseTree> getChildren(ParseTree node) {
ArrayList<ParseTree> children = new ArrayList<ParseTree>();
for (int i = 0; i < node.getChildCount(); i++) {
children.add(node.getChild(i));
@@ -70,7 +69,7 @@
return children;
}
- public List<ParseTree> getChildrenWithCat(ParseTree node, String nodeCat) {
+ protected List<ParseTree> getChildrenWithCat(ParseTree node, String nodeCat) {
ArrayList<ParseTree> children = new ArrayList<ParseTree>();
for (int i = 0; i < node.getChildCount(); i++) {
if (getNodeCat(node.getChild(i)).equals(nodeCat)) {
@@ -80,11 +79,11 @@
return children;
}
- public ParseTree getFirstChildWithCat(ParseTree node, String nodeCat) {
+ protected ParseTree getFirstChildWithCat(ParseTree node, String nodeCat) {
return getNthChildWithCat(node, nodeCat, 1);
}
- public ParseTree getNthChildWithCat(ParseTree node, String nodeCat, int n) {
+ protected ParseTree getNthChildWithCat(ParseTree node, String nodeCat, int n) {
int counter = 0;
for (int i = 0; i < node.getChildCount(); i++) {
if (getNodeCat(node.getChild(i)).equals(nodeCat)) {
@@ -96,23 +95,4 @@
}
return null;
}
-
- /**
- * Checks whether a node only serves as a container for another node (e.g. in (cq_segment ( cg_seg_occ ...)), the cq_segment node does not contain
- * any information and only contains the cq_seg_occ node.
- * @param node The node to check
- * @return true iff the node is a container only.
- */
- public boolean isContainerOnly(ParseTree node) {
- String[] validNodeNamesArray = "cq_segment sq_segment element empty_segments spanclass".split(" ");
- List<String> validNodeNames = Arrays.asList(validNodeNamesArray);
- List<ParseTree> children = getChildren(node);
- for (ParseTree child : children) {
- if (validNodeNames.contains(getNodeCat(child))) {
- return false;
- }
- }
- return true;
- }
-
-}
+}
\ No newline at end of file
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/CollectionQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/CollectionQueryProcessor.java
index 932e34d..26e86e3 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/CollectionQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/CollectionQueryProcessor.java
@@ -3,6 +3,7 @@
import de.ids_mannheim.korap.query.parse.collection.CollectionQueryLexer;
import de.ids_mannheim.korap.query.parse.collection.CollectionQueryParser;
import de.ids_mannheim.korap.query.serialize.util.Antlr4DescriptiveErrorListener;
+import de.ids_mannheim.korap.query.serialize.util.CqlfObjectGenerator;
import de.ids_mannheim.korap.query.serialize.util.StatusCodes;
import de.ids_mannheim.korap.query.serialize.util.QueryException;
@@ -42,14 +43,17 @@
Integer stackedObjects = 0;
public CollectionQueryProcessor() {
+ CqlfObjectGenerator.setQueryProcessor(this);
}
public CollectionQueryProcessor(boolean verbose) {
+ CqlfObjectGenerator.setQueryProcessor(this);
CollectionQueryProcessor.verbose = verbose;
}
public CollectionQueryProcessor(String query) throws QueryException {
- process(query);
+ CqlfObjectGenerator.setQueryProcessor(this);
+ process(query);
}
@Override
@@ -86,7 +90,7 @@
if (nodeCat.equals("relation")) {
String operator = node.getChild(1).getChild(0).toStringTree(parser).equals("&") ? "and" : "or";
- LinkedHashMap<String, Object> relationGroup = makeDocGroup(operator);
+ LinkedHashMap<String, Object> relationGroup = CqlfObjectGenerator.makeDocGroup(operator);
putIntoSuperObject(relationGroup);
objectStack.push(relationGroup);
stackedObjects++;
@@ -97,7 +101,7 @@
String field = fieldNode.getChild(0).toStringTree(parser);
ParseTree operatorNode = getFirstChildWithCat(node, "operator");
ParseTree valueNode = getFirstChildWithCat(node, "value");
- LinkedHashMap<String, Object> term = makeDoc();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeDoc();
term.put("key", field);
term.putAll(parseValue(valueNode));
String match = operatorNode.getText();
@@ -120,7 +124,7 @@
ParseTree dateOpNode = getFirstChildWithCat(node, "dateOp");
ParseTree dateNode = getFirstChildWithCat(node, "date");
- LinkedHashMap<String, Object> term = makeDoc();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeDoc();
term.put("key", field);
term.putAll(parseValue(dateNode));
String match = dateOpNode.getText();
@@ -133,7 +137,7 @@
}
if (nodeCat.equals("token")) {
- LinkedHashMap<String,Object> token = makeToken();
+ LinkedHashMap<String,Object> token = CqlfObjectGenerator.makeToken();
// handle negation
List<ParseTree> negations = getChildrenWithCat(node, "!");
boolean negated = false;
@@ -141,7 +145,7 @@
if (negations.size() % 2 == 1) negated = true;
if (getNodeCat(node.getChild(0)).equals("key")) {
// no 'term' child, but direct key specification: process here
- LinkedHashMap<String,Object> term = makeTerm();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
String key = node.getChild(0).getText();
if (getNodeCat(node.getChild(0).getChild(0)).equals("regex")) {
isRegex = true;
@@ -365,7 +369,7 @@
private LinkedHashMap<String, Object> parseTermOrTermGroup(ParseTree node, boolean negatedGlobal, String mode) {
if (getNodeCat(node).equals("term")) {
String key = null;
- LinkedHashMap<String,Object> term = makeTerm();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
// handle negation
boolean negated = negatedGlobal;
boolean isRegex = false;
@@ -433,7 +437,7 @@
// establish boolean relation
ParseTree boolOp = getFirstChildWithCat(node, "booleanOp");
String operator = boolOp.getText().equals("&") ? "and" : "or";
- termGroup = makeTermGroup(operator);
+ termGroup = CqlfObjectGenerator.makeTermGroup(operator);
ArrayList<Object> operands = (ArrayList<Object>) termGroup.get("operands");
// recursion with left/right operands
operands.add(parseTermOrTermGroup(leftOp, negatedGlobal, mode));
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/Cosmas2QueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/Cosmas2QueryProcessor.java
index 7023a94..f119b08 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/Cosmas2QueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/Cosmas2QueryProcessor.java
@@ -3,6 +3,7 @@
import de.ids_mannheim.korap.query.parse.cosmas.c2psLexer;
import de.ids_mannheim.korap.query.parse.cosmas.c2psParser;
import de.ids_mannheim.korap.query.serialize.util.Antlr3DescriptiveErrorListener;
+import de.ids_mannheim.korap.query.serialize.util.CqlfObjectGenerator;
import de.ids_mannheim.korap.query.serialize.util.ResourceMapper;
import de.ids_mannheim.korap.query.serialize.util.StatusCodes;
import de.ids_mannheim.korap.query.serialize.util.QueryException;
@@ -97,6 +98,7 @@
* @throws QueryException
*/
public Cosmas2QueryProcessor(String query) throws QueryException {
+ CqlfObjectGenerator.setQueryProcessor(this);
this.query = query;
process(query);
log.info(">>> " + requestMap.get("query") + " <<<");
@@ -312,7 +314,7 @@
Tree begConditions = getFirstChildWithCat(node.getChild(optsChild), "TPBEG");
Tree endConditions = getFirstChildWithCat(node.getChild(optsChild), "TPEND");
- LinkedHashMap<String, Object> submatchgroup = makeReference(128+classCounter);
+ LinkedHashMap<String, Object> submatchgroup = CqlfObjectGenerator.makeReference(128+classCounter);
ArrayList<Object> submatchOperands = new ArrayList<Object>();
submatchgroup.put("operands", submatchOperands);
putIntoSuperObject(submatchgroup);
@@ -338,14 +340,14 @@
if (conditionGroups.size()==1) {
submatchOperands.add(conditionGroup);
} else if (conditionCount < conditionGroups.size()) {
- LinkedHashMap<String,Object> matchesGroup = makePosition(new String[]{"frames:matches"}, new String[0]);
+ LinkedHashMap<String,Object> matchesGroup = CqlfObjectGenerator.makePosition(new String[]{"frames:matches"}, new String[0]);
@SuppressWarnings("unchecked")
ArrayList<Object> matchesOperands = (ArrayList<Object>) matchesGroup.get("operands");
matchesOperands.add(conditionGroup);
// matches groups that are embedded at the second or lower level receive an additional
// focus to grep out only the query term to which the constraint applies
if (conditionCount > 1) {
- LinkedHashMap<String,Object> focus = makeReference(128+classCounter-conditionGroups.size()+conditionCount-1);
+ LinkedHashMap<String,Object> focus = CqlfObjectGenerator.makeReference(128+classCounter-conditionGroups.size()+conditionCount-1);
ArrayList<Object> focusOperands = new ArrayList<Object>();
focus.put("operands", focusOperands);
focusOperands.add(matchesGroup);
@@ -363,8 +365,8 @@
private void processOPNHIT(Tree node) {
Integer[] classRef = new Integer[]{128+classCounter+1, 128+classCounter+2};
// classRef.add(classCounter + 1); // yes, do this twice (two classes)!
- LinkedHashMap<String, Object> group = makeReference(128+classCounter);
- LinkedHashMap<String, Object> classRefCheck = makeClassRefOp("classRefOp:inversion", classRef, classCounter+128);
+ LinkedHashMap<String, Object> group = CqlfObjectGenerator.makeReference(128+classCounter);
+ LinkedHashMap<String, Object> classRefCheck = CqlfObjectGenerator.makeClassRefOp("classRefOp:inversion", classRef, classCounter+128);
ArrayList<Object> operands = new ArrayList<Object>();
operands.add(classRefCheck);
group.put("operands", operands);
@@ -400,7 +402,7 @@
wrapOperandInClass(node,2,classCounter++);
wrapOperandInClass(node,1,classCounter++);
// LinkedHashMap<String, Object> posgroup = makePosition(null);
- LinkedHashMap<String, Object> posgroup = makeGroup("position");
+ LinkedHashMap<String, Object> posgroup = CqlfObjectGenerator.makeGroup("position");
LinkedHashMap<String, Object> positionOptions;
// posgroup
if (nodeCat.equals("OPIN")) {
@@ -423,14 +425,14 @@
// Step II: wrap in reference and decide where to put
ArrayList<String> check = (ArrayList<String>) positionOptions.get("classRefCheck");
Integer[] classIn = new Integer[]{128+classCounter-2,128+classCounter-1};
- LinkedHashMap<String, Object> classRefCheck = makeClassRefCheck(check, classIn, 128+classCounter);
+ LinkedHashMap<String, Object> classRefCheck = CqlfObjectGenerator.makeClassRefCheck(check, classIn, 128+classCounter);
((ArrayList<Object>) classRefCheck.get("operands")).add(posgroup);
LinkedHashMap<String, Object> focusGroup = null;
if ((boolean) positionOptions.get("matchall") == true) {
- focusGroup = makeResetReference();
+ focusGroup = CqlfObjectGenerator.makeResetReference();
((ArrayList<Object>) focusGroup.get("operands")).add(classRefCheck);
} else { // match only first argument
- focusGroup = wrapInReference(classRefCheck, 128+classCounter-1);
+ focusGroup = CqlfObjectGenerator.wrapInReference(classRefCheck, 128+classCounter-1);
}
putIntoSuperObject(focusGroup, 1);
}
@@ -442,7 +444,7 @@
Tree typ = prox_opts.getChild(0);
Tree dist_list = prox_opts.getChild(1);
// Step I: create group
- LinkedHashMap<String, Object> group = makeGroup("sequence");
+ LinkedHashMap<String, Object> group = CqlfObjectGenerator.makeGroup("sequence");
ArrayList<Object> constraints = new ArrayList<Object>();
boolean exclusion = typ.getChild(0).toStringTree().equals("EXCL");
@@ -481,7 +483,7 @@
if (!meas.equals("w") && min == 0 ) {
processSpanDistance(meas,min,max);
}
- LinkedHashMap<String, Object> distance = makeDistance(meas,min,max);
+ LinkedHashMap<String, Object> distance = CqlfObjectGenerator.makeDistance(meas,min,max);
if (exclusion) {
distance.put("exclude", true);
}
@@ -505,10 +507,10 @@
if (! (openNodeCats.get(1).equals("OPBEG") || openNodeCats.get(1).equals("OPEND") || inOPALL || openNodeCats.get(1).equals("OPNHIT"))) {
wrapOperandInClass(node,1,classCounter);
wrapOperandInClass(node,2,classCounter);
- group = wrapInReference(group, 128+classCounter++);
+ group = CqlfObjectGenerator.wrapInReference(group, 128+classCounter++);
} else if (openNodeCats.get(1).equals("OPNHIT")) {
- LinkedHashMap<String,Object> repetition = makeRepetition(min, max);
- ((ArrayList<Object>) repetition.get("operands")).add(makeToken());
+ LinkedHashMap<String,Object> repetition = CqlfObjectGenerator.makeRepetition(min, max);
+ ((ArrayList<Object>) repetition.get("operands")).add(CqlfObjectGenerator.makeToken());
// TODO go on with this: put the repetition into a class and put it in between the operands
// -> what if there's several distance constraints. with different keys, like /w4,s0?
}
@@ -516,10 +518,10 @@
LinkedHashMap<String,Object> sequence = null;
if (putIntoOverlapDisjunction) {
sequence = embeddedSequence;
- group = makeGroup("or");
+ group = CqlfObjectGenerator.makeGroup("or");
ArrayList<Object> disjOperands = (ArrayList<Object>) group.get("operands");
String[] sharedClasses = new String[]{"intersects"};
- LinkedHashMap<String,Object> overlapsGroup = makePosition(new String[0], sharedClasses);
+ LinkedHashMap<String,Object> overlapsGroup = CqlfObjectGenerator.makePosition(new String[0], sharedClasses);
ArrayList<Object> overlapsOperands = (ArrayList<Object>) overlapsGroup.get("operands");
// this ensures identity of the operands lists and thereby a distribution of the operands for both created objects
@@ -528,7 +530,7 @@
invertedOperandsLists.push(overlapsOperands);
}
disjOperands.add(overlapsGroup);
- disjOperands.add(wrapInReference(sequence, 0));
+ disjOperands.add(CqlfObjectGenerator.wrapInReference(sequence, 0));
// Step II: decide where to put
putIntoSuperObject(group, 0);
objectStack.push(sequence);
@@ -592,7 +594,7 @@
@SuppressWarnings("unchecked")
private void processOPELEM(Tree node) {
// Step I: create element
- LinkedHashMap<String, Object> span = makeSpan();
+ LinkedHashMap<String, Object> span = CqlfObjectGenerator.makeSpan();
if (node.getChild(0).toStringTree().equals("EMPTY")) {
} else {
@@ -612,12 +614,12 @@
* top-level group (in order to avoid a top-level group that only
* contains a sub-group).
*/
- LinkedHashMap<String, Object> termGroup = makeTermGroup("and");
+ LinkedHashMap<String, Object> termGroup = CqlfObjectGenerator.makeTermGroup("and");
ArrayList<Object> termGroupOperands = (ArrayList<Object>) termGroup.get("operands");
for (int i = elname; i < node.getChildCount(); i++) {
Tree attrNode = node.getChild(i);
if (attrNode.getChildCount() == 2) {
- LinkedHashMap<String, Object> term = makeTerm();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeTerm();
termGroupOperands.add(term);
String layer = attrNode.getChild(0).toStringTree();
String[] splitted = layer.split("/");
@@ -630,11 +632,11 @@
String match = getNodeCat(attrNode).equals("EQ") ? "eq" : "ne";
term.put("match", "match:" + match);
} else {
- LinkedHashMap<String, Object> subTermGroup = makeTermGroup("and");
+ LinkedHashMap<String, Object> subTermGroup = CqlfObjectGenerator.makeTermGroup("and");
ArrayList<Object> subTermGroupOperands = (ArrayList<Object>) subTermGroup.get("operands");
int j;
for (j = 1; j < attrNode.getChildCount(); j++) {
- LinkedHashMap<String, Object> term = makeTerm();
+ LinkedHashMap<String, Object> term = CqlfObjectGenerator.makeTerm();
String layer = attrNode.getChild(0).toStringTree();
String[] splitted = layer.split("/");
if (splitted.length > 1) {
@@ -671,7 +673,7 @@
private void processOPMORPH(Tree node) {
//Step I: get info
String[] morphterms = node.getChild(0).toStringTree().replace(" ", "").split("&");
- LinkedHashMap<String, Object> token = makeToken();
+ LinkedHashMap<String, Object> token = CqlfObjectGenerator.makeToken();
ArrayList<Object> terms = new ArrayList<Object>();
LinkedHashMap<String, Object> fieldMap = null;
for (String morphterm : morphterms) {
@@ -706,7 +708,7 @@
if (morphterms.length == 1) {
token.put("wrap", fieldMap);
} else {
- LinkedHashMap<String, Object> termGroup = makeTermGroup("and");
+ LinkedHashMap<String, Object> termGroup = CqlfObjectGenerator.makeTermGroup("and");
termGroup.put("operands", terms);
token.put("wrap", termGroup);
}
@@ -774,7 +776,7 @@
* @param cls The class id.
*/
private void wrapOperandInClass(Tree node, int arg, int cls) {
- LinkedHashMap<String,Object> clsGroup = makeSpanClass(cls);
+ LinkedHashMap<String,Object> clsGroup = CqlfObjectGenerator.makeSpanClass(cls);
wrapOperand(node,arg,clsGroup);
}
@@ -851,10 +853,10 @@
}
}
// Create the position group and add the span and the subquery as operands, possibly wrapped in spanRefs
- LinkedHashMap<String, Object> positionGroup = makePosition(new String[]{position}, new String[0]);
+ LinkedHashMap<String, Object> positionGroup = CqlfObjectGenerator.makePosition(new String[]{position}, new String[0]);
if (negated) positionGroup.put("exclude", true);
ArrayList<Object> posOperands = new ArrayList<Object>();
- LinkedHashMap<String, Object> classGroup = makeSpanClass(classCounter++);
+ LinkedHashMap<String, Object> classGroup = CqlfObjectGenerator.makeSpanClass(classCounter++);
classGroup.put("operands", distributedOperands);
positionGroup.put("operands", posOperands);
LinkedHashMap<String, Object> span = new LinkedHashMap<String, Object>();
@@ -862,12 +864,12 @@
span.put("key", elem);
objectStack.push(classGroup);
if (hitSpanRef != null) {
- LinkedHashMap<String, Object> spanRefAroundHit = makeSpanReference(hitSpanRef, "focus");
+ LinkedHashMap<String, Object> spanRefAroundHit = CqlfObjectGenerator.makeSpanReference(hitSpanRef, "focus");
((ArrayList<Object>) spanRefAroundHit.get("operands")).add(classGroup);
classGroup = spanRefAroundHit; //re-assign after wrapping classGroup in spanRef
}
if (elemSpanRef != null) {
- LinkedHashMap<String, Object> spanRefAroundSpan = makeSpanReference(elemSpanRef, "focus");
+ LinkedHashMap<String, Object> spanRefAroundSpan = CqlfObjectGenerator.makeSpanReference(elemSpanRef, "focus");
((ArrayList<Object>) spanRefAroundSpan.get("operands")).add(span);
span = spanRefAroundSpan; //re-assign after wrapping span in spanRef
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusQueryProcessor.java b/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusQueryProcessor.java
index d509ccb..458e976 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusQueryProcessor.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusQueryProcessor.java
@@ -3,6 +3,7 @@
import de.ids_mannheim.korap.query.parse.poliqarpplus.PoliqarpPlusLexer;
import de.ids_mannheim.korap.query.parse.poliqarpplus.PoliqarpPlusParser;
import de.ids_mannheim.korap.query.serialize.util.Antlr4DescriptiveErrorListener;
+import de.ids_mannheim.korap.query.serialize.util.CqlfObjectGenerator;
import de.ids_mannheim.korap.query.serialize.util.StatusCodes;
import de.ids_mannheim.korap.query.serialize.util.QueryException;
@@ -34,6 +35,7 @@
* @throws QueryException
*/
public PoliqarpPlusQueryProcessor(String query) throws QueryException {
+ CqlfObjectGenerator.setQueryProcessor(this);
process(query);
log.info(">>> " + requestMap.get("query") + " <<<");
}
@@ -171,9 +173,9 @@
// Cover possible quantification (i.e. repetition) of segment
ParseTree quantification = getFirstChildWithCat(node, "repetition");
if (quantification != null) {
- LinkedHashMap<String,Object> quantGroup = makeGroup("repetition");
+ LinkedHashMap<String,Object> quantGroup = CqlfObjectGenerator.makeGroup("repetition");
Integer[] minmax = parseRepetition(quantification);
- quantGroup.put("boundary", makeBoundary(minmax[0], minmax[1]));
+ quantGroup.put("boundary", CqlfObjectGenerator.makeBoundary(minmax[0], minmax[1]));
if (minmax[0] != null) quantGroup.put("min", minmax[0]);
if (minmax[1] != null) quantGroup.put("max", minmax[1]);
addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-07-24: 'min' and 'max' to be " +
@@ -185,12 +187,12 @@
}
private void processSequence(ParseTree node) {
- LinkedHashMap<String,Object> sequence = makeGroup("sequence");
+ LinkedHashMap<String,Object> sequence = CqlfObjectGenerator.makeGroup("sequence");
ParseTree distanceNode = getFirstChildWithCat(node, "distance");
if (distanceNode!=null) {
Integer[] minmax = parseDistance(distanceNode);
- LinkedHashMap<String,Object> distance = makeDistance("w", minmax[0], minmax[1]);
+ LinkedHashMap<String,Object> distance = CqlfObjectGenerator.makeDistance("w", minmax[0], minmax[1]);
sequence.put("inOrder", true);
ArrayList<Object> distances = new ArrayList<Object>();
distances.add(distance);
@@ -211,9 +213,9 @@
Integer[] minmax = parseEmptySegments(node);
// object will be either a repetition group or a single empty token
LinkedHashMap<String,Object> object;
- LinkedHashMap<String,Object> emptyToken = makeToken();
+ LinkedHashMap<String,Object> emptyToken = CqlfObjectGenerator.makeToken();
if (minmax[0] != 1 || minmax[1] == null || minmax[1] != 1) {
- object = makeRepetition(minmax[0], minmax[1]);
+ object = CqlfObjectGenerator.makeRepetition(minmax[0], minmax[1]);
((ArrayList<Object>) object.get("operands")).add(emptyToken);
} else {
object = emptyToken;
@@ -228,14 +230,14 @@
if (hasChild(node, "spanclass_id")) {
classId = Integer.parseInt(node.getChild(1).getChild(0).toStringTree(parser));
}
- LinkedHashMap<String,Object> classGroup = makeSpanClass(classId, false);
+ LinkedHashMap<String,Object> classGroup = CqlfObjectGenerator.makeSpanClass(classId, false);
putIntoSuperObject(classGroup);
objectStack.push(classGroup);
stackedObjects++;
}
private void processToken(ParseTree node) {
- LinkedHashMap<String,Object> token = makeToken();
+ LinkedHashMap<String,Object> token = CqlfObjectGenerator.makeToken();
// handle negation
List<ParseTree> negations = getChildrenWithCat(node, "!");
boolean negated = false;
@@ -243,7 +245,7 @@
if (negations.size() % 2 == 1) negated = true;
if (getNodeCat(node.getChild(0)).equals("key")) {
// no 'term' child, but direct key specification: process here
- LinkedHashMap<String,Object> term = makeTerm();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
String key = node.getChild(0).getText();
if (getNodeCat(node.getChild(0).getChild(0)).equals("regex")) {
@@ -284,7 +286,7 @@
@SuppressWarnings("unchecked")
private void processAlignment(ParseTree node) {
- LinkedHashMap<String,Object> alignClass = makeSpanClass(++classCounter,false);
+ LinkedHashMap<String,Object> alignClass = CqlfObjectGenerator.makeSpanClass(++classCounter,false);
LinkedHashMap<String,Object> metaMap = (LinkedHashMap<String, Object>) requestMap.get("meta");
if (metaMap.containsKey("alignment")) {
ArrayList<Integer> alignedClasses = new ArrayList<Integer>();
@@ -308,7 +310,7 @@
List<ParseTree> negations = getChildrenWithCat(node, "!");
boolean negated = false;
if (negations.size() % 2 == 1) negated = true;
- LinkedHashMap<String,Object> span = makeSpan();
+ LinkedHashMap<String,Object> span = CqlfObjectGenerator.makeSpan();
ParseTree keyNode = getFirstChildWithCat(node, "key");
ParseTree layerNode = getFirstChildWithCat(node, "layer");
ParseTree foundryNode = getFirstChildWithCat(node, "foundry");
@@ -343,7 +345,7 @@
}
private void processDisjunction(ParseTree node) {
- LinkedHashMap<String,Object> disjunction = makeGroup("or");
+ LinkedHashMap<String,Object> disjunction = CqlfObjectGenerator.makeGroup("or");
putIntoSuperObject(disjunction);
objectStack.push(disjunction);
stackedObjects++;
@@ -357,8 +359,8 @@
}
private void processRelation(ParseTree node) {
- LinkedHashMap<String, Object> relationGroup = makeGroup("relation");
- LinkedHashMap<String, Object> relation = makeRelation();
+ LinkedHashMap<String, Object> relationGroup = CqlfObjectGenerator.makeGroup("relation");
+ LinkedHashMap<String, Object> relation = CqlfObjectGenerator.makeRelation();
relationGroup.put("relation", relation);
if (node.getChild(0).getText().equals("dominates")) {
relation.put("layer", "c");
@@ -375,7 +377,7 @@
}
if (repetition != null) {
Integer[] minmax = parseRepetition(repetition);
- relation.put("boundary", makeBoundary(minmax[0], minmax[1]));
+ relation.put("boundary", CqlfObjectGenerator.makeBoundary(minmax[0], minmax[1]));
}
putIntoSuperObject(relationGroup);
objectStack.push(relationGroup);
@@ -402,7 +404,7 @@
classId = 127;
}
}
- LinkedHashMap<String, Object> classGroup = makeSpanClass(classId, false);
+ LinkedHashMap<String, Object> classGroup = CqlfObjectGenerator.makeSpanClass(classId, false);
putIntoSuperObject(classGroup);
objectStack.push(classGroup);
stackedObjects++;
@@ -439,7 +441,7 @@
} else {
classRefs.add(1);
}
- LinkedHashMap<String, Object> referenceGroup = makeReference(classRefs);
+ LinkedHashMap<String, Object> referenceGroup = CqlfObjectGenerator.makeReference(classRefs);
String type = node.getChild(0).toStringTree(parser);
// Default is focus(), if deviating catch here
@@ -463,7 +465,7 @@
}
private void processSubmatch(ParseTree node) {
- LinkedHashMap<String,Object> submatch = makeReference(null);
+ LinkedHashMap<String,Object> submatch = CqlfObjectGenerator.makeReference(null);
submatch.put("operands", new ArrayList<Object>());
ParseTree startpos = getFirstChildWithCat(node,"startpos");
ParseTree length = getFirstChildWithCat(node,"length");
@@ -574,7 +576,7 @@
classRefCheck = new String[]{"classRefCheck:intersects"};
break;
}
- return makePosition(frames,classRefCheck);
+ return CqlfObjectGenerator.makePosition(frames,classRefCheck);
}
@@ -595,7 +597,7 @@
String nodeCat = getNodeCat(node);
if (nodeCat.equals("term")) {
String key = null;
- LinkedHashMap<String,Object> term = makeTerm();
+ LinkedHashMap<String,Object> term = CqlfObjectGenerator.makeTerm();
// handle negation
boolean negated = negatedGlobal;
boolean isRegex = false;
@@ -663,7 +665,7 @@
// establish boolean relation
ParseTree boolOp = getFirstChildWithCat(node, "boolOp");
String operator = boolOp.getText().equals("&") ? "and" : "or";
- termGroup = makeTermGroup(operator);
+ termGroup = CqlfObjectGenerator.makeTermGroup(operator);
ArrayList<Object> operands = (ArrayList<Object>) termGroup.get("operands");
// recursion with left/right operands
operands.add(parseTermOrTermGroup(leftOp, negatedGlobal, mode));
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/util/CqlfObjectGenerator.java b/src/main/java/de/ids_mannheim/korap/query/serialize/util/CqlfObjectGenerator.java
new file mode 100644
index 0000000..b03959d
--- /dev/null
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/util/CqlfObjectGenerator.java
@@ -0,0 +1,272 @@
+package de.ids_mannheim.korap.query.serialize.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+
+import de.ids_mannheim.korap.query.serialize.AbstractQueryProcessor;
+
+public class CqlfObjectGenerator {
+
+ protected static final Integer MAXIMUM_DISTANCE = 100;
+ private static AbstractQueryProcessor qp;
+
+ public static void setQueryProcessor(AbstractQueryProcessor qp) {
+ CqlfObjectGenerator.qp = qp;
+ }
+
+ public static LinkedHashMap<String, Object> makeSpan() {
+ LinkedHashMap<String, Object> span = new LinkedHashMap<String, Object>();
+ span.put("@type", "korap:span");
+ return span;
+ }
+
+ public static LinkedHashMap<String, Object> makeSpan(String key) {
+ LinkedHashMap<String, Object> span = new LinkedHashMap<String, Object>();
+ span.put("@type", "korap:span");
+ span.put("key", key);
+ return span;
+ }
+
+ public static LinkedHashMap<String, Object> makeTerm() {
+ LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
+ term.put("@type", "korap:term");
+ return term;
+ }
+
+ public static LinkedHashMap<String, Object> makeTermGroup(String relation) {
+ LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
+ term.put("@type", "korap:termGroup");
+ term.put("relation", "relation:"+relation);
+ term.put("operands", new ArrayList<Object>());
+ return term;
+ }
+
+ public static LinkedHashMap<String, Object> makeDoc() {
+ LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
+ term.put("@type", "korap:doc");
+ return term;
+ }
+
+ public static LinkedHashMap<String, Object> makeDocGroup(String relation) {
+ LinkedHashMap<String, Object> term = new LinkedHashMap<String, Object>();
+ term.put("@type", "korap:docGroup");
+ term.put("operation", "operation:"+relation);
+ term.put("operands", new ArrayList<Object>());
+ return term;
+ }
+
+ public static LinkedHashMap<String, Object> makeToken() {
+ LinkedHashMap<String, Object> token = new LinkedHashMap<String, Object>();
+ token.put("@type", "korap:token");
+ return token;
+ }
+
+ public static LinkedHashMap<String, Object> makeGroup(String operation) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:group");
+ group.put("operation", "operation:"+operation);
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeRepetition(Integer min, Integer max) {
+ LinkedHashMap<String, Object> group = makeGroup("repetition");
+ group.put("boundary", makeBoundary(min, max));
+ group.put("min", min);
+ return group;
+ }
+
+ @Deprecated
+ public static LinkedHashMap<String, Object> makePosition(String frame) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:group");
+ group.put("operation", "operation:position");
+ group.put("frame", "frame:"+frame);
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makePosition(String[] allowedFrames, String[] classRefCheck) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:group");
+ group.put("operation", "operation:position");
+ group.put("frames", Arrays.asList(allowedFrames));
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeSpanClass(int classCount) {
+ return makeSpanClass(classCount, true);
+ }
+
+ public static LinkedHashMap<String, Object> makeSpanClass(int classCount, boolean setBySystem) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:group");
+ group.put("operation", "operation:class");
+ if (setBySystem) {
+ group.put("class", 128+classCount);
+ group.put("classOut", 128+classCount);
+ qp.addMessage("A class has been introduced into the backend representation of " +
+ "your query for later reference to a part of the query. The class id is "+(128+classCount));
+ } else {
+ group.put("class", classCount);
+ group.put("classOut", classCount);
+ }
+ qp.addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-10-07: 'class' only to be supported until 3 months from deprecation date. " +
+ "Classes are now defined using the 'classOut' attribute.");
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeClassRefCheck(ArrayList<String> check, Integer[] classIn, int classOut) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:group");
+ group.put("operation", "operation:class");
+ group.put("classRefCheck", check);
+ group.put("classIn", Arrays.asList(classIn));
+ group.put("classOut", classOut);
+ group.put("class", classOut);
+ qp.addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-10-07: 'class' only to be supported until 3 months from deprecation date. " +
+ "Classes are now defined using the 'classOut' attribute.");
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeClassRefOp(String operation, Integer[] classIn, int classOut) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:group");
+ group.put("operation", "operation:class");
+ group.put("classRefOp", operation);
+ group.put("classIn", Arrays.asList(classIn));
+ group.put("classOut", classOut);
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ @Deprecated
+ public static LinkedHashMap<String, Object> makeTreeRelation(String reltype) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:treeRelation");
+ if (reltype != null) group.put("reltype", reltype);
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeRelation() {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:relation");
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeBoundary(Integer min, Integer max) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:boundary");
+ group.put("min", min);
+ if (max != null) {
+ group.put("max", max);
+ }
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeDistance(String key, Integer min, Integer max) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ if (key.equals("w")) {
+ group.put("@type", "korap:distance");
+ } else {
+ group.put("@type", "cosmas:distance");
+ }
+ group.put("key", key);
+ group.put("boundary", makeBoundary(min, max));
+ group.put("min", min);
+ if (max != null) {
+ group.put("max", max);
+ }
+ qp.addMessage(StatusCodes.DEPRECATED_QUERY_ELEMENT, "Deprecated 2014-07-24: 'min' and 'max' to be supported until 3 months from deprecation date.");
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeReference(ArrayList<Integer> classRefs, String operation) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:reference");
+ group.put("operation", "operation:"+operation);
+ if (classRefs!= null && !classRefs.isEmpty()) {
+ group.put("classRef", classRefs);
+ }
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeReference(ArrayList<Integer> classRefs) {
+ return makeReference(classRefs, "focus");
+ }
+
+ public static LinkedHashMap<String, Object> makeReference(int classRef, String operation, boolean setBySystem) {
+ ArrayList<Integer> classRefs = new ArrayList<Integer>();
+ if (setBySystem) classRef = classRef+128;
+ classRefs.add(classRef);
+ return makeReference(classRefs, operation);
+ }
+
+ public static LinkedHashMap<String, Object> makeReference(int classRef, boolean setBySystem) {
+ ArrayList<Integer> classRefs = new ArrayList<Integer>();
+ if (setBySystem) classRef = classRef+128;
+ classRefs.add(classRef);
+ return makeReference(classRefs, "focus");
+ }
+
+ public static LinkedHashMap<String, Object> makeReference(int classRef) {
+ return makeReference(classRef, false);
+ }
+
+ public static LinkedHashMap<String, Object> makeResetReference() {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:reference");
+ group.put("operation", "operation:focus");
+ group.put("reset", true);
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static LinkedHashMap<String, Object> makeSpanReference(Integer[] spanRef, String operation) {
+ LinkedHashMap<String, Object> group = new LinkedHashMap<String, Object>();
+ group.put("@type", "korap:reference");
+ group.put("operation", "operation:"+operation);
+ group.put("spanRef", Arrays.asList(spanRef));
+ group.put("operands", new ArrayList<Object>());
+ return group;
+ }
+
+ public static void addOperandsToGroup(LinkedHashMap<String, Object> group) {
+ ArrayList<Object> operands = new ArrayList<Object>();
+ group.put("operands", operands);
+ }
+
+ public static LinkedHashMap<String, Object> wrapInReference(LinkedHashMap<String, Object> group, Integer classId) {
+ LinkedHashMap<String, Object> refGroup = makeReference(classId);
+ ArrayList<Object> operands = new ArrayList<Object>();
+ operands.add(group);
+ refGroup.put("operands", operands);
+ return refGroup;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static LinkedHashMap<String, Object> wrapInClass(LinkedHashMap<String, Object> group, Integer classId) {
+ LinkedHashMap<String, Object> classGroup = makeSpanClass(classId, true);
+ ((ArrayList<Object>) classGroup.get("operands")).add(group);
+ return classGroup;
+ }
+
+ /**
+ * Ensures that a distance or quantification value does not exceed the allowed maximum value.
+ * @param number
+ * @return The input number if it is below the allowed maximum value, else the maximum value.
+ */
+ public static int cropToMaxValue(int number) {
+ if (number > MAXIMUM_DISTANCE) {
+ number = MAXIMUM_DISTANCE;
+ String warning = String.format("You specified a distance between two segments that is greater than " +
+ "the allowed max value of %d. Your query will be re-interpreted using a distance of %d.", MAXIMUM_DISTANCE, MAXIMUM_DISTANCE);
+ qp.addWarning(warning);
+ }
+ return number;
+ }
+}