001    package org.maltparser.core.syntaxgraph;
002    
003    import java.util.HashMap;
004    import java.util.HashSet;
005    
006    import org.maltparser.core.config.ConfigurationDir;
007    import org.maltparser.core.exception.MaltChainedException;
008    import org.maltparser.core.flow.FlowChartInstance;
009    import org.maltparser.core.flow.FlowException;
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.symbol.SymbolTableHandler;
018    import org.maltparser.core.syntaxgraph.ds2ps.LosslessMapping;
019    /**
020    *
021    *
022    * @author Johan Hall
023    */
024    public class SyntaxGraphChartItem extends ChartItem {
025            private String idName;
026            private String structureName;
027            private String taskName;
028            private TokenStructure graph;
029            
030            public SyntaxGraphChartItem() { super(); }
031            
032            public void initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification) throws MaltChainedException {
033                    super.initialize(flowChartinstance, chartItemSpecification);
034                    
035                    for (String key : chartItemSpecification.getChartItemAttributes().keySet()) {
036                            if (key.equals("id")) {
037                                    idName = chartItemSpecification.getChartItemAttributes().get(key);
038                            } else if (key.equals("structure")) {
039                                    structureName = chartItemSpecification.getChartItemAttributes().get(key);
040                            } else if (key.equals("task")) {
041                                    taskName = chartItemSpecification.getChartItemAttributes().get(key);
042                            }
043                    }
044                    if (idName == null) {
045                            idName = getChartElement("graph").getAttributes().get("id").getDefaultValue();
046                    } else if (structureName == null) {
047                            structureName = getChartElement("graph").getAttributes().get("structure").getDefaultValue();
048                    } else if (taskName == null) {
049                            taskName = getChartElement("graph").getAttributes().get("task").getDefaultValue();
050                    }
051            }
052            
053            public int preprocess(int signal) throws MaltChainedException {
054                    if (taskName.equals("create")) {
055                            boolean phrase = false;
056                            boolean dependency = false;
057                            ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(org.maltparser.core.config.ConfigurationDir.class, idName);
058                            DataFormatInstance dataFormatInstance = null;
059                            DataFormatManager dataFormatManager = configDir.getDataFormatManager();
060    //                      DataFormatManager dataFormatManager = flowChartinstance.getDataFormatManager();
061                            SymbolTableHandler symbolTables = configDir.getSymbolTables();
062    //                      SymbolTableHandler symbolTables = flowChartinstance.getSymbolTables();
063                            
064                            HashMap<String, DataFormatInstance> dataFormatInstances = configDir.getDataFormatInstances();
065    //                      HashMap<String, DataFormatInstance> dataFormatInstances = flowChartinstance.getDataFormatInstances();
066                            for (String key : dataFormatInstances.keySet()) {
067                                    if (dataFormatInstances.get(key).getDataFormarSpec().getDataStructure() == DataStructure.PHRASE) {
068                                            phrase = true;
069                                    }
070                                    if (dataFormatInstances.get(key).getDataFormarSpec().getDataStructure() == DataStructure.DEPENDENCY) {
071                                            dependency = true;
072                                            dataFormatInstance = dataFormatInstances.get(key);
073                                    }
074                            }
075                            
076                            if (dependency == false && OptionManager.instance().getOptionValue(getOptionContainerIndex(), "config", "flowchart").toString().equals("learn")) {
077                                    dependency = true;
078                                    HashSet<Dependency> deps = dataFormatManager.getInputDataFormatSpec().getDependencies();
079                                    String nullValueStategy = OptionManager.instance().getOptionValue(getOptionContainerIndex(), "singlemalt", "null_value").toString();
080                                    String rootLabels = OptionManager.instance().getOptionValue(getOptionContainerIndex(), "graph", "root_label").toString();
081                                    for (Dependency dep : deps) {
082                                            dataFormatInstance = dataFormatManager.getDataFormatSpec(dep.getDependentOn()).createDataFormatInstance(symbolTables, nullValueStategy, rootLabels);
083                                            dataFormatInstances.put(dataFormatManager.getOutputDataFormatSpec().getDataFormatName(), dataFormatInstance);
084                                    }
085                            }
086    
087                            if (dependency == true && phrase == false) {
088                                    graph = new DependencyGraph(symbolTables);
089                                    flowChartinstance.addFlowChartRegistry(org.maltparser.core.syntaxgraph.DependencyStructure.class, structureName, graph);
090                            } else if (dependency == true && phrase == true) {
091                                    graph = new MappablePhraseStructureGraph(symbolTables);
092                                    final DataFormatInstance inFormat = dataFormatInstances.get(dataFormatManager.getInputDataFormatSpec().getDataFormatName());
093                                    final DataFormatInstance outFormat = dataFormatInstances.get(dataFormatManager.getOutputDataFormatSpec().getDataFormatName());
094    
095                                    if (inFormat != null && outFormat != null) {
096                                            LosslessMapping mapping = null;
097                                            if (inFormat.getDataFormarSpec().getDataStructure() == DataStructure.DEPENDENCY) {
098                                                    mapping = new LosslessMapping(inFormat, outFormat);
099                                            } else {
100                                                    mapping = new LosslessMapping(outFormat, inFormat);
101                                            }
102                                            if (inFormat.getDataFormarSpec().getDataStructure() == DataStructure.PHRASE) {
103                                                    mapping.setHeadRules(OptionManager.instance().getOptionValue(getOptionContainerIndex(), "graph", "head_rules").toString());
104                                            }
105                                            ((MappablePhraseStructureGraph)graph).setMapping(mapping);
106                                    } else {
107                                            throw new FlowException("Couldn't determine the input and output data format. ");
108                                    }
109                                    flowChartinstance.addFlowChartRegistry(org.maltparser.core.syntaxgraph.DependencyStructure.class, structureName, graph);
110                                    flowChartinstance.addFlowChartRegistry(org.maltparser.core.syntaxgraph.PhraseStructure.class, structureName, graph);
111                            } else if (dependency == false && phrase == true) {
112                                    graph = new PhraseStructureGraph(symbolTables);
113                                    flowChartinstance.addFlowChartRegistry(org.maltparser.core.syntaxgraph.PhraseStructure.class, structureName, graph);
114                            } else {
115                                    graph = new Sentence(symbolTables);
116                            }
117                            
118                            if (dataFormatInstance != null) {
119                                    ((DependencyStructure)graph).setDefaultRootEdgeLabels(
120                                                    OptionManager.instance().getOptionValue(getOptionContainerIndex(), "graph", "root_label").toString(), 
121                                                    dataFormatInstance.getDependencyEdgeLabelSymbolTables());
122                            }
123                            flowChartinstance.addFlowChartRegistry(org.maltparser.core.syntaxgraph.TokenStructure.class, structureName, graph);
124                    }
125                    return signal;
126            }
127            
128            public int process(int signal) throws MaltChainedException {
129                    return signal;
130            }
131            
132            public int postprocess(int signal) throws MaltChainedException {
133                    return signal;
134            }
135            
136            public void terminate() throws MaltChainedException {
137                    if (graph != null) {
138                            graph.clear();
139                            graph = null;
140                    }
141            }
142            
143            public boolean equals(Object obj) {
144                    if (this == obj)
145                            return true;
146                    if (obj == null)
147                            return false;
148                    if (getClass() != obj.getClass())
149                            return false;
150                    return obj.toString().equals(this.toString());
151            }
152            
153            public int hashCode() {
154                    return 217 + (null == toString() ? 0 : toString().hashCode());
155            }
156            
157            public String toString() {
158                    StringBuilder sb = new StringBuilder();
159                    sb.append("    graph ");
160                    sb.append("id:");sb.append(idName);
161                    sb.append(' ');
162                    sb.append("task:");
163                    sb.append(taskName);
164                    sb.append(' ');
165                    sb.append("structure:");
166                    sb.append(structureName);
167                    return sb.toString();
168            }
169    }