    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.setIndexCode(table.getSymbolStringToCode("LEFT"));
    103                                            featureValue.setValue(1);
    104                                            featureValue.setSymbol("LEFT");
    105                                            featureValue.setNullValue(false);
    106                                    } else {
    107                                            featureValue.setIndexCode(table.getSymbolStringToCode("RIGHT"));
    108                                            featureValue.setValue(1);
    109                                            featureValue.setSymbol("RIGHT");
    110                                            featureValue.setNullValue(false);
    111                                    }
    112                            } else {
    113                                    featureValue.setIndexCode(table.getNullValueCode(NullValueId.ROOT_NODE));
    114                                    featureValue.setValue(1);
    115                                    featureValue.setSymbol(table.getNullValueSymbol(NullValueId.ROOT_NODE));
    116                                    featureValue.setNullValue(true);
    117                            }
    118                    } else {
    119                            featureValue.setIndexCode(table.getNullValueCode(NullValueId.NO_NODE));
    120                            featureValue.setValue(1);
    121                            featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
    122                            featureValue.setNullValue(true);
    123                    }
    124    //              featureValue.setKnown(true);
    125            }
    126
    127            /**
    128             * Returns the feature value
    129             *
    130             * @return the feature value
    131             */
    132            public FeatureValue getFeatureValue() {
    133                    return featureValue;
    134            }
    135
    136            /**
    137             * Returns the symbol table used by the exists feature function
    138             *
    139             * @return the symbol table used by the exists feature function
    140             */
    141            public SymbolTable getSymbolTable() {
    142                    return table;
    143            }
    144
    145            /**
    146             * Returns the address function
    147             *
    148             * @return the address function
    149             */
    150            public AddressFunction getAddressFunction() {
    151                    return addressFunction;
    152            }
    153
    154
    155            /**
    156             * Sets the address function
    157             *
    158             * @param addressFunction a address function
    159             */
    160            public void setAddressFunction(AddressFunction addressFunction) {
    161                    this.addressFunction = addressFunction;
    162            }
    163
    164            /**
    165             * Returns symbol table handler
    166             *
    167             * @return a symbol table handler
    168             */
    169            public SymbolTableHandler getTableHandler() {
    170                    return tableHandler;
    171            }
    172            /**
    173             * Sets the symbol table handler
    174             *
    175             * @param tableHandler a symbol table handler
    176             */
    177            public void setTableHandler(SymbolTableHandler tableHandler) {
    178                    this.tableHandler = tableHandler;
    179            }
    180
    181            public  int getType() {
    182                    return ColumnDescription.STRING;
    183            }
    184
    185            public String getMapIdentifier() {
    186                    return getSymbolTable().getName();
    187            }
    188            /**
    189             * Sets the symbol table used by the exists feature function
    190             *
    191             * @param table
    192             */
    193            public void setSymbolTable(SymbolTable table) {
    194                    this.table = table;
    195            }
    196
    197            public boolean equals(Object obj) {
    198                    if (this == obj)
    199                            return true;
    200                    if (obj == null)
    201                            return false;
    202                    if (getClass() != obj.getClass())
    203                            return false;
    204                    return obj.toString().equals(this.toString());
    205            }
    206
    207            public int hashCode() {
    208                    return 217 + (null == toString() ? 0 : toString().hashCode());
    209            }
    210
    211            public String toString() {
    212                    final StringBuilder sb = new StringBuilder();
    213                    sb.append("ArcDir(");
    214                    sb.append(addressFunction.toString());
    215                    sb.append(')');
    216                    return sb.toString();
    217            }
    218    }