    001    package org.maltparser.core.syntaxgraph.feature;
    002
    003    import org.maltparser.core.exception.MaltChainedException;
    004    import org.maltparser.core.feature.function.AddressFunction;
    005    import org.maltparser.core.feature.function.FeatureFunction;
    006    import org.maltparser.core.feature.value.FeatureValue;
    007    import org.maltparser.core.feature.value.SingleFeatureValue;
    008    import org.maltparser.core.io.dataformat.ColumnDescription;
    009    import org.maltparser.core.symbol.SymbolTable;
    010    import org.maltparser.core.symbol.SymbolTableHandler;
    011    import org.maltparser.core.symbol.nullvalue.NullValues.NullValueId;
    012    import org.maltparser.core.syntaxgraph.SyntaxGraphException;
    013    import org.maltparser.core.syntaxgraph.node.DependencyNode;
    014
    015    public class ArcDirFeature implements FeatureFunction {
    016            protected AddressFunction addressFunction;
    017            protected SymbolTableHandler tableHandler;
    018            protected SymbolTable table;
    019            protected SingleFeatureValue featureValue;
    020
    021            public ArcDirFeature(SymbolTableHandler tableHandler) throws MaltChainedException {
    022                    super();
    023                    featureValue = new SingleFeatureValue(this);
    024                    setTableHandler(tableHandler);
    025            }
    026
    027            /**
    028             * Initialize the exists feature function
    029             *
    030             * @param arguments an array of arguments with the type returned by getParameterTypes()
    031             * @throws MaltChainedException
    032             */
    033            public void initialize(Object[] arguments) throws MaltChainedException {
    034                    if (arguments.length != 1) {
    035                            throw new SyntaxGraphException("Could not initialize ArcDirFeature: number of arguments are not correct. ");
    036                    }
    037                    // Checks that the two arguments are address functions
    038                    if (!(arguments[0] instanceof AddressFunction)) {
    039                            throw new SyntaxGraphException("Could not initialize ArcDirFeature: the first argument is not an address function. ");
    040                    }
    041
    042                    setAddressFunction((AddressFunction)arguments[0]);
    043
    044                    // Creates a symbol table called "ARCDIR" using one null value
    045                    setSymbolTable(tableHandler.addSymbolTable("ARCDIR", ColumnDescription.INPUT, "one"));
    046
    047                    table.addSymbol("LEFT"); // The address exists
    048                    table.addSymbol("RIGHT"); // The address don't exists
    049            }
    050
    051            /**
    052             * Returns an array of class types used by the feature extraction system to invoke initialize with
    053             * correct arguments.
    054             *
    055             * @return an array of class types
    056             */
    057            public Class<?>[] getParameterTypes() {
    058                    Class<?>[] paramTypes = { org.maltparser.core.feature.function.AddressFunction.class };
    059                    return paramTypes;
    060            }
    061            /**
    062             * Returns the string representation of the integer <code>code</code> according to the exists feature function.
    063             *
    064             * @param code the integer representation of the symbol
    065             * @return the string representation of the integer <code>code</code> according to the exists feature function.
    066             * @throws MaltChainedException
    067             */
    068            public String getSymbol(int code) throws MaltChainedException {
    069                    return table.getSymbolCodeToString(code);
    070            }
    071
    072            /**
    073             * Returns the integer representation of the string <code>symbol</code> according to the exists feature function.
    074             *
    075             * @param symbol the string representation of the symbol
    076             * @return the integer representation of the string <code>symbol</code> according to the exists feature function.
    077             * @throws MaltChainedException
    078             */
    079            public int getCode(String symbol) throws MaltChainedException {
    080                    return table.getSymbolStringToCode(symbol);
    081            }
    082
    083            /**
    084             * Cause the exists feature function to update the cardinality of the feature value.
    085             *
    086             * @throws MaltChainedException
    087             */
    088            public void updateCardinality() {
    089                    featureValue.setCardinality(table.getValueCounter());
    090            }
    091
    092            /**
    093             * Cause the feature function to update the feature value.
    094             *
    095             * @throws MaltChainedException
    096             */
    097            public void update() throws MaltChainedException {
    098                    if (addressFunction.getAddressValue().getAddress() != null) {
    099                            final DependencyNode node = (DependencyNode)addressFunction.getAddressValue().getAddress();
    100                            if (!node.isRoot()) {
    101                                    if (node.getHead().getIndex() < node.getIndex()) {
    102                                            featureValue.setCode(table.getSymbolStringToCode("LEFT"));
    103                                            featureValue.setSymbol("LEFT");
    104                                            featureValue.setKnown(true);
    105                                            featureValue.setNullValue(false);
    106                                    } else {
    107                                            featureValue.setCode(table.getSymbolStringToCode("RIGHT"));
    108                                            featureValue.setSymbol("RIGHT");
    109                                            featureValue.setKnown(true);
    110                                            featureValue.setNullValue(false);
    111                                    }
    112                            } else {
    113                                    featureValue.setCode(table.getNullValueCode(NullValueId.ROOT_NODE));
    114                                    featureValue.setSymbol(table.getNullValueSymbol(NullValueId.ROOT_NODE));
    115                                    featureValue.setKnown(true);
    116                                    featureValue.setNullValue(true);
    117                            }
    118                    } else {
    119                            featureValue.setCode(table.getNullValueCode(NullValueId.NO_NODE));
    120                            featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
    121                            featureValue.setKnown(true);
    122                            featureValue.setNullValue(true);
    123                    }
    124            }
    125
    126            /**
    127             * Returns the feature value
    128             *
    129             * @return the feature value
    130             */
    131            public FeatureValue getFeatureValue() {
    132                    return featureValue;
    133            }
    134
    135            /**
    136             * Returns the symbol table used by the exists feature function
    137             *
    138             * @return the symbol table used by the exists feature function
    139             */
    140            public SymbolTable getSymbolTable() {
    141                    return table;
    142            }
    143
    144            /**
    145             * Returns the address function
    146             *
    147             * @return the address function
    148             */
    149            public AddressFunction getAddressFunction() {
    150                    return addressFunction;
    151            }
    152
    153
    154            /**
    155             * Sets the address function
    156             *
    157             * @param addressFunction a address function
    158             */
    159            public void setAddressFunction(AddressFunction addressFunction) {
    160                    this.addressFunction = addressFunction;
    161            }
    162
    163            /**
    164             * Returns symbol table handler
    165             *
    166             * @return a symbol table handler
    167             */
    168            public SymbolTableHandler getTableHandler() {
    169                    return tableHandler;
    170            }
    171            /**
    172             * Sets the symbol table handler
    173             *
    174             * @param tableHandler a symbol table handler
    175             */
    176            public void setTableHandler(SymbolTableHandler tableHandler) {
    177                    this.tableHandler = tableHandler;
    178            }
    179
    180            /**
    181             * Sets the symbol table used by the exists feature function
    182             *
    183             * @param table
    184             */
    185            public void setSymbolTable(SymbolTable table) {
    186                    this.table = table;
    187            }
    188
    189            public boolean equals(Object obj) {
    190                    if (this == obj)
    191                            return true;
    192                    if (obj == null)
    193                            return false;
    194                    if (getClass() != obj.getClass())
    195                            return false;
    196                    return obj.toString().equals(this.toString());
    197            }
    198
    199            public int hashCode() {
    200                    return 217 + (null == toString() ? 0 : toString().hashCode());
    201            }
    202
    203            public String toString() {
    204                    final StringBuilder sb = new StringBuilder();
    205                    sb.append("ArcDir(");
    206                    sb.append(addressFunction.toString());
    207                    sb.append(')');
    208                    return sb.toString();
    209            }
    210    }