    001    package org.maltparser.parser.algorithm.covington;
    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.parser.Algorithm;
    007    import org.maltparser.parser.ParsingException;
    008    /**
    009     * @author Johan Hall
    010     *
    011     */
    012    public class CovingtonAddressFunction extends AddressFunction {
    013            public enum CovingtonSubFunction {
    014                    LEFT, RIGHT, LEFTCONTEXT, RIGHTCONTEXT
    015            };
    016            private String subFunctionName;
    017            private CovingtonSubFunction subFunction;
    018            private Algorithm parsingAlgorithm;
    019            private int index;
    020
    021            public CovingtonAddressFunction(String subFunctionName, Algorithm parsingAlgorithm) {
    022                    super();
    023                    setSubFunctionName(subFunctionName);
    024                    setAlgorithm(parsingAlgorithm);
    025            }
    026
    027            public void initialize(Object[] arguments) throws MaltChainedException {
    028                    if (arguments.length != 1) {
    029                            throw new ParsingException("Could not initialize "+this.getClass().getName()+": number of arguments are not correct. ");
    030                    }
    031                    if (!(arguments[0] instanceof Integer)) {
    032                            throw new ParsingException("Could not initialize "+this.getClass().getName()+": the first argument is not an integer. ");
    033                    }
    034
    035                    setIndex(((Integer)arguments[0]).intValue());
    036            }
    037
    038            public Class<?>[] getParameterTypes() {
    039                    Class<?>[] paramTypes = { java.lang.Integer.class };
    040                    return paramTypes;
    041            }
    042
    043            public void update() throws MaltChainedException {
    044                    update((CovingtonConfig)parsingAlgorithm.getCurrentParserConfiguration());
    045            }
    046
    047            public void update(Object[] arguments) throws MaltChainedException {
    048                    if (arguments.length != 1 || !(arguments[0] instanceof CovingtonConfig)) {
    049                            throw new ParsingException("Number of arguments to the Covington address function is not correct. ");
    050                    }
    051                    update((CovingtonConfig)arguments[0]);
    052            }
    053
    054            private void update(CovingtonConfig config) throws MaltChainedException {
    055                    if (subFunction == CovingtonSubFunction.LEFT) {
    056                            address.setAddress(config.getLeftNode(index));
    057                    } else if (subFunction == CovingtonSubFunction.RIGHT) {
    058                            address.setAddress(config.getRightNode(index));
    059                    } else if (subFunction == CovingtonSubFunction.LEFTCONTEXT) {
    060                            address.setAddress(config.getLeftContextNode(index));
    061                    } else if (subFunction == CovingtonSubFunction.RIGHTCONTEXT) {
    062                            address.setAddress(config.getRightContextNode(index));
    063                    } else {
    064                            address.setAddress(null);
    065                    }
    066            }
    067
    068            public String getSubFunctionName() {
    069                    return subFunctionName;
    070            }
    071
    072            public void setSubFunctionName(String subFunctionName) {
    073                    this.subFunctionName = subFunctionName;
    074                    subFunction = CovingtonSubFunction.valueOf(subFunctionName.toUpperCase());
    075            }
    076
    077            public CovingtonSubFunction getSubFunction() {
    078                    return subFunction;
    079            }
    080
    081            public AddressValue getAddressValue() {
    082                    return address;
    083            }
    084
    085            public Algorithm getParsingAlgorithm() {
    086                    return parsingAlgorithm;
    087            }
    088
    089            public void setAlgorithm(Algorithm parsingAlgorithm) {
    090                    this.parsingAlgorithm = parsingAlgorithm;
    091            }
    092
    093            public int getIndex() {
    094                    return index;
    095            }
    096
    097            public void setIndex(int index) {
    098                    this.index = index;
    099            }
    100
    101            public boolean equals(Object obj) {
    102                    if (this == obj)
    103                            return true;
    104                    if (obj == null)
    105                            return false;
    106                    if (getClass() != obj.getClass())
    107                            return false;
    108
    109                    CovingtonAddressFunction other = (CovingtonAddressFunction) obj;
    110                    if (index != other.index)
    111                            return false;
    112                    if (parsingAlgorithm == null) {
    113                            if (other.parsingAlgorithm != null)
    114                                    return false;
    115                    } else if (!parsingAlgorithm.equals(other.parsingAlgorithm))
    116                            return false;
    117                    if (subFunction == null) {
    118                            if (other.subFunction != null)
    119                                    return false;
    120                    } else if (!subFunction.equals(other.subFunction))
    121                            return false;
    122                    return true;
    123            }
    124
    125            public String toString() {
    126                    final StringBuilder sb = new StringBuilder();
    127                    sb.append(subFunctionName);
    128                    sb.append('[');
    129                    sb.append(index);
    130                    sb.append(']');
    131                    return sb.toString();
    132            }
    133    }