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