    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.value.AddressValue;
    006    import org.maltparser.core.syntaxgraph.SyntaxGraphException;
    007    import org.maltparser.core.syntaxgraph.node.DependencyNode;
    008    import org.maltparser.core.syntaxgraph.node.TokenNode;
    009    /**
    010    *
    011    *
    012    * @author Johan Hall
    013    */
    014    public class DGraphAddressFunction extends AddressFunction {
    015            public enum DGraphSubFunction {
    016                    HEAD, LDEP, RDEP, RDEP2, LSIB, RSIB, PRED, SUCC, ANC, PANC, LDESC, PLDESC, RDESC, PRDESC
    017            };
    018            private AddressFunction addressFunction;
    019            private String subFunctionName;
    020            private DGraphSubFunction subFunction;
    021
    022            public DGraphAddressFunction(String subFunctionName) {
    023                    super();
    024                    setSubFunctionName(subFunctionName);
    025            }
    026
    027            public void initialize(Object[] arguments) throws MaltChainedException {
    028                    if (arguments.length != 1) {
    029                            throw new SyntaxGraphException("Could not initialize NodeAddressFunction: number of arguments are not correct. ");
    030                    }
    031                    if (!(arguments[0] instanceof AddressFunction)) {
    032                            throw new SyntaxGraphException("Could not initialize NodeAddressFunction: the second argument is not an addres function. ");
    033                    }
    034                    setAddressFunction((AddressFunction)arguments[0]);
    035            }
    036
    037            public Class<?>[] getParameterTypes() {
    038                    Class<?>[] paramTypes = { org.maltparser.core.feature.function.AddressFunction.class };
    039                    return paramTypes;
    040            }
    041
    042            public void update() throws MaltChainedException {
    043                    final AddressValue a = addressFunction.getAddressValue();
    044                    if (a.getAddress() == null) {
    045                            address.setAddress(null);
    046                    } else {
    047    //                      try {
    048    //                              a.getAddressClass().asSubclass(org.maltparser.core.syntaxgraph.node.DependencyNode.class);
    049
    050                                    final DependencyNode node = (DependencyNode)a.getAddress();
    051                                    if (subFunction == DGraphSubFunction.HEAD && !node.isRoot()) {
    052                                            address.setAddress(node.getHead());
    053                                    } else if (subFunction == DGraphSubFunction.LDEP) {
    054                                            address.setAddress(node.getLeftmostDependent());
    055                                    } else if (subFunction == DGraphSubFunction.RDEP) {
    056                                            address.setAddress(node.getRightmostDependent());
    057                                    } else if (subFunction == DGraphSubFunction.RDEP2) {
    058                                            // To emulate the behavior of MaltParser 0.4 (bug)
    059                                            if (!node.isRoot()) {
    060                                                    address.setAddress(node.getRightmostDependent());
    061                                            } else {
    062                                                    address.setAddress(null);
    063                                            }
    064                                    } else if (subFunction == DGraphSubFunction.LSIB) {
    065                                            address.setAddress(node.getSameSideLeftSibling());
    066                                    } else if (subFunction == DGraphSubFunction.RSIB) {
    067                                            address.setAddress(node.getSameSideRightSibling());
    068                                    } else if (node instanceof TokenNode && subFunction == DGraphSubFunction.PRED) {
    069                                            address.setAddress(((TokenNode)node).getPredecessor());
    070                                    } else if (node instanceof TokenNode && subFunction == DGraphSubFunction.SUCC) {
    071                                            address.setAddress(((TokenNode)node).getSuccessor());
    072                                    } else if (subFunction == DGraphSubFunction.ANC) {
    073                                            address.setAddress(node.getAncestor());
    074                                    } else if (subFunction == DGraphSubFunction.PANC) {
    075                                            address.setAddress(node.getProperAncestor());
    076                                    } else if (subFunction == DGraphSubFunction.LDESC) {
    077                                            address.setAddress(node.getLeftmostDescendant());
    078                                    } else if (subFunction == DGraphSubFunction.PLDESC) {
    079                                            address.setAddress(node.getLeftmostProperDescendant());
    080                                    } else if (subFunction == DGraphSubFunction.RDESC) {
    081                                            address.setAddress(node.getRightmostDescendant());
    082                                    } else if (subFunction == DGraphSubFunction.PRDESC) {
    083                                            address.setAddress(node.getRightmostProperDescendant());
    084                                    } else {
    085                                            address.setAddress(null);
    086                                    }
    087    //                      } catch (ClassCastException e) {
    088    //                              address.setAddress(null);
    089    //                      }
    090                    }
    091            }
    092
    093            public void update(Object[] arguments) throws MaltChainedException {
    094                    update();
    095            }
    096
    097            public AddressFunction getAddressFunction() {
    098                    return addressFunction;
    099            }
    100
    101            public void setAddressFunction(AddressFunction addressFunction) {
    102                    this.addressFunction = addressFunction;
    103            }
    104
    105            public String getSubFunctionName() {
    106                    return subFunctionName;
    107            }
    108
    109            public void setSubFunctionName(String subFunctionName) {
    110                    this.subFunctionName = subFunctionName;
    111                    subFunction = DGraphSubFunction.valueOf(subFunctionName.toUpperCase());
    112            }
    113
    114            public DGraphSubFunction getSubFunction() {
    115                    return subFunction;
    116            }
    117
    118            public boolean equals(Object obj) {
    119                    if (this == obj)
    120                            return true;
    121                    if (obj == null)
    122                            return false;
    123                    if (getClass() != obj.getClass())
    124                            return false;
    125                    if (!addressFunction.equals(((DGraphAddressFunction)obj).getAddressFunction())) {
    126                            return false;
    127                    } else if (!subFunction.equals(((DGraphAddressFunction)obj).getSubFunction())) {
    128                            return false;
    129                    }
    130                    return true;
    131            }
    132
    133            public String toString() {
    134                    return subFunctionName + "(" + addressFunction.toString() + ")";
    135            }
    136    }