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    }