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