adapted Cosmas and PQ to current JSON-LD specifications
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 beb2c38..6f471e4 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
@@ -136,8 +136,8 @@
context.put("korap", "http://korap.ids-mannheim.de/ns/query");
context.put("@language", "de");
- context.put("operands", operands);
- context.put("relation", relation);
+ context.put("@operands", operands);
+ context.put("@relation", relation);
context.put("class", classMap);
context.put("query", "korap:query");
context.put("filter", "korap:filter");
@@ -203,7 +203,7 @@
// 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("@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
@@ -230,15 +230,16 @@
fieldMap.put("@type", "korap:term");
// make category-specific fieldMap entry
- String attr = nodeCat.equals("OPWF") ? "orth:" : "base:";
- String value = attr+node.getChild(0).toStringTree().replaceAll("\"", "");
+ String attr = nodeCat.equals("OPWF") ? "orth" : "lemma";
+ String value = node.getChild(0).toStringTree().replaceAll("\"", "");
fieldMap.put("@value", value);
+ fieldMap.put("@attr", attr);
// negate field (see above)
if (negate) {
- fieldMap.put("relation", "!=");
+ fieldMap.put("@relation", "!=");
} else {
- fieldMap.put("relation", "=");
+ fieldMap.put("@relation", "=");
}
//Step II: decide where to put
putIntoSuperObject(token, 1);
@@ -248,43 +249,56 @@
//Step I: get info
LinkedHashMap<String, Object> token = new LinkedHashMap<String, Object>();
token.put("@type", "korap:token");
+ LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
+ token.put("@value", fieldMap);
- List<String> morphValues = QueryUtils.parseMorph(node.getChild(0).toStringTree());
- if (morphValues.size() == 1) {
- LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
- token.put("@value", fieldMap);
-
- fieldMap.put("@type", "korap:term");
- fieldMap.put("@value", morphValues.get(0));
- // make category-specific fieldMap entry
- // negate field (see above)
- if (negate) {
- fieldMap.put("relation", "!=");
- } else {
- fieldMap.put("relation", "=");
- }
+ fieldMap.put("@type", "korap:term");
+// fieldMap.put("@value", "morph:"+node.getChild(0).toString().replace(" ", "_"));
+ fieldMap.put("@value", node.getChild(0).toString().replace(" ", "_"));
+ // make category-specific fieldMap entry
+ // negate field (see above)
+ if (negate) {
+ fieldMap.put("@relation", "!=");
} else {
- LinkedHashMap<String, Object> conjGroup = new LinkedHashMap<String, Object>();
- token.put("@value", conjGroup);
- ArrayList<Object> conjOperands = new ArrayList<Object>();
- conjGroup.put("@type", "korap:group");
- conjGroup.put("relation", "and");
- conjGroup.put("operands", conjOperands);
- for (String value : morphValues) {
- LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
- token.put("@value", fieldMap);
-
- fieldMap.put("@type", "korap:term");
- fieldMap.put("@value", value);
- // make category-specific fieldMap entry
- // negate field (see above)
- if (negate) {
- fieldMap.put("relation", "!=");
- } else {
- fieldMap.put("relation", "=");
- }
- }
+ fieldMap.put("@relation", "=");
}
+// 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);
+//
+// fieldMap.put("@type", "korap:term");
+// fieldMap.put("@value", morphValues.get(0));
+// // make category-specific fieldMap entry
+// // negate field (see above)
+// if (negate) {
+// fieldMap.put("@relation", "!=");
+// } else {
+// fieldMap.put("@relation", "=");
+// }
+// } else {
+// LinkedHashMap<String, Object> conjGroup = new LinkedHashMap<String, Object>();
+// token.put("@value", conjGroup);
+// ArrayList<Object> conjOperands = new ArrayList<Object>();
+// conjGroup.put("@type", "korap:group");
+// conjGroup.put("@relation", "and");
+// conjGroup.put("@operands", conjOperands);
+// for (String value : morphValues) {
+// LinkedHashMap<String, Object> fieldMap = new LinkedHashMap<String, Object>();
+// token.put("@value", fieldMap);
+//
+// fieldMap.put("@type", "korap:term");
+// fieldMap.put("@value", value);
+// // make category-specific fieldMap entry
+// // negate field (see above)
+// if (negate) {
+// fieldMap.put("@relation", "!=");
+// } else {
+// fieldMap.put("@relation", "=");
+// }
+// }
+// }
//Step II: decide where to put
@@ -294,7 +308,7 @@
if (nodeCat.equals("OPELEM")) {
// Step I: create element
LinkedHashMap<String, Object> elem = new LinkedHashMap<String, Object>();
- elem.put("@type", "korap:element");
+ elem.put("@type", "korap:span");
elem.put("@value", node.getChild(0).getChild(0).toStringTree().toLowerCase());
//Step II: decide where to put
putIntoSuperObject(elem);
@@ -303,7 +317,7 @@
if (nodeCat.equals("OPLABEL")) {
// Step I: create element
LinkedHashMap<String, Object> elem = new LinkedHashMap<String, Object>();
- elem.put("@type", "korap:element");
+ elem.put("@type", "korap:span");
elem.put("@value", node.getChild(0).toStringTree().replaceAll("<|>", ""));
//Step II: decide where to put
putIntoSuperObject(elem);
@@ -316,8 +330,8 @@
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("@relation", relation);
+ disjunction.put("@operands", new ArrayList<Object>());
objectStack.push(disjunction);
stackedObjects++;
// Step II: decide where to put
@@ -325,25 +339,28 @@
}
if (nodeCat.equals("OPPROX")) {
+ //TODO direction "both": wrap in "or" group with operands once flipped, once not
// collect info
Tree prox_opts = node.getChild(0);
Tree typ = prox_opts.getChild(0);
Tree dist_list = prox_opts.getChild(1);
// Step I: create group
- LinkedHashMap<String, Object> proxGroup = new LinkedHashMap<String, Object>();
- proxGroup.put("@type", "korap:group");
- proxGroup.put("relation", "distance");
- objectStack.push(proxGroup);
+ LinkedHashMap<String, Object> proxSequence = new LinkedHashMap<String, Object>();
+ proxSequence.put("@type", "korap:sequence");
+ objectStack.push(proxSequence);
stackedObjects++;
- if (openNodeCats.get(1).equals("OPALL")) proxGroup.put("match", "all");
- else if (openNodeCats.get(1).equals("OPNHIT")) proxGroup.put("match", "between");
- else proxGroup.put("match", "operands");
+// if (openNodeCats.get(1).equals("OPALL")) proxSequence.put("match", "all");
+// else if (openNodeCats.get(1).equals("OPNHIT")) proxSequence.put("match", "between");
+// else proxSequence.put("match", "operands");
ArrayList<Object> constraints = new ArrayList<Object>();
- String subtype = typ.getChild(0).toStringTree().equals("PROX") ? "incl" : "excl";
- proxGroup.put("@subtype", subtype);
- proxGroup.put("constraint", constraints);
+ boolean exclusion = ! typ.getChild(0).toStringTree().equals("PROX");
+
+ String inOrder = "true";
+ proxSequence.put("@inOrder", inOrder);
+ proxSequence.put("@constraints", constraints);
+
ArrayList<Object> operands = new ArrayList<Object>();
- proxGroup.put("operands", operands);
+ proxSequence.put("@operands", operands);
// if only one dist_info, put directly into constraints
if (dist_list.getChildCount()==1) {
@@ -357,22 +374,27 @@
if (direction.equals("minus")) {
direction = "plus";
invertedOperandsLists.add(operands);
+ } else if (direction.equals("both")) {
+ inOrder="false";
}
LinkedHashMap<String, Object> distance = new LinkedHashMap<String, Object>();
distance.put("@type", "korap:distance");
- distance.put("measure", meas);
- distance.put("direction", direction);
- distance.put("min", min);
- distance.put("max", max);
+ distance.put("@measure", meas);
+ distance.put("@min", Integer.parseInt(min));
+ distance.put("@max", Integer.parseInt(max));
+ if (exclusion) {
+ distance.put("@exclude", exclusion);
+ }
constraints.add(distance);
+ 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("@relation", "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();
@@ -384,32 +406,42 @@
}
LinkedHashMap<String, Object> distance = new LinkedHashMap<String, Object>();
distance.put("@type", "korap:distance");
- distance.put("measure", meas);
- distance.put("direction", direction);
- distance.put("min", min);
- distance.put("max", max);
+ distance.put("@measure", meas);
+ distance.put("@min", min);
+ distance.put("@max", max);
+ if (exclusion) {
+ distance.put("@exclude", exclusion);
+ }
groupOperands.add(distance);
+ if (direction.equals("plus")) {
+ inOrder="true";
+ } else if (direction.equals("minus")) {
+ inOrder="true";
+ invertedOperandsLists.add(operands);
+ }
}
+ proxSequence.put("@inOrder", inOrder);
+
}
// Step II: decide where to put
- putIntoSuperObject(proxGroup, 1);
+ putIntoSuperObject(proxSequence, 1);
}
// inlcusion or overlap
if (nodeCat.equals("OPIN") || nodeCat.equals("OPOV")) {
// Step I: create group
- LinkedHashMap<String, Object> shrinkgroup = new LinkedHashMap<String, Object>();
- shrinkgroup.put("@type", "korap:group");
- shrinkgroup.put("relation", "shrink");
- shrinkgroup.put("shrink", "1");
+ LinkedHashMap<String, Object> submatchgroup = new LinkedHashMap<String, Object>();
+ submatchgroup.put("@type", "korap:group");
+ submatchgroup.put("@relation", "submatch");
+ submatchgroup.put("@classRef", "1");
- ArrayList<Object> shrinkoperands = new ArrayList<Object>();
+ ArrayList<Object> submatchoperands = new ArrayList<Object>();
LinkedHashMap<String, Object> posgroup = new LinkedHashMap<String, Object>();
- shrinkgroup.put("operands", shrinkoperands);
- shrinkoperands.add(posgroup);
+ submatchgroup.put("@operands", submatchoperands);
+ submatchoperands.add(posgroup);
posgroup.put("@type", "korap:group");
- String relation = nodeCat.equals("OPIN") ? "position" : "overlap";
- posgroup.put("relation", relation);
+ String relation = nodeCat.equals("OPIN") ? "position" : "overlaps";
+ posgroup.put("@relation", relation);
if (nodeCat.equals("OPIN")) {
parseOPINOptions(node, posgroup);
@@ -419,14 +451,14 @@
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);
stackedObjects++;
// Step II: decide where to put
- putIntoSuperObject(shrinkgroup, 1);
+ putIntoSuperObject(submatchgroup, 1);
}
@@ -436,7 +468,7 @@
LinkedHashMap<String, Object> classGroup = new LinkedHashMap<String, Object>();
classGroup.put("@type", "korap:group");
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
@@ -452,10 +484,15 @@
// Step I: create group
LinkedHashMap<String, Object> beggroup = new LinkedHashMap<String, Object>();
beggroup.put("@type", "korap:group");
- beggroup.put("relation", "shrink");
- String reduction = nodeCat.equals("OPBEG") ? "first" : "last";
- beggroup.put("shrink", reduction);
- beggroup.put("operands", new ArrayList<Object>());
+ beggroup.put("@relation", "submatch");
+ ArrayList<Integer> spanRef = new ArrayList<Integer>();
+ if (nodeCat.equals("OPBEG")) {
+ spanRef.add(0); spanRef.add(1);
+ } else {
+ spanRef.add(-1); spanRef.add(1);
+ }
+ beggroup.put("@spanRef", spanRef);
+ beggroup.put("@operands", new ArrayList<Object>());
objectStack.push(beggroup);
stackedObjects++;
@@ -471,15 +508,15 @@
if (conditions.getChildCount()==1) {
LinkedHashMap<String, Object> posgroup = new LinkedHashMap<String, Object>();
posgroup.put("@type", "korap:group");
- posgroup.put("relation", "position");
+ posgroup.put("@relation", "position");
CosmasCondition c = new CosmasCondition(conditions.getChild(0));
- posgroup.put("position", c.position);
- if (c.negated) posgroup.put("@subtype", "excl");
+ posgroup.put("@position", c.position);
+ if (c.negated) posgroup.put("@relation", "!=");
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:element");
+ bedElem.put("@type", "korap:span");
bedElem.put("@value", c.elem);
objectStack.push(posgroup);
stackedObjects++;
@@ -492,9 +529,9 @@
// -> 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("@relation", "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++) {
@@ -505,15 +542,15 @@
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("@subtype", "excl");
+ posGroup.put("@relation", "position");
+ posGroup.put("@position", 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:element");
+ bedElem.put("@type", "korap:span");
bedElem.put("@value", c.elem);
@@ -586,7 +623,7 @@
} else {
position = "contains";
}
- posgroup.put("position", position);
+ posgroup.put("@position", position);
position = openNodeCats.get(1).equals("OPIN") ? "contains" : "full";
if (rangenode != null) {
@@ -599,13 +636,14 @@
negatePosition = !negatePosition;
}
}
-
+ System.err.println(negatePosition);
if (negatePosition) {
- posgroup.put("@subtype", "excl");
+ posgroup.put("@exclude", "true");
+// negate = !negate;
}
if (groupnode != null) {
- String grouping = groupnode.getChild(0).toStringTree().equals("MAX") ? "true" : "false";
+ String grouping = groupnode.getChild(0).toStringTree().equals("max") ? "true" : "false";
posgroup.put("grouping", grouping);
}
}
@@ -622,16 +660,16 @@
} else {
position = "any";
}
- posgroup.put("position", position);
+ posgroup.put("@position", position);
position = openNodeCats.get(1).equals("OPIN") ? "contains" : "full";
if (exclnode != null) {
if (exclnode.getChild(0).toStringTree().equals("YES")) {
- posgroup.put("@subtype", "excl");
+ posgroup.put("@relation", "!=");
}
}
if (groupnode != null) {
- String grouping = groupnode.getChild(0).toStringTree().equals("MAX") ? "true" : "false";
+ String grouping = groupnode.getChild(0).toStringTree().equals("@max") ? "true" : "false";
posgroup.put("grouping", grouping);
}
@@ -681,7 +719,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 {
@@ -724,7 +762,12 @@
*/
String[] queries = new String[] {
/* COSMAS 2 */
- "MORPH(V)"
+ "MORPH(V)",
+ "MORPH(V PRES)",
+ "wegen #IN(%, L) <s>",
+ "wegen #IN(%) <s>",
+ "(Mann oder Frau) #IN <s>",
+ "#BEG(der /w3:5 Mann) /+w10 kommt"
};
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 b10105c..530f597 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
@@ -178,8 +178,8 @@
context.put("korap", "http://korap.ids-mannheim.de/ns/query");
context.put("@language", "de");
- context.put("operands", operands);
- context.put("relation", relation);
+ context.put("@operands", operands);
+ context.put("@relation", relation);
context.put("class", classMap);
context.put("query", "korap:query");
context.put("filter", "korap:filter");
@@ -277,7 +277,6 @@
}
// Step I: decide type of element (one or more elements? -> token or sequence)
// take into account a possible 'occ' child with accompanying parantheses, therefore 3 extra children
- // TODO analyse emptysegments
int occExtraChildren = cqHasOccChild ? 3:0;
if (node.getChildCount()>1 + occExtraChildren) {
ParseTree emptySegments = QueryUtils.getFirstChildWithCat(node, "empty_segments");
@@ -285,20 +284,19 @@
String[] minmax = parseEmptySegments(emptySegments);
Integer min = Integer.parseInt(minmax[0]);
Integer max = Integer.parseInt(minmax[1]);
- sequence.put("@type", "korap:group");
- sequence.put("relation", "distance");
- sequence.put("@subtype", "incl");
+ sequence.put("@type", "korap:sequence");
+// sequence.put("@relation", "distance");
+ sequence.put("@inOrder", "true");
ArrayList<Object> constraint = new ArrayList<Object>();
- sequence.put("constraint", constraint);
+ sequence.put("@constraints", 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("measure", "w");
- distMap.put("direction", "plus");
distMap.put("min", min);
distMap.put("max", max);
} else {
@@ -311,7 +309,7 @@
sequence.put("offset-min", min);
sequence.put("offset-max", max);
}
- sequence.put("operands", sequenceOperands);
+ sequence.put("@operands", sequenceOperands);
objectStack.push(sequence);
stackedObjects++;
}
@@ -334,7 +332,7 @@
// 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 {
@@ -350,20 +348,20 @@
LinkedHashMap<String,Object> superSequence = new LinkedHashMap<String,Object>();
superSequence.put("@type", "korap: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);
}
}
@@ -404,7 +402,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);
}
}
@@ -415,13 +413,13 @@
LinkedHashMap<String,Object> group = new LinkedHashMap<String,Object>();
curOccGroup = group;
group.put("@type", "korap:group");
- group.put("operands", new ArrayList<Object>());
+ 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);
@@ -435,13 +433,13 @@
stackedObjects++;
ArrayList<Object> disjOperands = new ArrayList<Object>();
disjunction.put("@type", "korap:group");
- disjunction.put("relation", "or");
- disjunction.put("operands", disjOperands);
+ disjunction.put("@relation", "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);
}
}
@@ -479,8 +477,15 @@
value = valNode.getChild(0).toStringTree(poliqarpParser); //e.g. (re_query "bar*")
fieldMap.put("@subtype", "korap:value#regex");
}
- fieldMap.put("@value", fieldName+":"+value);
- fieldMap.put("relation", relation);
+ fieldMap.put("@value", value);
+ if (fieldName.contains("/")) {
+ String[] splitted = fieldName.split("/");
+ fieldMap.put("@attr", splitted[1]);
+ fieldMap.put("@foundry", splitted[0]);
+ } else {
+ fieldMap.put("@attr", fieldName);
+ }
+ fieldMap.put("@relation", 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) {
@@ -505,7 +510,7 @@
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("@operands", groupOperands);
fieldStack.push(groupOperands);
stackedFields++;
// Step I: get operator (& or |)
@@ -515,7 +520,7 @@
if (negField) {
relation = relation.equals("or") ? "and": "or";
}
- group.put("relation", relation);
+ group.put("@relation", 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);
@@ -554,15 +559,15 @@
LinkedHashMap<String,Object> tokenValues = new LinkedHashMap<String,Object>();
token.put("@value", tokenValues);
tokenValues.put("@type", "korap:term");
- tokenValues.put("@value", "orth:"+word);
- tokenValues.put("relation", "=");
+ tokenValues.put("@value", word);
+ tokenValues.put("@attr", "orth");
+ tokenValues.put("@relation", "=");
// 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);
}
}
- System.out.println(stackedObjects+" "+objectStack);
visited.add(node.getChild(0));
}
@@ -571,7 +576,7 @@
reQuery.put("@subtype", "korap:regex");
String regex = node.getChild(0).toStringTree(poliqarpParser);
reQuery.put("@value", regex);
- reQuery.put("relation", "=");
+ reQuery.put("@relation", "=");
// if in field, regex was already added there
if (!openNodeCats.get(1).equals("field")) {
@@ -583,7 +588,7 @@
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);
}
}
@@ -600,17 +605,17 @@
// Step I: get info
// fill group
alignGroup.put("@type", "korap:group");
- alignGroup.put("relation", "left-align");
- alignGroup.put("operands", new ArrayList<Object>());
+ alignGroup.put("@relation", "left-align");
+ 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));
@@ -629,12 +634,12 @@
objectStack.push(elem);
stackedObjects++;
// Step II: fill object (token values) and put into containing sequence
- elem.put("@type", "korap:element");
+ elem.put("@type", "korap:span");
String value = node.getChild(1).toStringTree(poliqarpParser);
elem.put("@value", 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));
@@ -661,13 +666,13 @@
}
span.put("@type", "korap:group");
span.put("class", id);
- 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
@@ -686,19 +691,19 @@
// 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("@relation", "position");
+ positionGroup.put("@position", 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);
}
}
@@ -720,19 +725,19 @@
}
}
shrinkGroup.put("@type", "korap:group");
- shrinkGroup.put("relation", "shrink");
- shrinkGroup.put(type, operandClass);
- shrinkGroup.put("operands", shrinkOperands);
+ shrinkGroup.put("@relation", type);
+ shrinkGroup.put("classRef", operandClass);
+ 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));
@@ -742,8 +747,10 @@
if (nodeCat.equals("occ")) {
ParseTree occChild = node.getChild(0);
String repetition = occChild.toStringTree(poliqarpParser);
- curOccGroup.put("relation", "repetition");
- curOccGroup.put("quantifier", repetition);
+ String[] minmax = parseRepetition(repetition);
+ curOccGroup.put("@relation", "repetition");
+ curOccGroup.put("@min", minmax[0]);
+ curOccGroup.put("@max", minmax[1]);
visited.add(occChild);
}
@@ -815,6 +822,19 @@
openNodeCats.pop();
}
+ private String[] parseRepetition(String repetition) {
+ if (repetition.equals("*")) {
+ return new String[] {"0", "100"};
+ } else if (repetition.equals("+")) {
+ return new String[] {"1", "100"};
+ } else if (repetition.equals("?")) {
+ return new String[] {"0", "1"};
+ } else {
+ repetition = repetition.substring(1, repetition.length()-1); // remove braces
+ return repetition.split(",");
+ }
+ }
+
private String[] parseEmptySegments(ParseTree emptySegments) {
String[] minmax = new String[2];
Integer min = 0;
@@ -824,8 +844,6 @@
child = emptySegments.getChild(i);
ParseTree nextSibling = emptySegments.getChild(i+1);
String nextSiblingString = nextSibling.toStringTree();
- System.err.println("FOO "+child.toStringTree());
- System.out.println("FOO "+nextSiblingString);
if (child.toStringTree().equals("[]")) {
if (nextSiblingString.equals("?")) {
max++;
@@ -861,7 +879,7 @@
LinkedHashMap<String,Object> occGroup = new LinkedHashMap<String,Object>();
occGroup.put("@type", "korap:group");
ArrayList<Object> groupOperands = new ArrayList<Object>();
- occGroup.put("operands", groupOperands);
+ occGroup.put("@operands", groupOperands);
curOccGroup = occGroup;
objectStack.push(occGroup);
stackedObjects++;
@@ -870,7 +888,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);
}
}
@@ -921,6 +939,9 @@
"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]"
};
PoliqarpPlusTree.debug=true;
for (String q : queries) {