001 package org.maltparser.parser.algorithm.stack; 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 StackAddressFunction extends AddressFunction { 013 public enum StackSubFunction { 014 STACK, INPUT, LOOKAHEAD 015 }; 016 protected String subFunctionName; 017 protected StackSubFunction subFunction; 018 protected Algorithm parsingAlgorithm; 019 protected int index; 020 021 public StackAddressFunction(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((StackConfig)parsingAlgorithm.getCurrentParserConfiguration()); 045 } 046 047 public void update(Object[] arguments) throws MaltChainedException { 048 if (arguments.length != 1 || !(arguments[0] instanceof StackConfig)) { 049 throw new ParsingException("Arguments to the Stack address function is not correct. "); 050 } 051 update((StackConfig)arguments[0]); 052 } 053 054 private void update(StackConfig config) throws MaltChainedException { 055 if (subFunction == StackSubFunction.STACK) { 056 address.setAddress(config.getStackNode(index)); 057 } else if (subFunction == StackSubFunction.INPUT) { 058 address.setAddress(config.getInputNode(index)); 059 } else if (subFunction == StackSubFunction.LOOKAHEAD) { 060 address.setAddress(config.getLookaheadNode(index)); 061 } else { 062 address.setAddress(null); 063 } 064 } 065 066 public String getSubFunctionName() { 067 return subFunctionName; 068 } 069 070 public void setSubFunctionName(String subFunctionName) { 071 this.subFunctionName = subFunctionName; 072 subFunction = StackSubFunction.valueOf(subFunctionName.toUpperCase()); 073 } 074 075 public StackSubFunction getSubFunction() { 076 return subFunction; 077 } 078 079 public AddressValue getAddressValue() { 080 return address; 081 } 082 083 public Algorithm getParsingAlgorithm() { 084 return parsingAlgorithm; 085 } 086 087 public void setAlgorithm(Algorithm parsingAlgorithm) { 088 this.parsingAlgorithm = parsingAlgorithm; 089 } 090 091 public int getIndex() { 092 return index; 093 } 094 095 public void setIndex(int index) { 096 this.index = index; 097 } 098 099 public boolean equals(Object obj) { 100 if (this == obj) 101 return true; 102 if (obj == null) 103 return false; 104 if (getClass() != obj.getClass()) 105 return false; 106 107 StackAddressFunction other = (StackAddressFunction) obj; 108 if (index != other.index) 109 return false; 110 if (parsingAlgorithm == null) { 111 if (other.parsingAlgorithm != null) 112 return false; 113 } else if (!parsingAlgorithm.equals(other.parsingAlgorithm)) 114 return false; 115 if (subFunction == null) { 116 if (other.subFunction != null) 117 return false; 118 } else if (!subFunction.equals(other.subFunction)) 119 return false; 120 return true; 121 } 122 123 public String toString() { 124 return subFunctionName + "[" + index + "]"; 125 } 126 }