001 package org.maltparser.core.syntaxgraph.feature;
002
003 import org.maltparser.core.exception.MaltChainedException;
004 import org.maltparser.core.feature.FeatureException;
005 import org.maltparser.core.feature.function.AddressFunction;
006 import org.maltparser.core.feature.function.FeatureFunction;
007 import org.maltparser.core.feature.value.AddressValue;
008 import org.maltparser.core.feature.value.FeatureValue;
009 import org.maltparser.core.feature.value.SingleFeatureValue;
010 import org.maltparser.core.io.dataformat.ColumnDescription;
011 import org.maltparser.core.io.dataformat.DataFormatInstance;
012 import org.maltparser.core.symbol.SymbolTable;
013 import org.maltparser.core.symbol.SymbolTableHandler;
014 import org.maltparser.core.symbol.nullvalue.NullValues.NullValueId;
015 import org.maltparser.core.syntaxgraph.SyntaxGraphException;
016 import org.maltparser.core.syntaxgraph.node.DependencyNode;
017
018 /**
019 *
020 * @author Carlos Gomez Rodriguez
021 *
022 */
023 public class OutputArcFeature implements FeatureFunction {
024 protected AddressFunction addressFunction1;
025 protected AddressFunction addressFunction2;
026 protected ColumnDescription column;
027 protected DataFormatInstance dataFormatInstance;
028 protected SymbolTableHandler tableHandler;
029 protected SymbolTable table;
030 protected SingleFeatureValue featureValue;
031
032
033 public OutputArcFeature(DataFormatInstance dataFormatInstance, SymbolTableHandler tableHandler) throws MaltChainedException {
034 super();
035 setDataFormatInstance(dataFormatInstance);
036 setTableHandler(tableHandler);
037 setFeatureValue(new SingleFeatureValue(this));
038 }
039
040 public void initialize(Object[] arguments) throws MaltChainedException {
041 if (arguments.length != 3) {
042 throw new FeatureException("Could not initialize OutputArcFeature: number of arguments are not correct. ");
043 }
044 // Checks that the two arguments are address functions
045
046 if (!(arguments[0] instanceof String)) {
047 throw new FeatureException("Could not initialize OutputArcFeature: the first argument is not a string. ");
048 }
049 if (!(arguments[1] instanceof AddressFunction)) {
050 throw new SyntaxGraphException("Could not initialize OutputArcFeature: the second argument is not an address function. ");
051 }
052 if (!(arguments[2] instanceof AddressFunction)) {
053 throw new SyntaxGraphException("Could not initialize OutputArcFeature: the third argument is not an address function. ");
054 }
055 setAddressFunction1((AddressFunction)arguments[1]);
056 setAddressFunction2((AddressFunction)arguments[2]);
057
058 setColumn(dataFormatInstance.getColumnDescriptionByName((String)arguments[0]));
059 setSymbolTable(tableHandler.addSymbolTable("ARC_"+column.getName(),ColumnDescription.INPUT, "one"));
060 table.addSymbol("LEFT");
061 table.addSymbol("RIGHT");
062 }
063
064 public Class<?>[] getParameterTypes() {
065 Class<?>[] paramTypes = { java.lang.String.class , org.maltparser.core.feature.function.AddressFunction.class , org.maltparser.core.feature.function.AddressFunction.class };
066 return paramTypes;
067 }
068
069 public int getCode(String symbol) throws MaltChainedException {
070 return table.getSymbolStringToCode(symbol);
071 }
072
073
074 public FeatureValue getFeatureValue() {
075 return featureValue;
076 }
077
078
079 public String getSymbol(int code) throws MaltChainedException {
080 return table.getSymbolCodeToString(code);
081 }
082
083
084 public void updateCardinality() throws MaltChainedException {
085 featureValue.setCardinality(table.getValueCounter());
086 }
087
088 public void update() throws MaltChainedException {
089 // Retrieve the address value
090 final AddressValue arg1 = addressFunction1.getAddressValue();
091 final AddressValue arg2 = addressFunction2.getAddressValue();
092 try {
093
094 if (arg1.getAddress() == null || arg2.getAddress() == null) {
095 featureValue.setCode(table.getNullValueCode(NullValueId.NO_NODE));
096 featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
097 featureValue.setKnown(true);
098 featureValue.setNullValue(true);
099 } else {
100 final DependencyNode node1 = (DependencyNode)arg1.getAddress();
101 final DependencyNode node2 = (DependencyNode)arg2.getAddress();
102
103 int head1 = -1;
104 int head2 = -1;
105
106 if ( node1.hasHead() )
107 {
108 head1 = node1.getHead().getIndex(); //lines below don't seem to work
109 //head1 = Integer.parseInt(node1.getHeadEdgeLabelSymbol(column.getSymbolTable()));
110 //if ( node1.hasHeadEdgeLabel(column.getSymbolTable()) )
111 // head1 = Integer.parseInt(node1.getHeadEdgeLabelSymbol(column.getSymbolTable()));
112 }
113 if ( node2.hasHead() )
114 {
115 head2 = node2.getHead().getIndex(); //lines below don't seem to work
116 //head2 = Integer.parseInt(node2.getHeadEdgeLabelSymbol(column.getSymbolTable()));
117 //if ( node2.hasHeadEdgeLabel(column.getSymbolTable()) )
118 // head2 = Integer.parseInt(node2.getHeadEdgeLabelSymbol(column.getSymbolTable()));
119 }
120 if (!node1.isRoot() && head1 == node2.getIndex()) {
121 featureValue.setCode(table.getSymbolStringToCode("LEFT"));
122 featureValue.setSymbol("LEFT");
123 featureValue.setKnown(true);
124 featureValue.setNullValue(false);
125 } else if (!node2.isRoot() && head2 == node1.getIndex()) {
126 featureValue.setCode(table.getSymbolStringToCode("RIGHT"));
127 featureValue.setSymbol("RIGHT");
128 featureValue.setKnown(true);
129 featureValue.setNullValue(false);
130 } else {
131 featureValue.setCode(table.getNullValueCode(NullValueId.NO_NODE));
132 featureValue.setSymbol(table.getNullValueSymbol(NullValueId.NO_NODE));
133 featureValue.setKnown(true);
134 featureValue.setNullValue(true);
135 }
136 }
137 } catch (NumberFormatException e) {
138 throw new FeatureException("The index of the feature must be an integer value. ", e);
139 }
140 }
141
142 public ColumnDescription getColumn() {
143 return column;
144 }
145
146 public void setColumn(ColumnDescription column) throws MaltChainedException {
147 if (column.getType() != ColumnDescription.INTEGER) {
148 throw new FeatureException("OutputArc feature column must be of type integer. ");
149 }
150 this.column = column;
151 }
152
153 /**
154 * Returns the address function 1 (argument 1)
155 *
156 * @return the address function 1 (argument 1)
157 */
158 public AddressFunction getAddressFunction1() {
159 return addressFunction1;
160 }
161
162
163 /**
164 * Sets the address function 1 (argument 1)
165 *
166 * @param addressFunction1 a address function 1 (argument 1)
167 */
168 public void setAddressFunction1(AddressFunction addressFunction1) {
169 this.addressFunction1 = addressFunction1;
170 }
171
172 /**
173 * Returns the address function 2 (argument 2)
174 *
175 * @return the address function 1 (argument 2)
176 */
177 public AddressFunction getAddressFunction2() {
178 return addressFunction2;
179 }
180
181 /**
182 * Sets the address function 2 (argument 2)
183 *
184 * @param addressFunction2 a address function 2 (argument 2)
185 */
186 public void setAddressFunction2(AddressFunction addressFunction2) {
187 this.addressFunction2 = addressFunction2;
188 }
189
190 public DataFormatInstance getDataFormatInstance() {
191 return dataFormatInstance;
192 }
193
194 public void setDataFormatInstance(DataFormatInstance dataFormatInstance) {
195 this.dataFormatInstance = dataFormatInstance;
196 }
197
198 public void setFeatureValue(SingleFeatureValue featureValue) {
199 this.featureValue = featureValue;
200 }
201
202 public SymbolTable getSymbolTable() {
203 return table;
204 }
205
206 public void setSymbolTable(SymbolTable table) {
207 this.table = table;
208 }
209
210 public SymbolTableHandler getTableHandler() {
211 return tableHandler;
212 }
213
214 public void setTableHandler(SymbolTableHandler tableHandler) {
215 this.tableHandler = tableHandler;
216 }
217
218 public boolean equals(Object obj) {
219 if (!(obj instanceof InputArcFeature)) {
220 return false;
221 }
222 if (!obj.toString().equals(this.toString())) {
223 return false;
224 }
225 return true;
226 }
227
228 public String toString() {
229 return "OutputArc(" + column.getName() + ")";
230 }
231 }