    001    package org.maltparser.core.syntaxgraph.writer;
    002
    003    import org.maltparser.core.config.ConfigurationDir;
    004    import org.maltparser.core.exception.MaltChainedException;
    005    import org.maltparser.core.flow.FlowChartInstance;
    006    import org.maltparser.core.flow.item.ChartItem;
    007    import org.maltparser.core.flow.spec.ChartItemSpecification;
    008    import org.maltparser.core.io.dataformat.DataFormatException;
    009    import org.maltparser.core.io.dataformat.DataFormatInstance;
    010    import org.maltparser.core.io.dataformat.DataFormatManager;
    011    import org.maltparser.core.options.OptionManager;
    012    import org.maltparser.core.symbol.SymbolTableHandler;
    013    import org.maltparser.core.syntaxgraph.TokenStructure;
    014
    015    /**
    016    *
    017    *
    018    * @author Johan Hall
    019    */
    020    public class WriteChartItem extends ChartItem {
    021            private String idName;
    022            private String outputFormatName;
    023            private String outputFileName;
    024            private String outputCharSet;
    025            private String writerOptions;
    026            private Class<? extends SyntaxGraphWriter> graphWriterClass;
    027
    028            private String nullValueStrategy;
    029
    030            private SyntaxGraphWriter writer;
    031            private String sourceName;
    032            private String optiongroupName;
    033            private DataFormatInstance outputDataFormatInstance;
    034            private TokenStructure cachedGraph = null;
    035
    036            public WriteChartItem() { super(); }
    037
    038            public void initialize(FlowChartInstance flowChartinstance, ChartItemSpecification chartItemSpecification) throws MaltChainedException {
    039                    super.initialize(flowChartinstance, chartItemSpecification);
    040
    041                    for (String key : chartItemSpecification.getChartItemAttributes().keySet()) {
    042                            if (key.equals("id")) {
    043                                    idName = chartItemSpecification.getChartItemAttributes().get(key);
    044                            } else if (key.equals("source")) {
    045                                    sourceName = chartItemSpecification.getChartItemAttributes().get(key);
    046                            } else if (key.equals("optiongroup")) {
    047                                    optiongroupName = chartItemSpecification.getChartItemAttributes().get(key);
    048                            }
    049                    }
    050
    051                    if (idName == null) {
    052                            idName = getChartElement("write").getAttributes().get("id").getDefaultValue();
    053                    } else if (sourceName == null) {
    054                            sourceName = getChartElement("write").getAttributes().get("source").getDefaultValue();
    055                    } else if (optiongroupName == null) {
    056                            optiongroupName = getChartElement("write").getAttributes().get("optiongroup").getDefaultValue();
    057                    }
    058
    059                    setOutputFormatName(OptionManager.instance().getOptionValue(getOptionContainerIndex(), optiongroupName, "format").toString());
    060                    setOutputFileName(OptionManager.instance().getOptionValue(getOptionContainerIndex(), optiongroupName, "outfile").toString());
    061                    setOutputCharSet(OptionManager.instance().getOptionValue(getOptionContainerIndex(), optiongroupName, "charset").toString());
    062                    setWriterOptions(OptionManager.instance().getOptionValue(getOptionContainerIndex(), optiongroupName, "writer_options").toString());
    063                    setSyntaxGraphWriterClass((Class<?>)OptionManager.instance().getOptionValue(getOptionContainerIndex(), optiongroupName, "writer"));
    064
    065                    setNullValueStrategy(OptionManager.instance().getOptionValue(getOptionContainerIndex(), "singlemalt", "null_value").toString());
    066
    067                    initOutput(getNullValueStrategy());
    068                    initWriter(getSyntaxGraphWriterClass(), getOutputFileName(), getOutputCharSet(), getWriterOptions());
    069            }
    070
    071            public int preprocess(int signal) throws MaltChainedException {
    072                    return signal;
    073            }
    074
    075            public int process(int signal) throws MaltChainedException {
    076                    if (cachedGraph == null) {
    077                            cachedGraph = (TokenStructure)flowChartinstance.getFlowChartRegistry(org.maltparser.core.syntaxgraph.TokenStructure.class, sourceName);
    078                            writer.writeProlog();
    079                    }
    080                    writer.writeSentence(cachedGraph);
    081                    if (signal == ChartItem.TERMINATE) {
    082                            writer.writeEpilog();
    083                    }
    084                    return signal;
    085            }
    086
    087            public int postprocess(int signal) throws MaltChainedException {
    088                    return signal;
    089            }
    090
    091            public void terminate() throws MaltChainedException {
    092                    if (writer != null) {
    093                            writer.close();
    094                            writer = null;
    095                    }
    096                    outputDataFormatInstance = null;
    097                    cachedGraph = null;
    098            }
    099
    100            public String getOutputFormatName() {
    101                    if (outputFormatName == null) {
    102                            return "/appdata/dataformat/conllx.xml";
    103                    }
    104                    return outputFormatName;
    105            }
    106
    107            public void setOutputFormatName(String outputFormatName) {
    108                    this.outputFormatName = outputFormatName;
    109            }
    110
    111            public String getOutputFileName() {
    112                    if (outputFileName == null) {
    113                            return "/dev/stdout";
    114                    }
    115                    return outputFileName;
    116            }
    117
    118            public void setOutputFileName(String outputFileName) {
    119                    this.outputFileName = outputFileName;
    120            }
    121
    122            public String getOutputCharSet() {
    123                    if (outputCharSet == null) {
    124                            return "UTF-8";
    125                    }
    126                    return outputCharSet;
    127            }
    128
    129            public void setOutputCharSet(String outputCharSet) {
    130                    this.outputCharSet = outputCharSet;
    131            }
    132
    133            public String getWriterOptions() {
    134                    if (writerOptions == null) {
    135                            return "";
    136                    }
    137                    return writerOptions;
    138            }
    139
    140            public void setWriterOptions(String writerOptions) {
    141                    this.writerOptions = writerOptions;
    142            }
    143
    144            public Class<? extends SyntaxGraphWriter> getSyntaxGraphWriterClass() {
    145                    return graphWriterClass;
    146            }
    147
    148            public void setSyntaxGraphWriterClass(Class<?> graphWriterClass) throws MaltChainedException {
    149                    try {
    150                            if (graphWriterClass != null) {
    151                                    this.graphWriterClass = graphWriterClass.asSubclass(org.maltparser.core.syntaxgraph.writer.SyntaxGraphWriter.class);
    152                            }
    153                    } catch (ClassCastException e) {
    154                            throw new DataFormatException("The class '"+graphWriterClass.getName()+"' is not a subclass of '"+org.maltparser.core.syntaxgraph.writer.SyntaxGraphWriter.class.getName()+"'. ", e);
    155                    }
    156            }
    157
    158            public String getNullValueStrategy() {
    159                    if (nullValueStrategy == null) {
    160                            return "one";
    161                    }
    162                    return nullValueStrategy;
    163            }
    164
    165            public void setNullValueStrategy(String nullValueStrategy) {
    166                    this.nullValueStrategy = nullValueStrategy;
    167            }
    168
    169            public void initOutput(String nullValueStategy) throws MaltChainedException {
    170                    ConfigurationDir configDir = (ConfigurationDir)flowChartinstance.getFlowChartRegistry(org.maltparser.core.config.ConfigurationDir.class, idName);
    171                    DataFormatManager dataFormatManager = configDir.getDataFormatManager();
    172                    SymbolTableHandler symbolTables = configDir.getSymbolTables();
    173
    174                    if (configDir.sizeDataFormatInstance() == 0 || dataFormatManager.getInputDataFormatSpec() != dataFormatManager.getOutputDataFormatSpec()) {
    175                            outputDataFormatInstance = dataFormatManager.getOutputDataFormatSpec().createDataFormatInstance(symbolTables, nullValueStategy);
    176                            configDir.addDataFormatInstance(dataFormatManager.getInputDataFormatSpec().getDataFormatName(), outputDataFormatInstance);
    177                    } else {
    178                            outputDataFormatInstance = configDir.getDataFormatInstance(dataFormatManager.getInputDataFormatSpec().getDataFormatName()); //dataFormatInstances.get(dataFormatManager.getInputDataFormatSpec().getDataFormatName());
    179                    }
    180            }
    181
    182            public void initWriter(Class<? extends SyntaxGraphWriter> syntaxGraphWriterClass, String outputFile, String outputCharSet,
    183                            String writerOption) throws MaltChainedException {
    184                    try {
    185                            writer = syntaxGraphWriterClass.newInstance();
    186                            if (outputFile == null || outputFile.length() == 0 || outputFile.equals("/dev/stdout")) {
    187                                    writer.open(System.out, outputCharSet);
    188                            } else {
    189                                    writer.open(outputFile, outputCharSet);
    190                            }
    191                            writer.setDataFormatInstance(outputDataFormatInstance);
    192                            writer.setOptions(writerOption);
    193                    } catch (InstantiationException e) {
    194                            throw new DataFormatException("The data writer '"+syntaxGraphWriterClass.getName()+"' cannot be initialized. ", e);
    195                    } catch (IllegalAccessException e) {
    196                            throw new DataFormatException("The data writer '"+syntaxGraphWriterClass.getName()+"' cannot be initialized. ", e);
    197                    }
    198            }
    199
    200            public Class<? extends SyntaxGraphWriter> getGraphWriterClass() {
    201                    return graphWriterClass;
    202            }
    203
    204            public SyntaxGraphWriter getWriter() {
    205                    return writer;
    206            }
    207
    208            public String getSourceName() {
    209                    return sourceName;
    210            }
    211
    212            public DataFormatInstance getOutputDataFormatInstance() {
    213                    return outputDataFormatInstance;
    214            }
    215
    216            public boolean equals(Object obj) {
    217                    if (this == obj)
    218                            return true;
    219                    if (obj == null)
    220                            return false;
    221                    if (getClass() != obj.getClass())
    222                            return false;
    223                    return obj.toString().equals(this.toString());
    224            }
    225
    226            public int hashCode() {
    227                    return 217 + (null == toString() ? 0 : toString().hashCode());
    228            }
    229
    230            public String toString() {
    231                    StringBuilder sb = new StringBuilder();
    232                    sb.append("    write ");
    233                    sb.append("id:");sb.append(idName);
    234                    sb.append(' ');
    235                    sb.append("source:");
    236                    sb.append(sourceName);
    237                    sb.append(' ');
    238                    sb.append("optiongroup:");
    239                    sb.append(optiongroupName);
    240                    return sb.toString();
    241            }
    242    }