// look up and apply coarts for w to each sign in result
@SuppressWarnings("unchecked")
private void applyCoarts(Word w, SignHash result) throws LexException {
List<Sign> inputSigns = new ArrayList<Sign>(result.asSignSet());
result.clear();
List<Sign> outputSigns = new ArrayList<Sign>(inputSigns.size());
// for each surface attr, lookup coarts and apply to input signs, storing results in output
// signs
for (Iterator<Pair<String, String>> it = w.getSurfaceAttrValPairs(); it.hasNext(); ) {
Pair<String, String> p = it.next();
String attr = (String) p.a;
if (!_indexedCoartAttrs.contains(attr)) continue;
String val = (String) p.b;
Word coartWord = Word.createWord(attr, val);
SignHash coartResult = getSignsFromWord(coartWord, null, null, null);
for (Iterator<Sign> it2 = coartResult.iterator(); it2.hasNext(); ) {
Sign coartSign = it2.next();
// apply to each input
for (int j = 0; j < inputSigns.size(); j++) {
Sign sign = inputSigns.get(j);
grammar.rules.applyCoart(sign, coartSign, outputSigns);
}
}
// switch output to input for next iteration
inputSigns.clear();
inputSigns.addAll(outputSigns);
outputSigns.clear();
}
// add results back
result.addAll(inputSigns);
}
// look up and apply coarts for given rels to each sign in result
private void applyCoarts(List<String> coartRels, Collection<Sign> result) {
List<Sign> inputSigns = new ArrayList<Sign>(result);
result.clear();
List<Sign> outputSigns = new ArrayList<Sign>(inputSigns.size());
// for each rel, lookup coarts and apply to input signs, storing results in output signs
for (Iterator<String> it = coartRels.iterator(); it.hasNext(); ) {
String rel = it.next();
Collection<String> preds = (Collection<String>) _coartRelsToPreds.get(rel);
if (preds == null) continue; // not expected
Collection<Sign> coartResult = getSignsFromRelAndPreds(rel, preds);
if (coartResult == null) continue;
for (Iterator<Sign> it2 = coartResult.iterator(); it2.hasNext(); ) {
Sign coartSign = it2.next();
// apply to each input
for (int j = 0; j < inputSigns.size(); j++) {
Sign sign = inputSigns.get(j);
grammar.rules.applyCoart(sign, coartSign, outputSigns);
}
}
// switch output to input for next iteration
inputSigns.clear();
inputSigns.addAll(outputSigns);
outputSigns.clear();
}
// add results back
result.addAll(inputSigns);
}
// get signs for rel via preds, or null if none
private Collection<Sign> getSignsFromRelAndPreds(String rel, Collection<String> preds) {
List<Sign> retval = new ArrayList<Sign>();
for (Iterator<String> it = preds.iterator(); it.hasNext(); ) {
String pred = it.next();
Collection<Sign> signs = getSignsFromPredAndTargetRel(pred, rel);
if (signs != null) retval.addAll(signs);
}
// return null if none survive filter
if (retval.size() > 0) return retval;
else return null;
}
// get licensing features, with appropriate defaults
@SuppressWarnings("unchecked")
private void loadLicensingFeatures(Element licensingElt) {
List<LicensingFeature> licensingFeats = new ArrayList<LicensingFeature>();
boolean containsLexFeat = false;
if (licensingElt != null) {
for (Iterator<Element> it = licensingElt.getChildren("feat").iterator(); it.hasNext(); ) {
Element featElt = it.next();
String attr = featElt.getAttributeValue("attr");
if (attr.equals("lex")) containsLexFeat = true;
String val = featElt.getAttributeValue("val");
List<String> alsoLicensedBy = null;
String alsoVals = featElt.getAttributeValue("also-licensed-by");
if (alsoVals != null) {
alsoLicensedBy = Arrays.asList(alsoVals.split("\\s+"));
}
boolean licenseEmptyCats = true;
boolean licenseMarkedCats = false;
boolean instantiate = true;
byte loc = LicensingFeature.BOTH;
String lmc = featElt.getAttributeValue("license-marked-cats");
if (lmc != null) {
licenseMarkedCats = Boolean.valueOf(lmc).booleanValue();
// change defaults
licenseEmptyCats = false;
loc = LicensingFeature.TARGET_ONLY;
instantiate = false;
}
String lec = featElt.getAttributeValue("license-empty-cats");
if (lec != null) {
licenseEmptyCats = Boolean.valueOf(lec).booleanValue();
}
String inst = featElt.getAttributeValue("instantiate");
if (inst != null) {
instantiate = Boolean.valueOf(inst).booleanValue();
}
String locStr = featElt.getAttributeValue("location");
if (locStr != null) {
if (locStr.equals("target-only")) loc = LicensingFeature.TARGET_ONLY;
if (locStr.equals("args-only")) loc = LicensingFeature.ARGS_ONLY;
if (locStr.equals("both")) loc = LicensingFeature.BOTH;
}
licensingFeats.add(
new LicensingFeature(
attr, val, alsoLicensedBy, licenseEmptyCats, licenseMarkedCats, instantiate, loc));
}
}
if (!containsLexFeat) {
licensingFeats.add(LicensingFeature.defaultLexFeature);
}
_licensingFeatures = new LicensingFeature[licensingFeats.size()];
licensingFeats.toArray(_licensingFeatures);
}
