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 }