CovingtonAddressFunction.java

package org.maltparser.parser.algorithm.covington;

import org.maltparser.core.exception.MaltChainedException;
import org.maltparser.core.feature.function.AddressFunction;
import org.maltparser.core.feature.value.AddressValue;
import org.maltparser.parser.Algorithm;
import org.maltparser.parser.ParsingException;

/**
 * @author Johan Hall
 *
 */
public class CovingtonAddressFunction extends AddressFunction {

    public enum CovingtonSubFunction {

        LEFT, RIGHT, LEFTCONTEXT, RIGHTCONTEXT
    };
    private String subFunctionName;
    private CovingtonSubFunction subFunction;
    private Algorithm parsingAlgorithm;
    private int index;

    public CovingtonAddressFunction(String subFunctionName, Algorithm parsingAlgorithm) {
        super();
        setSubFunctionName(subFunctionName);
        setAlgorithm(parsingAlgorithm);
    }

    public void initialize(Object[] arguments) throws MaltChainedException {
        if (arguments.length != 1) {
            throw new ParsingException("Could not initialize " + this.getClass().getName() + ": number of arguments are not correct. ");
        }
        if (!(arguments[0] instanceof Integer)) {
            throw new ParsingException("Could not initialize " + this.getClass().getName() + ": the first argument is not an integer. ");
        }

        setIndex(((Integer) arguments[0]).intValue());
    }

    public Class<?>[] getParameterTypes() {
        Class<?>[] paramTypes = {java.lang.Integer.class};
        return paramTypes;
    }

    public void update() throws MaltChainedException {
        update((CovingtonConfig) parsingAlgorithm.getCurrentParserConfiguration());
    }

    public void update(Object[] arguments) throws MaltChainedException {
//		if (arguments.length != 1 || !(arguments[0] instanceof CovingtonConfig)) {
//			throw new ParsingException("Number of arguments to the Covington address function is not correct. ");
//		}
        update((CovingtonConfig) arguments[0]);
    }

    private void update(CovingtonConfig config) throws MaltChainedException {
        if (subFunction == CovingtonSubFunction.LEFT) {
            address.setAddress(config.getLeftNode(index));
        } else if (subFunction == CovingtonSubFunction.RIGHT) {
            address.setAddress(config.getRightNode(index));
        } else if (subFunction == CovingtonSubFunction.LEFTCONTEXT) {
            address.setAddress(config.getLeftContextNode(index));
        } else if (subFunction == CovingtonSubFunction.RIGHTCONTEXT) {
            address.setAddress(config.getRightContextNode(index));
        } else {
            address.setAddress(null);
        }
    }

    public String getSubFunctionName() {
        return subFunctionName;
    }

    public void setSubFunctionName(String subFunctionName) {
        this.subFunctionName = subFunctionName;
        subFunction = CovingtonSubFunction.valueOf(subFunctionName.toUpperCase());
    }

    public CovingtonSubFunction getSubFunction() {
        return subFunction;
    }

    @Override
    public AddressValue getAddressValue() {
        return address;
    }

    public Algorithm getParsingAlgorithm() {
        return parsingAlgorithm;
    }

    public void setAlgorithm(Algorithm parsingAlgorithm) {
        this.parsingAlgorithm = parsingAlgorithm;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }

        CovingtonAddressFunction other = (CovingtonAddressFunction) obj;
        if (index != other.index) {
            return false;
        }
        if (parsingAlgorithm == null) {
            if (other.parsingAlgorithm != null) {
                return false;
            }
        } else if (!parsingAlgorithm.equals(other.parsingAlgorithm)) {
            return false;
        }
        if (subFunction == null) {
            if (other.subFunction != null) {
                return false;
            }
        } else if (!subFunction.equals(other.subFunction)) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append(subFunctionName);
        sb.append('[');
        sb.append(index);
        sb.append(']');
        return sb.toString();
    }
}