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