updated to new notation
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/CosmasTree.java b/src/main/java/de/ids_mannheim/korap/query/serialize/CosmasTree.java
index a772a5c..2931ad4 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/CosmasTree.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/CosmasTree.java
@@ -119,32 +119,7 @@
return this.requestMap;
}
- private void prepareContext() {
- LinkedHashMap<String,Object> context = new LinkedHashMap<String,Object>();
- LinkedHashMap<String,Object> operands = new LinkedHashMap<String,Object>();
- LinkedHashMap<String,Object> relation = new LinkedHashMap<String,Object>();
- LinkedHashMap<String,Object> classMap = new LinkedHashMap<String,Object>();
-
- operands.put("@id", "korap:operands");
- operands.put("@container", "@list");
-
- relation.put("@id", "korap:relation");
- relation.put("@type", "korap:relation#types");
-
- classMap.put("@id", "korap:class");
- classMap.put("@type", "xsd:integer");
-
- context.put("korap", "http://korap.ids-mannheim.de/ns/query");
- context.put("@language", "de");
- context.put("@operands", operands);
- context.put("@relation", relation);
- context.put("class", classMap);
- context.put("query", "korap:query");
- context.put("filter", "korap:filter");
- context.put("meta", "korap:meta");
-
- requestMap.put("@context", context);
- }
+
@Override
public void process(String query) throws QueryException {
@@ -158,7 +133,7 @@
}
System.out.println("Processing Cosmas");
- prepareContext();
+ QueryUtils.prepareContext(requestMap);
processNode(tree);
}
@@ -202,8 +177,9 @@
if (hasSequentiableSiblings) {
// Step I: create sequence
LinkedHashMap<String, Object> sequence = new LinkedHashMap<String, Object>();
- sequence.put("@type", "korap:sequence");
- sequence.put("@operands", new ArrayList<Object>());
+ sequence.put("type", "group");
+ sequence.put("operation", "sequence");
+ sequence.put("operands", new ArrayList<Object>());
// push sequence on object stack but don't increment stackedObjects counter since
// we've got to wait until the parent node is processed - therefore, add the parent
// to the sequencedNodes list and remove the sequence from the stack when the parent
@@ -222,24 +198,24 @@
//Step I: get info
LinkedHashMap<String, Object> token = new LinkedHashMap<String, Object>();
- token.put("@type", "korap:token");
+ token.put("type", "token");
objectStack.push(token);
stackedObjects++;
LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
- token.put("@value", fieldMap);
+ token.put("key", fieldMap);
- fieldMap.put("@type", "korap:term");
+ fieldMap.put("type", "term");
// make category-specific fieldMap entry
String attr = nodeCat.equals("OPWF") ? "orth" : "lemma";
String value = node.getChild(0).toStringTree().replaceAll("\"", "");
- fieldMap.put("@value", value);
- fieldMap.put("@attr", attr);
+ fieldMap.put("key", value);
+ fieldMap.put("layer", attr);
// negate field (see above)
if (negate) {
- fieldMap.put("@relation", "!=");
+ fieldMap.put("match", "ne");
} else {
- fieldMap.put("@relation", "=");
+ fieldMap.put("match", "eq");
}
//Step II: decide where to put
putIntoSuperObject(token, 1);
@@ -248,54 +224,54 @@
if (nodeCat.equals("OPMORPH")) {
//Step I: get info
LinkedHashMap<String, Object> token = new LinkedHashMap<String, Object>();
- token.put("@type", "korap:token");
+ token.put("type", "token");
LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
- token.put("@value", fieldMap);
+ token.put("key", fieldMap);
- fieldMap.put("@type", "korap:term");
-// fieldMap.put("@value", "morph:"+node.getChild(0).toString().replace(" ", "_"));
- fieldMap.put("@value", node.getChild(0).toString().replace(" ", "_"));
+ fieldMap.put("type", "term");
+// fieldMap.put("key", "morph:"+node.getChild(0).toString().replace(" ", "_"));
+ fieldMap.put("key", node.getChild(0).toString().replace(" ", "_"));
// make category-specific fieldMap entry
// negate field (see above)
if (negate) {
- fieldMap.put("@relation", "!=");
+ fieldMap.put("match", "ne");
} else {
- fieldMap.put("@relation", "=");
+ fieldMap.put("match", "eq");
}
// List<String> morphValues = QueryUtils.parseMorph(node.getChild(0).toStringTree());
// System.err.println(morphValues);
// if (morphValues.size() == 1) {
// LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
-// token.put("@value", fieldMap);
+// token.put("key", fieldMap);
//
-// fieldMap.put("@type", "korap:term");
-// fieldMap.put("@value", morphValues.get(0));
+// fieldMap.put("type", "term");
+// fieldMap.put("key", morphValues.get(0));
// // make category-specific fieldMap entry
// // negate field (see above)
// if (negate) {
-// fieldMap.put("@relation", "!=");
+// fieldMap.put("operation", "!=");
// } else {
-// fieldMap.put("@relation", "=");
+// fieldMap.put("operation", "=");
// }
// } else {
// LinkedHashMap<String, Object> conjGroup = new LinkedHashMap<String, Object>();
-// token.put("@value", conjGroup);
+// token.put("key", conjGroup);
// ArrayList<Object> conjOperands = new ArrayList<Object>();
-// conjGroup.put("@type", "korap:group");
-// conjGroup.put("@relation", "and");
-// conjGroup.put("@operands", conjOperands);
+// conjGroup.put("type", "group");
+// conjGroup.put("operation", "and");
+// conjGroup.put("operands", conjOperands);
// for (String value : morphValues) {
// LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
-// token.put("@value", fieldMap);
+// token.put("key", fieldMap);
//
-// fieldMap.put("@type", "korap:term");
-// fieldMap.put("@value", value);
+// fieldMap.put("type", "term");
+// fieldMap.put("key", value);
// // make category-specific fieldMap entry
// // negate field (see above)
// if (negate) {
-// fieldMap.put("@relation", "!=");
+// fieldMap.put("operation", "!=");
// } else {
-// fieldMap.put("@relation", "=");
+// fieldMap.put("operation", "=");
// }
// }
// }
@@ -308,8 +284,8 @@
if (nodeCat.equals("OPELEM")) {
// Step I: create element
LinkedHashMap<String, Object> elem = new LinkedHashMap<String, Object>();
- elem.put("@type", "korap:span");
- elem.put("@value", node.getChild(0).getChild(0).toStringTree().toLowerCase());
+ elem.put("type", "span");
+ elem.put("key", node.getChild(0).getChild(0).toStringTree().toLowerCase());
//Step II: decide where to put
putIntoSuperObject(elem);
}
@@ -317,8 +293,8 @@
if (nodeCat.equals("OPLABEL")) {
// Step I: create element
LinkedHashMap<String, Object> elem = new LinkedHashMap<String, Object>();
- elem.put("@type", "korap:span");
- elem.put("@value", node.getChild(0).toStringTree().replaceAll("<|>", ""));
+ elem.put("type", "span");
+ elem.put("key", node.getChild(0).toStringTree().replaceAll("<|>", ""));
//Step II: decide where to put
putIntoSuperObject(elem);
}
@@ -326,12 +302,12 @@
if (nodeCat.equals("OPOR") || nodeCat.equals("OPAND") || nodeCat.equals("OPNOT")) {
// Step I: create group
LinkedHashMap<String, Object> disjunction = new LinkedHashMap<String, Object>();
- disjunction.put("@type", "korap:group");
+ disjunction.put("type", "group");
String relation = "or";
if (nodeCat.equals("OPAND")) relation = "and";
if (nodeCat.equals("OPNOT")) relation = "not";
- disjunction.put("@relation", relation);
- disjunction.put("@operands", new ArrayList<Object>());
+ disjunction.put("operation", relation);
+ disjunction.put("operands", new ArrayList<Object>());
objectStack.push(disjunction);
stackedObjects++;
// Step II: decide where to put
@@ -346,7 +322,8 @@
Tree dist_list = prox_opts.getChild(1);
// Step I: create group
LinkedHashMap<String, Object> proxSequence = new LinkedHashMap<String, Object>();
- proxSequence.put("@type", "korap:sequence");
+ proxSequence.put("type", "group");
+ proxSequence.put("operation", "sequence");
objectStack.push(proxSequence);
stackedObjects++;
// if (openNodeCats.get(1).equals("OPALL")) proxSequence.put("match", "all");
@@ -356,11 +333,11 @@
boolean exclusion = ! typ.getChild(0).toStringTree().equals("PROX");
String inOrder = "true";
- proxSequence.put("@inOrder", inOrder);
- proxSequence.put("@constraints", constraints);
+ proxSequence.put("inOrder", inOrder);
+ proxSequence.put("distances", constraints);
ArrayList<Object> operands = new ArrayList<Object>();
- proxSequence.put("@operands", operands);
+ proxSequence.put("operands", operands);
// if only one dist_info, put directly into constraints
if (dist_list.getChildCount()==1) {
@@ -378,24 +355,24 @@
inOrder="false";
}
LinkedHashMap<String, Object> distance = new LinkedHashMap<String, Object>();
- distance.put("@type", "korap:distance");
- distance.put("@measure", meas);
- distance.put("@min", Integer.parseInt(min));
- distance.put("@max", Integer.parseInt(max));
+ distance.put("type", "distance");
+ distance.put("measure", meas);
+ distance.put("min", Integer.parseInt(min));
+ distance.put("max", Integer.parseInt(max));
if (exclusion) {
- distance.put("@exclude", exclusion);
+ distance.put("exclude", exclusion);
}
constraints.add(distance);
- proxSequence.put("@inOrder", inOrder);
+ proxSequence.put("inOrder", inOrder);
}
// otherwise, create group and add info there
else {
LinkedHashMap<String, Object> distanceGroup = new LinkedHashMap<String, Object>();
ArrayList<Object> groupOperands = new ArrayList<Object>();
- distanceGroup.put("@type", "korap:group");
- distanceGroup.put("@relation", "and");
- distanceGroup.put("@operands", groupOperands);
+ distanceGroup.put("type", "group");
+ distanceGroup.put("operation", "and");
+ distanceGroup.put("operands", groupOperands);
constraints.add(distanceGroup);
for (int i=0; i<dist_list.getChildCount(); i++) {
String direction = dist_list.getChild(i).getChild(0).getChild(0).toStringTree().toLowerCase();
@@ -406,12 +383,12 @@
min=max;
}
LinkedHashMap<String, Object> distance = new LinkedHashMap<String, Object>();
- distance.put("@type", "korap:distance");
- distance.put("@measure", meas);
- distance.put("@min", min);
- distance.put("@max", max);
+ distance.put("type", "distance");
+ distance.put("measure", meas);
+ distance.put("min", min);
+ distance.put("max", max);
if (exclusion) {
- distance.put("@exclude", exclusion);
+ distance.put("exclude", exclusion);
}
groupOperands.add(distance);
if (direction.equals("plus")) {
@@ -421,7 +398,7 @@
invertedOperandsLists.add(operands);
}
}
- proxSequence.put("@inOrder", inOrder);
+ proxSequence.put("inOrder", inOrder);
}
// Step II: decide where to put
putIntoSuperObject(proxSequence, 1);
@@ -431,24 +408,24 @@
if (nodeCat.equals("OPIN") || nodeCat.equals("OPOV")) {
// Step I: create group
LinkedHashMap<String, Object> submatchgroup = new LinkedHashMap<String, Object>();
- submatchgroup.put("@type", "korap:group");
- submatchgroup.put("@relation", "submatch");
- submatchgroup.put("@classRef", "1");
+ submatchgroup.put("type", "group");
+ submatchgroup.put("operation", "submatch");
+ submatchgroup.put("classRef", "1");
ArrayList<Object> submatchoperands = new ArrayList<Object>();
LinkedHashMap<String, Object> posgroup = new LinkedHashMap<String, Object>();
- submatchgroup.put("@operands", submatchoperands);
+ submatchgroup.put("operands", submatchoperands);
submatchoperands.add(posgroup);
- posgroup.put("@type", "korap:group");
+ posgroup.put("type", "group");
// String relation = nodeCat.equals("OPIN") ? "position" : "overlaps";
- posgroup.put("@relation", "position");
+ posgroup.put("operation", "position");
if (nodeCat.equals("OPIN")) {
parseOPINOptions(node, posgroup);
} else {
parseOPOVOptions(node, posgroup);
}
ArrayList<Object> posoperands = new ArrayList<Object>();
- posgroup.put("@operands", posoperands);
+ posgroup.put("operands", posoperands);
objectStack.push(posgroup);
// mark this an inverted list
invertedOperandsLists.push(posoperands);
@@ -462,9 +439,10 @@
if (nodeCat.equals("ARG1") && (openNodeCats.get(1).equals("OPIN") || openNodeCats.get(1).equals("OPOV"))) {
// Step I: create group
LinkedHashMap<String, Object> classGroup = new LinkedHashMap<String, Object>();
- classGroup.put("@type", "korap:group");
+ classGroup.put("type", "group");
+ classGroup.put("operation", "class");
classGroup.put("class", "1");
- classGroup.put("@operands", new ArrayList<Object>());
+ classGroup.put("operands", new ArrayList<Object>());
objectStack.push(classGroup);
stackedObjects++;
// Step II: decide where to put
@@ -475,15 +453,15 @@
if (nodeCat.equals("OPNHIT")) {
// proxGroupMatching = nodeCat.equals("OPALL") ? "all" : "exclude";
LinkedHashMap<String, Object> exclGroup = new LinkedHashMap<String, Object>();
- exclGroup.put("@type", "korap:group");
- exclGroup.put("@relation", "shrink");
+ exclGroup.put("type", "group");
+ exclGroup.put("operation", "shrink");
ArrayList<Integer> classRef = new ArrayList<Integer>();
classRef.add(1);
classRef.add(2);
exclGroup.put("classRef", classRef);
exclGroup.put("classRefOp", "intersection");
ArrayList<Object> operands = new ArrayList<Object>();
- exclGroup.put("@operands", operands);
+ exclGroup.put("operands", operands);
objectStack.push(exclGroup);
stackedObjects++;
putIntoSuperObject(exclGroup, 1);
@@ -492,8 +470,8 @@
if (nodeCat.equals("OPEND") || nodeCat.equals("OPBEG")) {
// Step I: create group
LinkedHashMap<String, Object> beggroup = new LinkedHashMap<String, Object>();
- beggroup.put("@type", "korap:group");
- beggroup.put("@relation", "submatch");
+ beggroup.put("type", "group");
+ beggroup.put("operation", "submatch");
ArrayList<Integer> spanRef = new ArrayList<Integer>();
if (nodeCat.equals("OPBEG")) {
spanRef.add(0); spanRef.add(1);
@@ -501,7 +479,7 @@
spanRef.add(-1); spanRef.add(1);
}
beggroup.put("@spanRef", spanRef);
- beggroup.put("@operands", new ArrayList<Object>());
+ beggroup.put("operands", new ArrayList<Object>());
objectStack.push(beggroup);
stackedObjects++;
@@ -516,17 +494,17 @@
// Distinguish two cases. Normal case: query has just one condition, like #BED(XY, sa) ...
if (conditions.getChildCount()==1) {
LinkedHashMap<String, Object> posgroup = new LinkedHashMap<String, Object>();
- posgroup.put("@type", "korap:group");
- posgroup.put("@relation", "position");
+ posgroup.put("type", "group");
+ posgroup.put("operation", "position");
CosmasCondition c = new CosmasCondition(conditions.getChild(0));
- posgroup.put("@position", c.position);
- if (c.negated) posgroup.put("@relation", "!=");
+ posgroup.put("frame", c.position);
+ if (c.negated) posgroup.put("operation", "!=");
ArrayList<Object> operands = new ArrayList<Object>();
- posgroup.put("@operands", operands);
+ posgroup.put("operands", operands);
LinkedHashMap<String, Object> bedElem = new LinkedHashMap<String, Object>();
operands.add(bedElem);
- bedElem.put("@type", "korap:span");
- bedElem.put("@value", c.elem);
+ bedElem.put("type", "span");
+ bedElem.put("key", c.elem);
objectStack.push(posgroup);
stackedObjects++;
// Step II: decide where to put
@@ -537,10 +515,10 @@
// node has several conditions (like 'sa, -pa')
// -> create 'and' group and embed all position groups there
LinkedHashMap<String, Object> conjunct = new LinkedHashMap<String, Object>();
- conjunct.put("@type", "korap:group");
- conjunct.put("@relation", "and");
+ conjunct.put("type", "group");
+ conjunct.put("operation", "and");
ArrayList<Object> operands = new ArrayList<Object>();
- conjunct.put("@operands", operands);
+ conjunct.put("operands", operands);
ArrayList<ArrayList<Object>> distributedOperands = new ArrayList<ArrayList<Object>>();
for (int i=0; i<conditions.getChildCount(); i++) {
@@ -550,17 +528,17 @@
operands.add(posGroup);
CosmasCondition c = new CosmasCondition(conditions.getChild(i));
- posGroup.put("@type", "korap:group");
- posGroup.put("@relation", "position");
- posGroup.put("@position", c.position);
- if (c.negated) posGroup.put("@exclude", "true");
+ posGroup.put("type", "group");
+ posGroup.put("operation", "position");
+ posGroup.put("frame", c.position);
+ if (c.negated) posGroup.put("exclude", "true");
ArrayList<Object> posOperands = new ArrayList<Object>();
distributedOperands.add(posOperands);
- posGroup.put("@operands", posOperands);
+ posGroup.put("operands", posOperands);
LinkedHashMap<String, Object> bedElem = new LinkedHashMap<String, Object>();
posOperands.add(bedElem);
- bedElem.put("@type", "korap:span");
- bedElem.put("@value", c.elem);
+ bedElem.put("type", "span");
+ bedElem.put("key", c.elem);
}
@@ -632,7 +610,7 @@
} else {
position = "contains";
}
- posgroup.put("@position", position);
+ posgroup.put("frame", position);
position = openNodeCats.get(1).equals("OPIN") ? "contains" : "full";
if (rangenode != null) {
@@ -647,7 +625,7 @@
}
System.err.println(negatePosition);
if (negatePosition) {
- posgroup.put("@exclude", "true");
+ posgroup.put("exclude", "true");
// negate = !negate;
}
@@ -667,11 +645,11 @@
String value = posnode.getChild(0).toStringTree();
position = "-"+translateTextAreaArgument(value, "ov");
}
- posgroup.put("@position", "overlaps"+position);
+ posgroup.put("frame", "overlaps"+position);
if (exclnode != null) {
if (exclnode.getChild(0).toStringTree().equals("YES")) {
- posgroup.put("@relation", "!=");
+ posgroup.put("match", "ne");
}
}
if (groupnode != null) {
@@ -726,7 +704,7 @@
operands.add(object);
}
} else if (objectStack.size()>objStackPosition) {
- ArrayList<Object> topObjectOperands = (ArrayList<Object>) objectStack.get(objStackPosition).get("@operands");
+ ArrayList<Object> topObjectOperands = (ArrayList<Object>) objectStack.get(objStackPosition).get("operands");
if (!invertedOperandsLists.contains(topObjectOperands)) {
topObjectOperands.add(object);
} else {
@@ -776,7 +754,13 @@
// "(Mann oder Frau) #IN <s>",
// "#BEG(der /w3:5 Mann) /+w10 kommt",
// "&würde /w0 MORPH(V)",
- "#NHIT(gehen /w1:10 voran)"
+ "#NHIT(gehen /w1:10 voran)",
+ "Der Mann",
+ "Der /+w1:3 Mann",
+ "Der /+w1:3,s1 Mann",
+ "(Der /+w1:3,s1 Mann) /+w5 geht",
+ "(Der /+w1:3,s1 Mann) /-w5 geht",
+ "(Der /+w1:3,s1 Mann) /+w5 (geht weg)",
};
CosmasTree.debug=true;
for (String q : queries) {
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusTree.java b/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusTree.java
index 470603a..7fa8b5e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusTree.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/PoliqarpPlusTree.java
@@ -161,33 +161,6 @@
log.info(">>> " + requestMap.get("query") + " <<<");
}
- private void prepareContext() {
- LinkedHashMap<String,Object> context = new LinkedHashMap<String,Object>();
- LinkedHashMap<String,Object> operands = new LinkedHashMap<String,Object>();
- LinkedHashMap<String,Object> relation = new LinkedHashMap<String,Object>();
- LinkedHashMap<String,Object> classMap = new LinkedHashMap<String,Object>();
-
- operands.put("@id", "korap:operands");
- operands.put("@container", "@list");
-
- relation.put("@id", "korap:relation");
- relation.put("@type", "korap:relation#types");
-
- classMap.put("@id", "korap:class");
- classMap.put("@type", "xsd:integer");
-
- context.put("korap", "http://korap.ids-mannheim.de/ns/query");
- context.put("@language", "de");
- context.put("@operands", operands);
- context.put("@relation", relation);
- context.put("class", classMap);
- context.put("query", "korap:query");
- context.put("filter", "korap:filter");
- context.put("meta", "korap:meta");
-
- requestMap.put("@context", context);
- }
-
@Override
public Map<String, Object> getRequestMap() {
return requestMap;
@@ -206,7 +179,7 @@
}
}
System.out.println("Processing PoliqarpPlus");
- prepareContext();
+ QueryUtils.prepareContext(requestMap);
processNode(tree);
}
@@ -286,23 +259,25 @@
String[] minmax = parseEmptySegments(emptySegments);
Integer min = Integer.parseInt(minmax[0]);
Integer max = Integer.parseInt(minmax[1]);
- sequence.put("@type", "korap:sequence");
-// sequence.put("@relation", "distance");
- sequence.put("@inOrder", "true");
+ sequence.put("type", "group");
+ sequence.put("operation", "sequence");
+// sequence.put("operation", "distance");
+ sequence.put("inOrder", "true");
ArrayList<Object> constraint = new ArrayList<Object>();
- sequence.put("@constraints", constraint);
+ sequence.put("distances", constraint);
ArrayList<Object> sequenceOperands = new ArrayList<Object>();
- sequence.put("@operands", sequenceOperands);
+ sequence.put("operands", sequenceOperands);
objectStack.push(sequence);
stackedObjects++;
LinkedHashMap<String, Object> distMap = new LinkedHashMap<String, Object>();
constraint.add(distMap);
- distMap.put("@type", "korap:distance");
+ distMap.put("type", "distance");
distMap.put("measure", "w");
distMap.put("min", min);
distMap.put("max", max);
} else {
- sequence.put("@type", "korap:sequence");
+ sequence.put("type", "group");
+ sequence.put("operation", "sequence");
ArrayList<Object> sequenceOperands = new ArrayList<Object>();
if (emptySegments != null) {
String[] minmax = parseEmptySegments(emptySegments);
@@ -311,30 +286,30 @@
sequence.put("offset-min", min);
sequence.put("offset-max", max);
}
- sequence.put("@operands", sequenceOperands);
+ sequence.put("operands", sequenceOperands);
objectStack.push(sequence);
stackedObjects++;
}
} else {
- // if only child, make the sequence a mere korap:token...
+ // if only child, make the sequence a mere token...
// ... but only if it has a real token/element beneath it
if (QueryUtils.getNodeCat(node.getChild(0)).equals("cq_segment")
|| QueryUtils.getNodeCat(node.getChild(0)).equals("sq_segment")
|| QueryUtils.getNodeCat(node.getChild(0)).equals("element") ) {
- sequence.put("@type", "korap:token");
+ sequence.put("type", "token");
tokenStack.push(sequence);
stackedTokens++;
objectStack.push(sequence);
stackedObjects++;
// else, it's a group (with shrink()/spanclass/align... as child)
} else {
- sequence.put("@type", "korap:group");
+ sequence.put("type", "group");
}
}
// Step II: decide where to put this element
// check if this is an argument for a containing occurrence group (see step 0)
if (cqHasOccSibling) {
- ArrayList<Object> topGroupOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topGroupOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topGroupOperands.add(sequence);
// ...if not modified by occurrence, put into suitable super structure
} else {
@@ -348,22 +323,23 @@
if (node.getParent().getChild(0).equals(node)) {
// if first child, create containing sequence and embed there
LinkedHashMap<String,Object> superSequence = new LinkedHashMap<String,Object>();
- superSequence.put("@type", "korap:sequence");
+ superSequence.put("type", "group");
+ superSequence.put("operation", "sequence");
ArrayList<Object> operands = new ArrayList<Object>();
- superSequence.put("@operands", operands);
+ superSequence.put("operands", operands);
operands.add(sequence);
requestMap.put("query", superSequence);
objectStack.push(superSequence); // add at 2nd position to keep current cq_segment accessible
stackedObjects++;
} else {
// if not first child, add to previously created parent sequence
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(sequence);
}
}
} else if (!objectStack.isEmpty()){
// embed in super sequence
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(sequence);
}
}
@@ -389,7 +365,7 @@
}
curToken = token;
// Step II: start filling object and add to containing sequence
- token.put("@type", "korap:token");
+ token.put("type", "token");
// add token to sequence only if it is not an only child (in that case, cq_segments has already added the info and is just waiting for the values from "field")
// take into account a possible 'occ' child
if (node.getParent().getChildCount()>1) {
@@ -404,7 +380,7 @@
// }
//
} else {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(onTopOfObjectStack).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(onTopOfObjectStack).get("operands");
topSequenceOperands.add(token);
}
}
@@ -414,14 +390,14 @@
if (nodeCat.equals("cq_seg_occ")) {
LinkedHashMap<String,Object> group = new LinkedHashMap<String,Object>();
curOccGroup = group;
- group.put("@type", "korap:group");
- group.put("@operands", new ArrayList<Object>());
+ group.put("type", "group");
+ group.put("operands", new ArrayList<Object>());
objectStack.push(group);
stackedObjects++;
// add group to sequence only if it is not an only child (in that case, cq_segments has already added the info and is just waiting for the values from "field")
// take into account a possible 'occ' child
if (node.getParent().getChildCount()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(group);
} else {
requestMap.put("query", group);
@@ -434,14 +410,14 @@
objectStack.push(disjunction);
stackedObjects++;
ArrayList<Object> disjOperands = new ArrayList<Object>();
- disjunction.put("@type", "korap:group");
- disjunction.put("@relation", "or");
- disjunction.put("@operands", disjOperands);
+ disjunction.put("type", "group");
+ disjunction.put("operation", "or");
+ disjunction.put("operands", disjOperands);
// decide where to put the disjunction
if (openNodeCats.get(1).equals("query")) {
requestMap.put("query", disjunction);
} else if (openNodeCats.get(1).equals("cq_segments")) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(disjunction);
}
}
@@ -457,6 +433,7 @@
} else if (fieldNameNode.getChildCount() == 3) {
// layer is indicated, merge layer and field name (0th and 2nd children, 1st is "/")
String layer = fieldNameNode.getChild(0).toStringTree(poliqarpParser);
+ if (layer.equals("base")) layer="lemma";
String layeredFieldName = fieldNameNode.getChild(2).toStringTree(poliqarpParser);
fieldName = layer+"/"+layeredFieldName;
}
@@ -469,31 +446,38 @@
relation = "!"+relation;
}
}
+ if (relation.equals("=")) {
+ relation="eq";
+ }
+ if (relation.equals("!=")) {
+ relation="ne";
+ }
String value = "";
ParseTree valNode = node.getChild(2);
String valType = QueryUtils.getNodeCat(valNode);
- fieldMap.put("@type", "korap:term");
+ fieldMap.put("type", "term");
if (valType.equals("simple_query")) {
value = valNode.getChild(0).getChild(0).toStringTree(poliqarpParser); //e.g. (simple_query (sq_segment foo))
} else if (valType.equals("re_query")) {
value = valNode.getChild(0).toStringTree(poliqarpParser); //e.g. (re_query "bar*")
- fieldMap.put("@subtype", "korap:value#regex");
+ fieldMap.put("@subtype", "value#regex");
}
- fieldMap.put("@value", value);
+ fieldMap.put("key", value);
if (fieldName.contains("/")) {
String[] splitted = fieldName.split("/");
- fieldMap.put("@attr", splitted[1]);
- fieldMap.put("@foundry", splitted[0]);
+ fieldMap.put("layer", splitted[1]);
+ fieldMap.put("foundry", splitted[0]);
} else {
- fieldMap.put("@attr", fieldName);
+ if (fieldName.equals("base")) fieldName = "lemma";
+ fieldMap.put("layer", fieldName);
}
- fieldMap.put("@relation", relation);
+ fieldMap.put("match", relation);
// Step II: decide where to put the field map (as the only value of a token or the meta filter or as a part of a group in case of coordinated fields)
if (fieldStack.isEmpty()) {
if (!inMeta) {
- tokenStack.getFirst().put("@value", fieldMap);
+ tokenStack.getFirst().put("key", fieldMap);
} else {
- ((HashMap<String, Object>) requestMap.get("meta")).put("@value", fieldMap);
+ ((HashMap<String, Object>) requestMap.get("meta")).put("key", fieldMap);
}
} else {
fieldStack.getFirst().add(fieldMap);
@@ -511,8 +495,8 @@
if (nodeCat.equals("conj_field")) {
LinkedHashMap<String,Object> group = new LinkedHashMap<String,Object>();
ArrayList<Object> groupOperands = new ArrayList<Object>();
- group.put("@type", "korap:group");
- group.put("@operands", groupOperands);
+ group.put("type", "group");
+ group.put("operands", groupOperands);
fieldStack.push(groupOperands);
stackedFields++;
// Step I: get operator (& or |)
@@ -522,16 +506,16 @@
if (negField) {
relation = relation.equals("or") ? "and": "or";
}
- group.put("@relation", relation);
+ group.put("operation", relation);
// Step II: decide where to put the group (directly under token or in top meta filter section or embed in super group)
if (openNodeCats.get(1).equals("cq_segment")) {
- tokenStack.getFirst().put("@value", group);
+ tokenStack.getFirst().put("key", group);
} else if (openNodeCats.get(1).equals("meta_field_group")) {
- ((HashMap<String, Object>) requestMap.get("meta")).put("@value", group);
+ ((HashMap<String, Object>) requestMap.get("meta")).put("key", group);
} else if (openNodeCats.get(2).equals("conj_field")) {
fieldStack.get(1).add(group);
} else {
- tokenStack.getFirst().put("@value", group);
+ tokenStack.getFirst().put("key", group);
}
// skip the operator
visited.add(node.getChild(1));
@@ -556,17 +540,17 @@
if (node.getText().equals("[]")) {
} else {
- token.put("@type", "korap:token");
+ token.put("type", "token");
String word = node.getChild(0).toStringTree(poliqarpParser);
LinkedHashMap<String,Object> tokenValues = new LinkedHashMap<String,Object>();
- token.put("@value", tokenValues);
- tokenValues.put("@type", "korap:term");
- tokenValues.put("@value", word);
- tokenValues.put("@attr", "orth");
- tokenValues.put("@relation", "=");
+ token.put("key", tokenValues);
+ tokenValues.put("type", "term");
+ tokenValues.put("key", word);
+ tokenValues.put("layer", "orth");
+ tokenValues.put("match", "eq");
// add token to sequence only if it is not an only child (in that case, sq_segments has already added the info and is just waiting for the values from "field")
if (node.getParent().getChildCount()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(token);
}
}
@@ -575,22 +559,22 @@
if (nodeCat.equals("re_query")) {
LinkedHashMap<String,Object> reQuery = new LinkedHashMap<String,Object>();
- reQuery.put("@subtype", "korap:regex");
+ reQuery.put("@subtype", "regex");
String regex = node.getChild(0).toStringTree(poliqarpParser);
- reQuery.put("@value", regex);
- reQuery.put("@relation", "=");
+ reQuery.put("key", regex);
+ reQuery.put("match", "eq");
// if in field, regex was already added there
if (!openNodeCats.get(1).equals("field")) {
LinkedHashMap<String,Object> token = new LinkedHashMap<String,Object>();
- token.put("@type", "korap:token");
- token.put("@value", reQuery);
- reQuery.put("@type", "korap:term");
+ token.put("type", "token");
+ token.put("key", reQuery);
+ reQuery.put("type", "term");
if (openNodeCats.get(1).equals("query")) {
requestMap.put("query", token);
} else {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(token);
}
}
@@ -607,18 +591,18 @@
stackedObjects++;
// Step I: get info
// fill group
- alignGroup.put("@type", "korap:group");
- alignGroup.put("@alignment", "left");
- alignGroup.put("@operands", new ArrayList<Object>());
+ alignGroup.put("type", "group");
+ alignGroup.put("alignment", "left");
+ alignGroup.put("operands", new ArrayList<Object>());
// Step II: decide where to put the group
// add group to sequence only if it is not an only child (in that case, sq_segments has already added the info and is just waiting for the relevant info)
if (node.getParent().getChildCount()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(alignGroup);
} else if (openNodeCats.get(2).equals("query")) {
requestMap.put("query", alignGroup);
} else {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(alignGroup);
}
visited.add(node.getChild(0));
@@ -637,12 +621,12 @@
objectStack.push(elem);
stackedObjects++;
// Step II: fill object (token values) and put into containing sequence
- elem.put("@type", "korap:span");
+ elem.put("type", "span");
String value = node.getChild(1).toStringTree(poliqarpParser);
- elem.put("@value", value);
+ elem.put("key", value);
// add token to sequence only if it is not an only child (in that case, cq_segments has already added the info and is just waiting for the values from "field")
if (node.getParent().getChildCount()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(elem);
}
visited.add(node.getChild(0));
@@ -652,8 +636,8 @@
if (nodeCat.equals("spanclass")) {
LinkedHashMap<String,Object> span = new LinkedHashMap<String,Object>();
- span.put("@type", "korap:group");
- span.put("@relation", "class");
+ span.put("type", "group");
+ span.put("operation", "class");
objectStack.push(span);
stackedObjects++;
ArrayList<Object> spanOperands = new ArrayList<Object>();
@@ -664,7 +648,7 @@
try {
classId = Integer.parseInt(ref);
} catch (NumberFormatException e) {
- throw new QueryException("The specified class reference in the shrink/split-Operator is not a number.");
+ throw new QueryException("The specified class reference in the shrink/split-Operator is not a number: "+ref);
}
// only allow class id up to 255
if (classId>255) {
@@ -672,13 +656,13 @@
}
}
span.put("class", classId);
- span.put("@operands", spanOperands);
+ span.put("operands", spanOperands);
// Step II: decide where to put the span
// add span to sequence only if it is not an only child (in that case, cq_segments has already added the info and is just waiting for the relevant info)
if (openNodeCats.get(2).equals("query") && node.getParent().getChildCount() == 1) {
requestMap.put("query", span);
} else if (objectStack.size()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(span);
}
// ignore leading and trailing braces
@@ -696,20 +680,20 @@
ArrayList<Object> posOperands = new ArrayList<Object>();
// Step I: get info
String relation = QueryUtils.getNodeCat(node.getChild(0));
- positionGroup.put("@type", "korap:group");
- positionGroup.put("@relation", "position");
- positionGroup.put("@position", relation.toLowerCase());
+ positionGroup.put("type", "group");
+ positionGroup.put("operation", "position");
+ positionGroup.put("frame", relation.toLowerCase());
// positionGroup.put("@subtype", "incl");
- positionGroup.put("@operands", posOperands);
+ positionGroup.put("operands", posOperands);
// Step II: decide where to put the group
// add group to sequence only if it is not an only child (in that case, sq_segments has already added the info and is just waiting for the relevant info)
if (node.getParent().getChildCount()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(positionGroup);
} else if (openNodeCats.get(2).equals("query")) {
requestMap.put("query", positionGroup);
} else {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(positionGroup);
}
}
@@ -746,23 +730,25 @@
} else {
classRefs.add(0);
}
- shrinkGroup.put("@type", "korap:group");
- shrinkGroup.put("@relation", node.getChild(0).toStringTree(poliqarpParser));
+ shrinkGroup.put("type", "group");
+ String type = node.getChild(0).toStringTree(poliqarpParser);
+ String operation = type.equals("shrink") ? "submatch" : "split";
+ shrinkGroup.put("operation", operation);
shrinkGroup.put("classRef", classRefs);
if (classRefOp != null) {
shrinkGroup.put("classRefOp", classRefOp);
}
- shrinkGroup.put("@operands", shrinkOperands);
+ shrinkGroup.put("operands", shrinkOperands);
int i=1;
// Step II: decide where to put the group
// add group to sequence only if it is not an only child (in that case, sq_segments has already added the info and is just waiting for the relevant info)
if (node.getParent().getChildCount()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(i).get("@operands"); // this shrinkGroup is on top
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(i).get("operands"); // this shrinkGroup is on top
topSequenceOperands.add(shrinkGroup);
} else if (openNodeCats.get(2).equals("query")) {
requestMap.put("query", shrinkGroup);
} else if (objectStack.size()>1) {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(i).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(i).get("operands");
topSequenceOperands.add(shrinkGroup);
}
visited.add(node.getChild(0));
@@ -773,7 +759,7 @@
ParseTree occChild = node.getChild(0);
String repetition = occChild.toStringTree(poliqarpParser);
String[] minmax = parseRepetition(repetition);
- curOccGroup.put("@relation", "repetition");
+ curOccGroup.put("operation", "repetition");
curOccGroup.put("@min", minmax[0]);
curOccGroup.put("@max", minmax[1]);
visited.add(occChild);
@@ -783,14 +769,14 @@
if (nodeCat.equals("flag")) {
String flag = QueryUtils.getNodeCat(node.getChild(0)).substring(1); //substring removes leading slash '/'
// add to current token's value
- ((HashMap<String, Object>) curToken.get("@value")).put("flag", flag);
+ ((HashMap<String, Object>) curToken.get("key")).put("flag", flag);
}
if (nodeCat.equals("meta")) {
inMeta=true;
LinkedHashMap<String,Object> metaFilter = new LinkedHashMap<String,Object>();
requestMap.put("meta", metaFilter);
- metaFilter.put("@type", "korap:meta");
+ metaFilter.put("type", "meta");
}
if (nodeCat.equals("within") && !QueryUtils.getNodeCat(node.getParent()).equals("position")) {
@@ -902,9 +888,9 @@
@SuppressWarnings("unchecked")
private void createOccGroup(ParseTree node) {
LinkedHashMap<String,Object> occGroup = new LinkedHashMap<String,Object>();
- occGroup.put("@type", "korap:group");
+ occGroup.put("type", "group");
ArrayList<Object> groupOperands = new ArrayList<Object>();
- occGroup.put("@operands", groupOperands);
+ occGroup.put("operands", groupOperands);
curOccGroup = occGroup;
objectStack.push(occGroup);
stackedObjects++;
@@ -913,7 +899,7 @@
requestMap.put("query", occGroup);
// embed in super sequence
} else {
- ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("@operands");
+ ArrayList<Object> topSequenceOperands = (ArrayList<Object>) objectStack.get(1).get("operands");
topSequenceOperands.add(occGroup);
}
}
@@ -961,28 +947,13 @@
* For testing
*/
-// PoliqarpPlusTree pt1 = new PoliqarpPlusTree("[base=Hund] | [base=Katze][base=Maus]");
-// PoliqarpPlusTree pt2 = new PoliqarpPlusTree("[base=Hund] | [base=Katze] [base=Maus]");
-// System.err.println(pt1.getRequestMap().equals(pt2.getRequestMap()));
String[] queries = new String[] {
-// "startswith(<s>,[][base=der][base=Mann])",
-//// "[][base=Mann]",
-// "[base=Hund][][base=Katze][][][base=Maus]",
-// "[base=Hund][]?[][base=Katze]",
-// "split([base=der]{[base=Mann]})",
-// "[base=Mann&gen=m&cas=N]",
-// "[base=Hund] | [base=Katze][base=Maus]",
-// "Baum | Haus",
-// "Baum | Stein Haus",
-// "^contains(<s>,<np>)",
-// "([base=a]^[base=b][base=c])|[base=d]",
-// "[orth=der]^[orth=große][orth=Mann]",
-// "([base=a]^[base=b]^[base=c])|[base=d]",
"shrink(1|2:{1:[base=der]}{2:[base=Mann]})",
// "[base=foo] meta (author=name&year=2000)",
// "[base=foo] meta year=2000",
- "{[base=Mann]}"
+ "{[base=Mann]}",
+ "shrink(1:[orth=Der]{1:[orth=Mann][orth=geht]})"
};
PoliqarpPlusTree.debug=true;
for (String q : queries) {
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/QuerySerializer.java b/src/main/java/de/ids_mannheim/korap/query/serialize/QuerySerializer.java
index 3252c0f..89db3e7 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/QuerySerializer.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/QuerySerializer.java
@@ -45,23 +45,12 @@
* regex
* & field_group
*/
- "[base=foo]|([base=foo][base=bar])* meta author=Goethe&year=1815",
- "([base=foo]|[base=bar])[base=foobar]",
- "shrink({[base=Mann]})",
- "shrink({[base=foo]}[orth=bar])",
- "shrink(1:[base=Der]{1:[base=Mann]})",
-
- "[base=Katze]",
- "[base!=Katze]",
- "[!base=Katze]",
- "[base=Katze&orth=Katzen]",
- "[base=Katze][orth=und][orth=Hunde]",
- "[!(base=Katze&orth=Katzen)]",
- "contains(<np>,[base=Mann])",
- "startswith(<np>,[!pos=Det])",
- "'vers{2,3}uch'",
- "[orth='vers.*ch']",
- "[(base=bar|base=foo)&orth=foobar]",
+ "Der Mann",
+ "Der /+w1:3 Mann",
+ "Der /+w1:3,s1 Mann",
+ "(Der /+w1:3,s1 Mann) /+w5 geht",
+ "(Der /+w1:3,s1 Mann) /-w5 geht",
+ "(Der /+w1:3,s1 Mann) /+w5 (geht weg)",
};
} else {
@@ -72,7 +61,7 @@
i++;
try {
System.out.println(q);
- jg.run(q, "poliqarp", System.getProperty("user.home") + "/bsp" + i + ".json");
+ jg.run(q, "cosmas", System.getProperty("user.home") + "/bsp" + i + ".json");
System.out.println();
} catch (NullPointerException npe) {
npe.printStackTrace();
@@ -105,8 +94,8 @@
throws JsonGenerationException, JsonMappingException, IOException, QueryException {
if (queryLanguage.equals("poliqarp")) {
ast = new PoliqarpPlusTree(query);
-// } else if (queryLanguage.equals("cosmas")) {
-// ast = new CosmasTree(query);
+ } else if (queryLanguage.equals("cosmas")) {
+ ast = new CosmasTree(query);
} else if (queryLanguage.equals("poliqarpplus")) {
ast = new PoliqarpPlusTree(query);
} else {
diff --git a/src/main/java/de/ids_mannheim/korap/query/serialize/QueryUtils.java b/src/main/java/de/ids_mannheim/korap/query/serialize/QueryUtils.java
index 736b875..cee10ef 100644
--- a/src/main/java/de/ids_mannheim/korap/query/serialize/QueryUtils.java
+++ b/src/main/java/de/ids_mannheim/korap/query/serialize/QueryUtils.java
@@ -260,6 +260,77 @@
return request;
}
+
+ public static void prepareContext(LinkedHashMap<String, Object> requestMap) {
+ LinkedHashMap<String,Object> context = new LinkedHashMap<String,Object>();
+
+ LinkedHashMap<String,Object> classMap = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> operands = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> operation = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> frame = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> classRef = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> spanRef = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> classRefOp = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> min = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> max = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> exclude = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> distances = new LinkedHashMap<String,Object>();
+ LinkedHashMap<String,Object> inOrder = new LinkedHashMap<String,Object>();
+
+ operation.put("@id", "group:operation/");
+ operation.put("@type", "@id");
+
+ classMap.put("@id", "group:class");
+ classMap.put("@type", "xsd:integer");
+
+ operands.put("@id", "group:operands");
+ operands.put("@container", "@list");
+
+ frame.put("@id", "group:frame/");
+ frame.put("@type", "@id");
+
+ classRef.put("@id", "group:classRef");
+ classRef.put("@type", "xsd:integer");
+
+ spanRef.put("@id", "group:spanRef");
+ spanRef.put("@type", "xsd:integer");
+
+ classRefOp.put("@id", "group:classRefOp");
+ classRefOp.put("@type", "@id");
+
+ min.put("@id", "boundary:min");
+ min.put("@type", "xsd:integer");
+
+ max.put("@id", "boundary:max");
+ max.put("@type", "xsd:integer");
+
+ exclude.put("@id", "group:exclude");
+ exclude.put("@type", "xsd:boolean");
+
+ distances.put("@id", "group:distances");
+ distances.put("@container", "@list");
+
+ inOrder.put("@id", "group:inOrder");
+ inOrder.put("@type", "xsd:boolean");
+
+ context.put("korap", "http://korap.ids-mannheim.de/ns/KorAP/json-ld/v0.1/");
+ context.put("boundary", "korap:boundary/");
+ context.put("group", "korap:group/");
+ context.put("operation", operation);
+ context.put("class", classMap);
+ context.put("operands", operands);
+ context.put("frame", frame);
+ context.put("classRef", classRef);
+ context.put("spanRef", spanRef);
+ context.put("classRefOp", classRefOp);
+ context.put("min", min);
+ context.put("max", max);
+ context.put("exclude", exclude);
+ context.put("distances", distances);
+ context.put("inOrder", inOrder);
+
+ requestMap.put("@context", context);
+ }