    001    package org.maltparser.core.syntaxgraph;
    002
    003    import java.io.BufferedWriter;
    004    import java.io.FileNotFoundException;
    005    import java.io.FileOutputStream;
    006    import java.io.IOException;
    007    import java.io.OutputStreamWriter;
    008    import java.io.UnsupportedEncodingException;
    009
    010    import org.maltparser.core.config.ConfigurationDir;
    011    import org.maltparser.core.exception.MaltChainedException;
    012    import org.maltparser.core.flow.FlowChartInstance;
    013    import org.maltparser.core.flow.item.ChartItem;
    014    import org.maltparser.core.flow.spec.ChartItemSpecification;
    015    import org.maltparser.core.io.dataformat.DataFormatException;
    016    import org.maltparser.core.options.OptionManager;
    017    import org.maltparser.core.syntaxgraph.node.DependencyNode;
    018
    019    public class GraphAnalyzerChartItem extends ChartItem {
    020            private String idName;
    021            private String sourceName;
    022            private String task;
    023            private ConfigurationDir configDir;
    024            private DependencyStructure cachedSource = null;
    025            private BufferedWriter writer;
    026            private boolean closeStream = true;
    027            private int graphCounter = 1;
    028
    029            public void initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification) throws MaltChainedException {
    030                    super.initialize(flowChartinstance, chartItemSpecification);
    031                    for (String key : chartItemSpecification.getChartItemAttributes().keySet()) {
    032                            if (key.equals("id")) {
    033                                    idName = chartItemSpecification.getChartItemAttributes().get(key);
    034                            } else if (key.equals("source")) {
    035                                    sourceName = chartItemSpecification.getChartItemAttributes().get(key);
    036                            }
    037                    }
    038                    if (idName == null) {
    039                            idName = getChartElement("analyzer").getAttributes().get("id").getDefaultValue();
    040                    } else if (sourceName == null) {
    041                            sourceName = getChartElement("analyzer").getAttributes().get("source").getDefaultValue();
    042                    }
    043                    task = OptionManager.instance().getOptionValue(getOptionContainerIndex(), "analyzer", "task").toString();
    044                    configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(org.maltparser.core.config.ConfigurationDir.class, idName);
    045                    open(task+".dat",OptionManager.instance().getOptionValue(getOptionContainerIndex(), "input", "charset").toString());
    046            }
    047
    048            public int preprocess(int signal) throws MaltChainedException {
    049                    return signal;
    050            }
    051
    052            public int process(int signal) throws MaltChainedException {
    053                    if (task.equals("projectivity")) {
    054                            if (cachedSource == null) {
    055                                    cachedSource = (DependencyStructure)flowChartinstance.getFlowChartRegistry(org.maltparser.core.syntaxgraph.DependencyStructure.class, sourceName);
    056                            }
    057                            try {
    058                                    writer.append("graph # ");
    059                                    writer.append(Integer.toString(graphCounter));
    060                                    writer.append('\n');
    061                                    for (int index : cachedSource.getTokenIndices()) {
    062                                            DependencyNode node = cachedSource.getDependencyNode(index);
    063
    064                                            writer.append(Integer.toString(node.getIndex()));
    065                                            writer.append('\t');
    066                                            writer.append(Integer.toString(node.getHead().getIndex()));
    067                                            writer.append('\t');
    068                                            writer.append('#');
    069                                            writer.append('\t');
    070                                            if (node.isProjective()) {
    071                                                    writer.append("@P");
    072                                            } else {
    073                                                    writer.append("@N");
    074                                            }
    075                                            writer.append('\n');
    076                                    }
    077                                    writer.append('\n');
    078                            } catch (IOException e) {
    079                                    throw new MaltChainedException("", e);
    080                            }
    081                            graphCounter++;
    082                    }
    083                    return signal;
    084            }
    085
    086            public int postprocess(int signal) throws MaltChainedException {
    087                    return signal;
    088            }
    089
    090
    091            public void terminate() throws MaltChainedException {
    092                    cachedSource = null;
    093                    close();
    094            }
    095
    096            private void open(String fileName, String charsetName) throws MaltChainedException {
    097                    try {
    098                            open(new OutputStreamWriter(new FileOutputStream(fileName),charsetName));
    099                    } catch (FileNotFoundException e) {
    100                            throw new DataFormatException("The output file '"+fileName+"' cannot be found.", e);
    101                    } catch (UnsupportedEncodingException e) {
    102                            throw new DataFormatException("The character encoding set '"+charsetName+"' isn't supported.", e);
    103                    }
    104            }
    105
    106            private void open(OutputStreamWriter osw) throws MaltChainedException {
    107                    setWriter(new BufferedWriter(osw));
    108            }
    109
    110            private void setWriter(BufferedWriter writer) throws MaltChainedException  {
    111                    close();
    112                    this.writer = writer;
    113            }
    114
    115            private void close() throws MaltChainedException {
    116                    try {
    117                            if (writer != null) {
    118                                    writer.flush();
    119                                    if (closeStream) {
    120                                            writer.close();
    121                                    }
    122                                    writer = null;
    123                            }
    124                    }   catch (IOException e) {
    125                            throw new DataFormatException("Could not close the output file. ", e);
    126                    }
    127
    128            }
    129    }