    001    package org.maltparser.core.syntaxgraph.headrules;
    002
    003    import java.io.BufferedReader;
    004    import java.io.IOException;
    005    import java.io.InputStreamReader;
    006    import java.net.URL;
    007
    008    import org.apache.log4j.Logger;
    009    import org.maltparser.core.exception.MaltChainedException;
    010    import org.maltparser.core.helper.HashMap;
    011    import org.maltparser.core.helper.URLFinder;
    012    import org.maltparser.core.io.dataformat.DataFormatInstance;
    013    import org.maltparser.core.symbol.SymbolTable;
    014    import org.maltparser.core.syntaxgraph.node.NonTerminalNode;
    015    import org.maltparser.core.syntaxgraph.node.PhraseStructureNode;
    016
    017    /**
    018    *
    019    *
    020    * @author Johan Hall
    021    */
    022    public class HeadRules extends HashMap<String,HeadRule> {
    023            public static final long serialVersionUID = 8045568022124826323L;
    024            protected Logger logger;
    025            protected String name;
    026            protected DataFormatInstance dataFormatInstance;
    027            protected SymbolTable nonTerminalSymbolTable; // TODO more complex
    028            protected SymbolTable edgelabelSymbolTable; // TODO more complex
    029
    030            public HeadRules(Logger logger, DataFormatInstance dataFormatInstance) throws MaltChainedException {
    031                    setLogger(logger);
    032                    setDataFormatInstance(dataFormatInstance);
    033                    nonTerminalSymbolTable = dataFormatInstance.getSymbolTables().addSymbolTable("CAT");
    034                    edgelabelSymbolTable = dataFormatInstance.getSymbolTables().addSymbolTable("LABEL");
    035            }
    036
    037            public void parseHeadRules(String fileName) throws MaltChainedException {
    038                    final URLFinder f = new URLFinder();
    039                    parseHeadRules(f.findURL(fileName));
    040            }
    041
    042            public void parseHeadRules(URL url) throws MaltChainedException {
    043                    BufferedReader br = null;
    044                    try {
    045                            br = new BufferedReader(new InputStreamReader(url.openStream()));
    046                    } catch (IOException e) {
    047                            throw new HeadRuleException("Could not read the head rules from file '"+url.toString()+"'. ", e);
    048                    }
    049                    if (logger.isInfoEnabled()) {
    050                            logger.debug("Loading the head rule specification '"+url.toString()+"' ...\n");
    051                    }
    052                    String fileLine;
    053                    while (true) {
    054                            try {
    055                                    fileLine = br.readLine();
    056                            } catch (IOException e) {
    057                                    throw new HeadRuleException("Could not read the head rules from file '"+url.toString()+"'. ", e);
    058                            }
    059                            if (fileLine == null) {
    060                                    break;
    061                            }
    062                            if (fileLine.length() <= 1 && fileLine.trim().substring(0, 2).trim().equals("--")) {
    063                                    continue;
    064                            }
    065                            int index = fileLine.indexOf('\t');
    066                            if (index == -1) {
    067                                    throw new HeadRuleException("The specification of the head rule is not correct '"+fileLine+"'. ");
    068                            }
    069
    070                            HeadRule rule = new HeadRule(this, fileLine);
    071                            put(fileLine.substring(0,index), rule);
    072                    }
    073            }
    074
    075            public PhraseStructureNode getHeadChild(NonTerminalNode nt) throws MaltChainedException {
    076                    HeadRule rule = null;
    077                    if (nt.hasLabel(nonTerminalSymbolTable)) {
    078                            rule = this.get(nonTerminalSymbolTable.getName()+":"+nt.getLabelSymbol(nonTerminalSymbolTable));
    079                    }
    080                    if (rule == null && nt.hasParentEdgeLabel(edgelabelSymbolTable)) {
    081                            rule = this.get(edgelabelSymbolTable.getName()+":"+nt.getParentEdgeLabelSymbol(edgelabelSymbolTable));
    082                    }
    083
    084                    if (rule != null) {
    085                            return rule.getHeadChild(nt);
    086                    }
    087                    return null;
    088            }
    089
    090            public Direction getDefaultDirection(NonTerminalNode nt) throws MaltChainedException {
    091                    HeadRule rule = null;
    092                    if (nt.hasLabel(nonTerminalSymbolTable)) {
    093                            rule = this.get(nonTerminalSymbolTable.getName()+":"+nt.getLabelSymbol(nonTerminalSymbolTable));
    094                    }
    095                    if (rule == null && nt.hasParentEdgeLabel(edgelabelSymbolTable)) {
    096                            rule = this.get(edgelabelSymbolTable.getName()+":"+nt.getParentEdgeLabelSymbol(edgelabelSymbolTable));
    097                    }
    098
    099                    if (rule != null) {
    100                            return rule.getDefaultDirection();
    101                    }
    102                    return Direction.LEFT;
    103            }
    104
    105            public Logger getLogger() {
    106                    return logger;
    107            }
    108
    109            public void setLogger(Logger logger) {
    110                    this.logger = logger;
    111            }
    112
    113            public DataFormatInstance getDataFormatInstance() {
    114                    return dataFormatInstance;
    115            }
    116
    117            public void setDataFormatInstance(DataFormatInstance dataFormatInstance) {
    118                    this.dataFormatInstance = dataFormatInstance;
    119            }
    120
    121            public String toString() {
    122                    final StringBuilder sb = new StringBuilder();
    123                    for (HeadRule rule : this.values()) {
    124                            sb.append(rule);
    125                            sb.append('\n');
    126                    }
    127                    return sb.toString();
    128            }
    129    }