    001    package org.maltparser.parser;
    002
    003    import java.util.HashMap;
    004    import java.util.HashSet;
    005    import java.util.regex.Pattern;
    006
    007    import org.maltparser.core.config.ConfigurationDir;
    008    import org.maltparser.core.exception.MaltChainedException;
    009    import org.maltparser.core.flow.FlowChartInstance;
    010    import org.maltparser.core.flow.item.ChartItem;
    011    import org.maltparser.core.flow.spec.ChartItemSpecification;
    012    import org.maltparser.core.io.dataformat.DataFormatInstance;
    013    import org.maltparser.core.io.dataformat.DataFormatManager;
    014    import org.maltparser.core.io.dataformat.DataFormatSpecification.DataStructure;
    015    import org.maltparser.core.io.dataformat.DataFormatSpecification.Dependency;
    016    import org.maltparser.core.options.OptionManager;
    017    import org.maltparser.core.syntaxgraph.DependencyStructure;
    018    import org.maltparser.core.syntaxgraph.MappablePhraseStructureGraph;
    019    /**
    020     * @author Johan Hall
    021     *
    022     */
    023    public class SingleMaltChartItem extends ChartItem {
    024            private SingleMalt singleMalt;
    025            private String idName;
    026            private String targetName;
    027            private String sourceName;
    028            private String modeName;
    029            private String taskName;
    030            private DependencyStructure cachedSourceGraph = null;
    031            private DependencyStructure cachedTargetGraph = null;
    032
    033
    034
    035            public void initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification) throws MaltChainedException {
    036                    super.initialize(flowChartinstance, chartItemSpecification);
    037
    038                    for (String key : chartItemSpecification.getChartItemAttributes().keySet()) {
    039                            if (key.equals("target")) {
    040                                    targetName = chartItemSpecification.getChartItemAttributes().get(key);
    041                            } else if (key.equals("source")) {
    042                                    sourceName = chartItemSpecification.getChartItemAttributes().get(key);
    043                            }  else if (key.equals("mode")) {
    044                                    modeName = chartItemSpecification.getChartItemAttributes().get(key);
    045                            }  else if (key.equals("task")) {
    046                                    taskName = chartItemSpecification.getChartItemAttributes().get(key);
    047                            } else if (key.equals("id")) {
    048                                    idName = chartItemSpecification.getChartItemAttributes().get(key);
    049                            }
    050                    }
    051                    if (targetName == null) {
    052                            targetName = getChartElement("singlemalt").getAttributes().get("target").getDefaultValue();
    053                    } else if (sourceName == null) {
    054                            sourceName = getChartElement("singlemalt").getAttributes().get("source").getDefaultValue();
    055                    } else if (modeName == null) {
    056                            modeName = getChartElement("singlemalt").getAttributes().get("mode").getDefaultValue();
    057                    } else if (taskName == null) {
    058                            taskName = getChartElement("singlemalt").getAttributes().get("task").getDefaultValue();
    059                    } else if (idName == null) {
    060                            idName = getChartElement("singlemalt").getAttributes().get("id").getDefaultValue();
    061                    }
    062
    063                    singleMalt = (SingleMalt)flowChartinstance.getFlowChartRegistry(org.maltparser.parser.SingleMalt.class, idName);
    064                    if (singleMalt == null) {
    065                            singleMalt = new SingleMalt();
    066                            flowChartinstance.addFlowChartRegistry(org.maltparser.parser.SingleMalt.class, idName, singleMalt);
    067                            flowChartinstance.addFlowChartRegistry(org.maltparser.core.config.Configuration.class, idName, singleMalt);
    068
    069                    }
    070            }
    071
    072
    073            public int preprocess(int signal) throws MaltChainedException {
    074                    if (taskName.equals("init")) {
    075                            if (modeName.equals("learn") || modeName.equals("parse")) {
    076                                    OptionManager.instance().overloadOptionValue(getOptionContainerIndex(), "singlemalt", "mode", modeName);
    077                                    ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(org.maltparser.core.config.ConfigurationDir.class, idName);
    078                                    DataFormatManager dataFormatManager = configDir.getDataFormatManager();
    079    //                              DataFormatManager dataFormatManager = flowChartinstance.getDataFormatManager();
    080    //                              HashMap<String, DataFormatInstance> dataFormatInstances = flowChartinstance.getDataFormatInstances();
    081                                    HashMap<String, DataFormatInstance> dataFormatInstances = configDir.getDataFormatInstances();
    082                                    if (modeName.equals("learn")) {
    083                                            DataFormatInstance dataFormatInstance = null;
    084                                            if (dataFormatManager.getInputDataFormatSpec().getDataStructure() == DataStructure.PHRASE) {
    085                                                    HashSet<Dependency> deps = dataFormatManager.getInputDataFormatSpec().getDependencies();
    086    //                                              String nullValueStategy = OptionManager.instance().getOptionValue(getOptionContainerIndex(), "singlemalt", "null_value").toString();
    087    //                                              String rootLabels = OptionManager.instance().getOptionValue(getOptionContainerIndex(), "graph", "root_label").toString();
    088                                                    for (Dependency dep : deps) {
    089    //                                                      dataFormatInstance = dataFormatManager.getDataFormatSpec(dep.getDependentOn()).createDataFormatInstance(flowChartinstance.getSymbolTables(), nullValueStategy, rootLabels);
    090    //                                                      flowChartinstance.getDataFormatInstances().put(flowChartinstance.getDataFormatManager().getOutputDataFormatSpec().getDataFormatName(), dataFormatInstance);
    091                                                            dataFormatInstance = dataFormatInstances.get(dataFormatManager.getOutputDataFormatSpec().getDataFormatName());
    092                                                    }
    093
    094                                                    String decisionSettings = OptionManager.instance().getOptionValue(getOptionContainerIndex(),"guide", "decision_settings").toString().trim();
    095                                                    StringBuilder newDecisionSettings = new StringBuilder();
    096                                                    if (!Pattern.matches(".*A\\.HEADREL.*", decisionSettings)) {
    097                                                            newDecisionSettings.append("+A.HEADREL");
    098                                                    }
    099                                                    if (!Pattern.matches(".*A\\.PHRASE.*", decisionSettings)) {
    100                                                            newDecisionSettings.append("+A.PHRASE");
    101                                                    }
    102                                                    if (!Pattern.matches(".*A\\.ATTACH.*", decisionSettings)) {
    103                                                            newDecisionSettings.append("+A.ATTACH");
    104                                                    }
    105                                                    if (newDecisionSettings.length() > 0) {
    106                                                            OptionManager.instance().overloadOptionValue(getOptionContainerIndex(), "guide", "decision_settings", decisionSettings+newDecisionSettings.toString());
    107                                                    }
    108                                            } else {
    109                                                    dataFormatInstance = dataFormatInstances.get(dataFormatManager.getInputDataFormatSpec().getDataFormatName());
    110                                            }
    111                                            singleMalt.initialize(getOptionContainerIndex(), dataFormatInstance, configDir, SingleMalt.LEARN);
    112                                    } else if (modeName.equals("parse")) {
    113                                            singleMalt.initialize(getOptionContainerIndex(),
    114                                                            dataFormatInstances.get(dataFormatManager.getInputDataFormatSpec().getDataFormatName()), configDir, SingleMalt.PARSE);
    115                                    } else {
    116                                            return ChartItem.TERMINATE;
    117                                    }
    118                            } else {
    119                                    return ChartItem.TERMINATE;
    120                            }
    121                    }
    122                    return signal;
    123            }
    124
    125            public int process(int signal) throws MaltChainedException {
    126                    if (taskName.equals("process")) {
    127                            if (cachedSourceGraph == null) {
    128                                    cachedSourceGraph = (DependencyStructure)flowChartinstance.getFlowChartRegistry(org.maltparser.core.syntaxgraph.DependencyStructure.class, sourceName);
    129                            }
    130                            if (cachedTargetGraph == null) {
    131                                    cachedTargetGraph = (DependencyStructure)flowChartinstance.getFlowChartRegistry(org.maltparser.core.syntaxgraph.DependencyStructure.class, targetName);
    132                            }
    133                            if (modeName.equals("learn")) {
    134                                    singleMalt.oracleParse(cachedSourceGraph, cachedTargetGraph);
    135                            } else if (modeName.equals("parse")) {
    136                                    singleMalt.parse(cachedSourceGraph);
    137                                    if (cachedSourceGraph instanceof MappablePhraseStructureGraph) {
    138                                            ((MappablePhraseStructureGraph)cachedSourceGraph).getMapping().connectUnattachedSpines((MappablePhraseStructureGraph)cachedSourceGraph);
    139                                    }
    140
    141                            }
    142                    }
    143                    return signal;
    144            }
    145
    146            public int postprocess(int signal) throws MaltChainedException {
    147                    if (taskName.equals("train") && singleMalt.getGuide() != null) {
    148                            singleMalt.getGuide().noMoreInstances();
    149                    } else if (taskName.equals("train") && singleMalt.getGuide() == null) {
    150                            singleMalt.train();
    151                    }
    152                    return signal;
    153            }
    154
    155            public void terminate() throws MaltChainedException {
    156                    if (flowChartinstance.getFlowChartRegistry(org.maltparser.parser.SingleMalt.class, idName) != null) {
    157                            singleMalt.terminate(null);
    158                            flowChartinstance.removeFlowChartRegistry(org.maltparser.parser.SingleMalt.class, idName);
    159                            flowChartinstance.removeFlowChartRegistry(org.maltparser.core.config.Configuration.class, idName);
    160                            singleMalt = null;
    161                    } else {
    162                            singleMalt = null;
    163                    }
    164                    cachedSourceGraph = null;
    165                    cachedTargetGraph = null;
    166            }
    167
    168            public SingleMalt getSingleMalt() {
    169                    return singleMalt;
    170            }
    171
    172            public void setSingleMalt(SingleMalt singleMalt) {
    173                    this.singleMalt = singleMalt;
    174            }
    175
    176            public String getTargetName() {
    177                    return targetName;
    178            }
    179
    180            public void setTargetName(String targetName) {
    181                    this.targetName = targetName;
    182            }
    183
    184            public String getSourceName() {
    185                    return sourceName;
    186            }
    187
    188            public void setSourceName(String sourceName) {
    189                    this.sourceName = sourceName;
    190            }
    191
    192            public boolean equals(Object obj) {
    193                    if (this == obj)
    194                            return true;
    195                    if (obj == null)
    196                            return false;
    197                    if (getClass() != obj.getClass())
    198                            return false;
    199                    return obj.toString().equals(this.toString());
    200            }
    201
    202            public int hashCode() {
    203                    return 217 + (null == toString() ? 0 : toString().hashCode());
    204            }
    205
    206            public String toString() {
    207                    StringBuilder sb = new StringBuilder();
    208                    sb.append("    singlemalt ");
    209                    sb.append("id:");sb.append(idName);
    210                    sb.append(' ');
    211                    sb.append("mode:");sb.append(modeName);
    212                    sb.append(' ');
    213                    sb.append("task:");sb.append(taskName);
    214                    sb.append(' ');
    215                    sb.append("source:");sb.append(sourceName);
    216                    sb.append(' ');
    217                    sb.append("target:");sb.append(targetName);
    218                    return sb.toString();
    219            }
    220    }