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 ((subFunction == DGraphSubFunction.PRED || subFunction == DGraphSubFunction.SUCC) && node instanceof TokenNode) { 069 final TokenNode tokenNode = (TokenNode)node; 070 if (subFunction == DGraphSubFunction.PRED) { 071 address.setAddress(tokenNode.getPredecessor()); 072 } else if (subFunction == DGraphSubFunction.SUCC) { 073 address.setAddress(tokenNode.getSuccessor()); 074 } 075 } else if (subFunction == DGraphSubFunction.ANC) { 076 address.setAddress(node.getAncestor()); 077 } else if (subFunction == DGraphSubFunction.PANC) { 078 address.setAddress(node.getProperAncestor()); 079 } else if (subFunction == DGraphSubFunction.LDESC) { 080 address.setAddress(node.getLeftmostDescendant()); 081 } else if (subFunction == DGraphSubFunction.PLDESC) { 082 address.setAddress(node.getLeftmostProperDescendant()); 083 } else if (subFunction == DGraphSubFunction.RDESC) { 084 address.setAddress(node.getRightmostDescendant()); 085 } else if (subFunction == DGraphSubFunction.PRDESC) { 086 address.setAddress(node.getRightmostProperDescendant()); 087 } else { 088 address.setAddress(null); 089 } 090 // } catch (ClassCastException e) { 091 // address.setAddress(null); 092 // } 093 } 094 } 095 096 public void update(Object[] arguments) throws MaltChainedException { 097 update(); 098 } 099 100 public AddressFunction getAddressFunction() { 101 return addressFunction; 102 } 103 104 public void setAddressFunction(AddressFunction addressFunction) { 105 this.addressFunction = addressFunction; 106 } 107 108 public String getSubFunctionName() { 109 return subFunctionName; 110 } 111 112 public void setSubFunctionName(String subFunctionName) { 113 this.subFunctionName = subFunctionName; 114 subFunction = DGraphSubFunction.valueOf(subFunctionName.toUpperCase()); 115 } 116 117 public DGraphSubFunction getSubFunction() { 118 return subFunction; 119 } 120 121 public boolean equals(Object obj) { 122 if (this == obj) 123 return true; 124 if (obj == null) 125 return false; 126 if (getClass() != obj.getClass()) 127 return false; 128 if (!addressFunction.equals(((DGraphAddressFunction)obj).getAddressFunction())) { 129 return false; 130 } else if (!subFunction.equals(((DGraphAddressFunction)obj).getSubFunction())) { 131 return false; 132 } 133 return true; 134 } 135 136 public String toString() { 137 return subFunctionName + "(" + addressFunction.toString() + ")"; 138 } 139 }