    001    package org.maltparser.core.syntaxgraph.feature;
    002
    003    import org.maltparser.core.exception.MaltChainedException;
    004    import org.maltparser.core.feature.FeatureException;
    005    import org.maltparser.core.feature.function.AddressFunction;
    006    import org.maltparser.core.feature.function.FeatureFunction;
    007    import org.maltparser.core.feature.value.AddressValue;
    008    import org.maltparser.core.feature.value.FeatureValue;
    009    import org.maltparser.core.feature.value.SingleFeatureValue;
    010    import org.maltparser.core.io.dataformat.ColumnDescription;
    011    import org.maltparser.core.io.dataformat.DataFormatInstance;
    012    import org.maltparser.core.symbol.SymbolTable;
    013    import org.maltparser.core.symbol.SymbolTableHandler;
    014    import org.maltparser.core.symbol.nullvalue.NullValues.NullValueId;
    015    import org.maltparser.core.syntaxgraph.SyntaxGraphException;
    016    import org.maltparser.core.syntaxgraph.node.DependencyNode;
    017    /**
    018    *
    019    * @author Johan Hall
    020    * @since 1.1
    021    **/
    022    public class InputArcFeature implements FeatureFunction {
    023            protected AddressFunction addressFunction1;
    024            protected AddressFunction addressFunction2;
    025            protected ColumnDescription column;
    026            protected DataFormatInstance dataFormatInstance;
    027            protected SymbolTableHandler tableHandler;
    028            protected SymbolTable table;
    029            protected SingleFeatureValue featureValue;
    030
    031
    032            public InputArcFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler) throws MaltChainedException {
    033                    super();
    034                    setDataFormatInstance(dataFormatInstance);
    035                    setTableHandler(tableHandler);
    036                    setFeatureValue(new SingleFeatureValue(this));
    037            }
    038
    039            public void initialize(Object[] arguments) throws MaltChainedException {
    040                    if (arguments.length != 3) {
    041                            throw new FeatureException("Could not initialize InputArcFeature: number of arguments are not correct. ");
    042                    }
    043                    // Checks that the two arguments are address functions
    044
    045                    if (!(arguments[0] instanceof String)) {
    046                            throw new FeatureException("Could not initialize InputArcFeature: the first argument is not a string. ");
    047                    }
    048                    if (!(arguments[1] instanceof AddressFunction)) {
    049                            throw new SyntaxGraphException("Could not initialize InputArcFeature: the second argument is not an address function. ");
    050                    }
    051                    if (!(arguments[2] instanceof AddressFunction)) {
    052                            throw new SyntaxGraphException("Could not initialize InputArcFeature: the third argument is not an address function. ");
    053                    }
    054                    setAddressFunction1((AddressFunction)arguments[1]);
    055                    setAddressFunction2((AddressFunction)arguments[2]);
    056
    057                    setColumn(dataFormatInstance.getColumnDescriptionByName((String)arguments[0]));
    058                    setSymbolTable(tableHandler.addSymbolTable("ARC_"+column.getName(),ColumnDescription.INPUT, "one"));
    059                    table.addSymbol("LEFT");
    060                    table.addSymbol("RIGHT");
    061            }
    062
    063            public Class<?>[] getParameterTypes() {
    064                Class<?>[] paramTypes = { java.lang.String.class, org.maltparser.core.feature.function.AddressFunction.class, org.maltparser.core.feature.function.AddressFunction.class };
    065                    return paramTypes;
    066            }
    067
    068            public int getCode(String symbol) throws MaltChainedException {
    069                    return table.getSymbolStringToCode(symbol);
    070            }
    071
    072
    073            public FeatureValue getFeatureValue() {
    074                    return featureValue;
    075            }
    076
    077
    078            public String getSymbol(int code) throws MaltChainedException {
    079                    return table.getSymbolCodeToString(code);
    080            }
    081
    082
    083            public void updateCardinality() throws MaltChainedException {
    084    //              featureValue.setCardinality(table.getValueCounter());
    085            }
    086
    087            public void update() throws MaltChainedException {
    088                    // Retrieve the address value
    089                    final AddressValue arg1 = addressFunction1.getAddressValue();
    090                    final AddressValue arg2 = addressFunction2.getAddressValue();
    091                    if (arg1.getAddress() != null && arg1.getAddressClass() == org.maltparser.core.syntaxgraph.node.DependencyNode.class &&
    092                        arg2.getAddress() != null && arg2.getAddressClass() == org.maltparser.core.syntaxgraph.node.DependencyNode.class) {
    093                        DependencyNode node1 = (DependencyNode)arg1.getAddress();
    094                        DependencyNode node2 = (DependencyNode)arg2.getAddress();
    095                        try {
    096                            int head1 = Integer.parseInt(node1.getLabelSymbol(column.getSymbolTable()));
    097                            int head2 = Integer.parseInt(node2.getLabelSymbol(column.getSymbolTable()));
    098                            if (!node1.isRoot() && head1 == node2.getIndex()) {
    099                                featureValue.setIndexCode(table.getSymbolStringToCode("LEFT"));
    100                                featureValue.setSymbol("LEFT");
    101                                featureValue.setNullValue(false);
    102                            } else if (!node2.isRoot() && head2 == node1.getIndex()) {
    103                                featureValue.setIndexCode(table.getSymbolStringToCode("RIGHT"));
    104                                featureValue.setSymbol("RIGHT");
    105                                featureValue.setNullValue(false);
    106                            } else {
    107                                featureValue.setIndexCode(table.getNullValueCode(NullValueId.NO_NODE));
    108                                featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
    109                                featureValue.setNullValue(true);
    110                            }
    111                        } catch (NumberFormatException e) {
    112                            throw new FeatureException("The index of the feature must be an integer value. ", e);
    113                        }
    114                    } else {
    115                        featureValue.setIndexCode(table.getNullValueCode(NullValueId.NO_NODE));
    116                        featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
    117                        featureValue.setNullValue(true);
    118                    }
    119    //              featureValue.setKnown(true);
    120                    featureValue.setValue(1);
    121            }
    122
    123            public ColumnDescription getColumn() {
    124                    return column;
    125            }
    126
    127            public void setColumn(ColumnDescription column) throws MaltChainedException {
    128                    if (column.getType() != ColumnDescription.INTEGER) {
    129                            throw new FeatureException("InputArc feature column must be of type integer. ");
    130                    }
    131                    this.column = column;
    132            }
    133
    134            /**
    135             * Returns the address function 1 (argument 1)
    136             *
    137             * @return the address function 1 (argument 1)
    138             */
    139            public AddressFunction getAddressFunction1() {
    140                    return addressFunction1;
    141            }
    142
    143
    144            /**
    145             * Sets the address function 1 (argument 1)
    146             *
    147             * @param addressFunction1 a address function 1 (argument 1)
    148             */
    149            public void setAddressFunction1(AddressFunction addressFunction1) {
    150                    this.addressFunction1 = addressFunction1;
    151            }
    152
    153            /**
    154             * Returns the address function 2 (argument 2)
    155             *
    156             * @return the address function 1 (argument 2)
    157             */
    158            public AddressFunction getAddressFunction2() {
    159                    return addressFunction2;
    160            }
    161
    162            /**
    163             * Sets the address function 2 (argument 2)
    164             *
    165             * @param addressFunction2 a address function 2 (argument 2)
    166             */
    167            public void setAddressFunction2(AddressFunction addressFunction2) {
    168                    this.addressFunction2 = addressFunction2;
    169            }
    170
    171            public DataFormatInstance getDataFormatInstance() {
    172                    return dataFormatInstance;
    173            }
    174
    175            public void setDataFormatInstance(DataFormatInstance dataFormatInstance) {
    176                    this.dataFormatInstance = dataFormatInstance;
    177            }
    178
    179            public void setFeatureValue(SingleFeatureValue featureValue) {
    180                    this.featureValue = featureValue;
    181            }
    182
    183            public SymbolTable getSymbolTable() {
    184                    return table;
    185            }
    186
    187            public void setSymbolTable(SymbolTable table) {
    188                    this.table = table;
    189            }
    190
    191            public SymbolTableHandler getTableHandler() {
    192                    return tableHandler;
    193            }
    194
    195            public void setTableHandler(SymbolTableHandler tableHandler) {
    196                    this.tableHandler = tableHandler;
    197            }
    198
    199            public  int getType() {
    200                    return ColumnDescription.STRING;
    201            }
    202
    203            public String getMapIdentifier() {
    204                    return getSymbolTable().getName();
    205            }
    206
    207            public boolean equals(Object obj) {
    208                    if (!(obj instanceof InputArcFeature)) {
    209                            return false;
    210                    }
    211                    if (!obj.toString().equals(this.toString())) {
    212                            return false;
    213                    }
    214                    return true;
    215            }
    216
    217            public String toString() {
    218                    return "InputArc(" + column.getName() + ")";
    219            }
    220    }