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 (code == 1)?"true":"false"; 
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 (symbol.equals("true"))?1:0;
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                    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  int getType() {
171                    return ColumnDescription.BOOLEAN;
172            }
173            
174            public String getMapIdentifier() {
175                    return "EXISTS";
176            }
177            
178            public boolean equals(Object obj) {
179                    if (this == obj)
180                            return true;
181                    if (obj == null)
182                            return false;
183                    if (getClass() != obj.getClass())
184                            return false;
185                    return obj.toString().equals(this.toString());
186            }
187            
188            public int hashCode() {
189                    return 217 + (null == toString() ? 0 : toString().hashCode());
190            }
191            
192            public String toString() {
193                    final StringBuilder sb = new StringBuilder();
194                    sb.append("Exists(");
195                    sb.append(addressFunction.toString());
196                    sb.append(')');
197                    return sb.toString();
198            }
199    }