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