    001    package org.maltparser.core.symbol.nullvalue;
    002
    003    import java.util.HashMap;
    004    import java.util.SortedMap;
    005    import java.util.TreeMap;
    006
    007    import org.maltparser.core.exception.MaltChainedException;
    008    import org.maltparser.core.symbol.SymbolException;
    009    import org.maltparser.core.symbol.SymbolTable;
    010    /**
    011
    012
    013    @author Johan Hall
    014    @since 1.0
    015     */
    016    public abstract class NullValues {
    017            protected enum NullValueDegree {
    018                    NONE, ONE, ROOTLABEL, ROOTNODE, NOVALUE
    019            };
    020            public enum NullValueId {
    021                    NO_NODE, ROOT_NODE, NO_VALUE
    022            };
    023            protected HashMap<NullValueId, String> nullValue2SymbolMap;
    024            protected HashMap<NullValueId, Integer> nullValue2CodeMap;
    025            protected HashMap<String, Integer> symbol2CodeMap;
    026            protected SortedMap<Integer, String> code2SymbolMap;
    027            protected SymbolTable table;
    028            protected NullValueDegree nullValueEncoding;
    029            protected String nullValueStrategy;
    030            protected int nextCode;
    031
    032            public NullValues(SymbolTable table) {
    033                    setSymbolTable(table);
    034                    nullValue2SymbolMap = new HashMap<NullValueId, String>();
    035                    nullValue2CodeMap = new HashMap<NullValueId, Integer>();
    036                    symbol2CodeMap = new HashMap<String, Integer>();
    037                    code2SymbolMap = new TreeMap<Integer, String>();
    038            }
    039
    040            private void setSymbolTable(SymbolTable table) {
    041                    this.table = table;
    042            }
    043
    044            public SymbolTable getSymbolTable() {
    045                    return table;
    046            }
    047
    048            public String getNullValueStrategy() {
    049                    return nullValueStrategy;
    050            }
    051
    052            protected void setNullValueStrategy(String nullValueStrategy) {
    053                    this.nullValueStrategy = nullValueStrategy;
    054            }
    055
    056            public NullValueDegree getNullValueEncoding() {
    057                    return nullValueEncoding;
    058            }
    059
    060            public int getNextCode() {
    061                    return nextCode;
    062            }
    063
    064            protected void setNextCode(int nextCode) {
    065                    this.nextCode = nextCode;
    066            }
    067
    068            public boolean isNullValue(int code) {
    069                    return code2SymbolMap.containsKey(code);
    070            }
    071
    072            public boolean isNullValue(String symbol) {
    073                    return symbol2CodeMap.containsKey(symbol);
    074            }
    075
    076            public boolean isNullValue(StringBuilder symbol) {
    077                    return symbol2CodeMap.containsKey(symbol);
    078            }
    079
    080            public int nullvalueToCode(NullValueId nullValueIdentifier) throws MaltChainedException {
    081                    if (!nullValue2CodeMap.containsKey(nullValueIdentifier)) {
    082                            throw new SymbolException("Illegal null-value identifier. ");
    083                    }
    084                    return nullValue2CodeMap.get(nullValueIdentifier);
    085            }
    086
    087            public String nullvalueToSymbol(NullValueId nullValueIdentifier) throws MaltChainedException {
    088                    if (!nullValue2SymbolMap.containsKey(nullValueIdentifier)) {
    089                            throw new SymbolException("Illegal null-value identifier. ");
    090                    }
    091                    return nullValue2SymbolMap.get(nullValueIdentifier);
    092            }
    093
    094            public int symbolToCode(String symbol) {
    095                    if (!symbol2CodeMap.containsKey(symbol)) {
    096                            return -1;
    097                    }
    098                    return symbol2CodeMap.get(symbol);
    099            }
    100
    101            public int symbolToCode(StringBuilder symbol) {
    102                    if (!symbol2CodeMap.containsKey(symbol)) {
    103                            return -1;
    104                    }
    105                    return symbol2CodeMap.get(symbol);
    106            }
    107
    108            public String codeToSymbol(int code) {
    109                    if (!code2SymbolMap.containsKey(code)) {
    110                            return null;
    111                    }
    112                    return code2SymbolMap.get(code);
    113            }
    114
    115            protected abstract void setNullValueEncoding(String nullValueStrategy);
    116            protected abstract void makeNullValues();
    117
    118            /* (non-Javadoc)
    119             * @see java.lang.Object#equals(java.lang.Object)
    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
    129                    NullValues nl = (NullValues)obj;
    130                    if (!nullValueStrategy.equalsIgnoreCase(nl.getNullValueStrategy())) { return false; }
    131                    if (nextCode != nl.getNextCode()) { return false; }
    132                    if (!nullValue2SymbolMap.equals(nl.nullValue2SymbolMap)) { return false; }
    133                    if (!nullValue2CodeMap.equals(nl.nullValue2CodeMap)) { return false; }
    134                    if (!code2SymbolMap.equals(nl.code2SymbolMap)) { return false; }
    135                    if (!symbol2CodeMap.equals(nl.symbol2CodeMap)) { return false; }
    136                    return true;
    137            }
    138
    139            /* (non-Javadoc)
    140             * @see java.lang.Object#toString()
    141             */
    142            public String toString() {
    143                    StringBuilder sb = new StringBuilder();
    144                    sb.append("Null-values:\n");
    145                    sb.append("  Strategy: "+ nullValueStrategy);
    146                    sb.append("  NO_NODE -> "+ nullValue2CodeMap.get(NullValueId.NO_NODE) + " " + nullValue2SymbolMap.get(NullValueId.NO_NODE)+"\n");
    147                    sb.append("  ROOT_NODE -> "+ nullValue2CodeMap.get(NullValueId.ROOT_NODE) + " " + nullValue2SymbolMap.get(NullValueId.ROOT_NODE)+"\n");
    148                    sb.append("  NO_VALUE -> "+ nullValue2CodeMap.get(NullValueId.NO_VALUE) + " " + nullValue2SymbolMap.get(NullValueId.NO_VALUE)+"\n");
    149                    return sb.toString();
    150            }
    151    }