    001    package org.maltparser.core.feature.map;
    002
    003    import org.maltparser.core.exception.MaltChainedException;
    004    import org.maltparser.core.feature.FeatureException;
    005    import org.maltparser.core.feature.function.FeatureFunction;
    006    import org.maltparser.core.feature.function.FeatureMapFunction;
    007    import org.maltparser.core.feature.value.FeatureValue;
    008    import org.maltparser.core.feature.value.FunctionValue;
    009    import org.maltparser.core.feature.value.MultipleFeatureValue;
    010    import org.maltparser.core.feature.value.SingleFeatureValue;
    011    import org.maltparser.core.io.dataformat.ColumnDescription;
    012    import org.maltparser.core.io.dataformat.DataFormatInstance;
    013    import org.maltparser.core.symbol.SymbolTable;
    014    import org.maltparser.core.symbol.SymbolTableHandler;
    015    /**
    016    *
    017    *
    018    * @author Johan Hall
    019    */
    020    public class SuffixFeature implements FeatureMapFunction {
    021            protected FeatureFunction parentFeature;
    022            protected MultipleFeatureValue multipleFeatureValue;
    023            protected SymbolTableHandler tableHandler;
    024            protected SymbolTable table;
    025            protected DataFormatInstance dataFormatInstance;
    026            protected ColumnDescription column;
    027            protected int suffixLength;
    028
    029            public SuffixFeature(DataFormatInstance dataFormatInstance) throws MaltChainedException {
    030                    super();
    031                    setDataFormatInstance(dataFormatInstance);
    032                    multipleFeatureValue = new MultipleFeatureValue(this);
    033            }
    034
    035            public void initialize(Object[] arguments) throws MaltChainedException {
    036                    if (arguments.length != 2) {
    037                            throw new FeatureException("Could not initialize SuffixFeature: number of arguments are not correct. ");
    038                    }
    039                    if (!(arguments[0] instanceof FeatureFunction)) {
    040                            throw new FeatureException("Could not initialize SuffixFeature: the first argument is not a feature. ");
    041                    }
    042                    if (!(arguments[1] instanceof Integer)) {
    043                            throw new FeatureException("Could not initialize SuffixFeature: the second argument is not a string. ");
    044                    }
    045                    setParentFeature((FeatureFunction)arguments[0]);
    046                    setSuffixLength(((Integer)arguments[1]).intValue());
    047                    ColumnDescription parentColumn = dataFormatInstance.getColumnDescriptionByName(parentFeature.getSymbolTable().getName());
    048                    if (parentColumn.getType() != ColumnDescription.STRING) {
    049                            throw new FeatureException("Could not initialize SuffixFeature: the first argument must be a string. ");
    050                    }
    051                    setColumn(dataFormatInstance.addInternalColumnDescription("SUFFIX_"+suffixLength+"_"+parentFeature.getSymbolTable().getName(), parentColumn));
    052                    setSymbolTable(column.getSymbolTable());
    053    //              setSymbolTable(tableHandler.addSymbolTable("SUFFIX_"+suffixLength+"_"+parentFeature.getSymbolTable().getName(), parentFeature.getSymbolTable()));
    054            }
    055
    056            public Class<?>[] getParameterTypes() {
    057                    Class<?>[] paramTypes = { org.maltparser.core.syntaxgraph.feature.InputColumnFeature.class, java.lang.Integer.class };
    058                    return paramTypes;
    059            }
    060
    061            public FeatureValue getFeatureValue() {
    062                    return multipleFeatureValue;
    063            }
    064
    065            public int getCode(String symbol) throws MaltChainedException {
    066                    return table.getSymbolStringToCode(symbol);
    067            }
    068
    069            public String getSymbol(int code) throws MaltChainedException {
    070                    return table.getSymbolCodeToString(code);
    071            }
    072
    073            public void update() throws MaltChainedException {
    074                    parentFeature.update();
    075                    FunctionValue value = parentFeature.getFeatureValue();
    076                    if (value instanceof SingleFeatureValue) {
    077                            String symbol = ((SingleFeatureValue)value).getSymbol();
    078                            if (((FeatureValue)value).isNullValue()) {
    079                                    multipleFeatureValue.addFeatureValue(parentFeature.getSymbolTable().getSymbolStringToCode(symbol), symbol);
    080                                    multipleFeatureValue.setNullValue(true);
    081                            } else {
    082                                    String suffixStr;
    083                                    if (symbol.length()-suffixLength > 0) {
    084                                            suffixStr = symbol.substring(symbol.length()-suffixLength);
    085                                    } else {
    086                                            suffixStr = symbol;
    087                                    }
    088                                    int code = table.addSymbol(suffixStr);
    089                                    multipleFeatureValue.addFeatureValue(code, suffixStr);
    090                                    multipleFeatureValue.setNullValue(false);
    091                            }
    092                    } else if (value instanceof MultipleFeatureValue) {
    093                            multipleFeatureValue.reset();
    094                            if (((MultipleFeatureValue)value).isNullValue()) {
    095                                    multipleFeatureValue.addFeatureValue(parentFeature.getSymbolTable().getSymbolStringToCode(((MultipleFeatureValue)value).getFirstSymbol()), ((MultipleFeatureValue)value).getFirstSymbol());
    096                                    multipleFeatureValue.setNullValue(true);
    097                            } else {
    098                                    for (String symbol : ((MultipleFeatureValue)value).getSymbols()) {
    099                                            String suffixStr;
    100                                            if (symbol.length()-suffixLength > 0) {
    101                                                    suffixStr = symbol.substring(symbol.length()-suffixLength);
    102                                            } else {
    103                                                    suffixStr = symbol;
    104                                            }
    105                                            int code = table.addSymbol(suffixStr);
    106                                            multipleFeatureValue.addFeatureValue(code, suffixStr);
    107                                            multipleFeatureValue.setNullValue(true);
    108                                    }
    109                            }
    110                    }
    111            }
    112
    113            public void updateCardinality() throws MaltChainedException {
    114    //              parentFeature.updateCardinality();
    115    //              multipleFeatureValue.setCardinality(table.getValueCounter());
    116            }
    117
    118            public FeatureFunction getParentFeature() {
    119                    return parentFeature;
    120            }
    121
    122            public void setParentFeature(FeatureFunction feature) {
    123                    this.parentFeature = feature;
    124            }
    125
    126            public int getSuffixLength() {
    127                    return suffixLength;
    128            }
    129
    130            public void setSuffixLength(int suffixLength) {
    131                    this.suffixLength = suffixLength;
    132            }
    133
    134            public SymbolTableHandler getTableHandler() {
    135                    return dataFormatInstance.getSymbolTables();
    136            }
    137
    138            public SymbolTable getSymbolTable() {
    139                    return table;
    140            }
    141
    142            public void setSymbolTable(SymbolTable table) {
    143                    this.table = table;
    144            }
    145
    146            public DataFormatInstance getDataFormatInstance() {
    147                    return dataFormatInstance;
    148            }
    149
    150            public void setDataFormatInstance(DataFormatInstance dataFormatInstance) {
    151                    this.dataFormatInstance = dataFormatInstance;
    152            }
    153
    154            public ColumnDescription getColumn() {
    155                    return column;
    156            }
    157
    158            protected void setColumn(ColumnDescription column) {
    159                    this.column = column;
    160            }
    161
    162            public boolean equals(Object obj) {
    163                    if (this == obj)
    164                            return true;
    165                    if (obj == null)
    166                            return false;
    167                    if (getClass() != obj.getClass())
    168                            return false;
    169                    return obj.toString().equals(this.toString());
    170            }
    171
    172            public String toString() {
    173                    final StringBuilder sb = new StringBuilder();
    174                    sb.append("Suffix(");
    175                    sb.append(parentFeature.toString());
    176                    sb.append(", ");
    177                    sb.append(suffixLength);
    178                    sb.append(')');
    179                    return sb.toString();
    180            }
    181    }