node.java

一个自然语言处理的Java开源工具包。LingPipe目前已有很丰富的功能

    public PAT2NodeLong(char c1, char c2, long count) {
        super(c1,c2);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class PAT3NodeLong extends PAT3Node {
    final long mCount;
    public PAT3NodeLong(char c1, char c2, char c3, long count) {
        super(c1,c2,c3);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class PAT4NodeLong extends PAT4Node {
    final long mCount;
    public PAT4NodeLong(char c1, char c2, char c3, char c4,
                        long count) {
        super(c1,c2,c3,c4);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class PATArrayNodeLong extends PATArrayNode {
    final long mCount;
    public PATArrayNodeLong(char[] cs, long count) {
        super(cs);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class TerminalNodeLong extends TerminalNode {
    final long mCount;
    public TerminalNodeLong(long count) {
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class OneDtrNodeLong extends OneDtrNode {
    final long mCount;
    public OneDtrNodeLong(char c, Node dtr, long count) {
        super(c,dtr);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class TwoDtrNodeLong extends TwoDtrNode {
    final long mCount;
    public TwoDtrNodeLong(char c1, Node dtr1,
                          char c2, Node dtr2,
                          long count) {
        super(c1,dtr1,c2,dtr2);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class ThreeDtrNodeLong extends ThreeDtrNode {
    final long mCount;
    public ThreeDtrNodeLong(char c1, Node dtr1,
                            char c2, Node dtr2,
                            char c3, Node dtr3,
                            long count) {
        super(c1,dtr1,c2,dtr2,c3,dtr3);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}
final class ArrayDtrNodeLong extends ArrayDtrNodeCacheExtCount {
    final long mCount;
    public ArrayDtrNodeLong(char[] cs, Node[] dtrs, long count) {
        super(cs,dtrs);
        mCount = count;
    }
    public long count() {
        return mCount;
    }
}

class NodeFactory {
    static char[] sliceToArray(char[] cs, int start, int end) {
        if (start == 0 && end==cs.length) return cs;
        char[] result = new char[end-start];
        for (int i = 0; i < result.length; ++i)
            result[i] = cs[start+i];
        return result;
    }
    static Node[] TERMINAL_NODES
        = new Node[1024];
    static {
        for (int i = 0; i < TERMINAL_NODES.length; ++i)
            TERMINAL_NODES[i] = createTerminalNode(i);
    }
    static Node createNode(long count) {
        if (count < TERMINAL_NODES.length)
            return TERMINAL_NODES[(int)count];
        return createTerminalNode(count);
    }
    static Node createNode(char[] cs, int start, int end, long count) {
        switch (end-start) {
        case 0: return createNode(count);
        case 1: return createNode(cs[start],count);
        case 2: return createNode(cs[start],cs[start+1],count);
        case 3: return createNode(cs[start],cs[start+1],cs[start+2],count);
        case 4: return createNode(cs[start],cs[start+1],cs[start+2],
                                  cs[start+3],count);
        default: return createPATArrayNode(sliceToArray(cs,start,end),count);
        }
    }
    static Node createNode(char[] cs, Node[] dtrs, long count) {
        switch (dtrs.length) {
        case 0: return createNode(count);
        case 1: return createNode(cs[0],dtrs[0],count);
        case 2: return createNode(cs[0],dtrs[0],cs[1],dtrs[1],count);
        case 3: return createNode(cs[0],dtrs[0],cs[1],dtrs[1],
                                  cs[2],dtrs[2],count);
        default: return createArrayDtrNode(cs,dtrs,count);
        }
    }
    static Node createNodePrune(char[] cs, Node[] dtrs, long count) {
        int numOutcomes = 0;
        for (int i = 0; i < dtrs.length; ++i)
            if (dtrs[i] != null) ++numOutcomes;
        if (numOutcomes == dtrs.length) return createNode(cs,dtrs,count);
        char[] csOut = new char[numOutcomes];
        Node[] dtrsOut = new Node[numOutcomes];
        int indexOut = 0;
        for (int i = 0; i < dtrs.length; ++i) {
            if (dtrs[i] != null) {
                csOut[indexOut] = cs[i];
                dtrsOut[indexOut] = dtrs[i];
                ++indexOut;
            }
        }
        return createNode(csOut,dtrsOut,count);
    }
    static Node createNode(char[] cs, int start, int end,
                           long headCount, long tailCount) {
        if (end == start)
            return createNode(headCount);
        if (headCount == tailCount)
            return createNode(cs,start,end,headCount);
        return createNode(cs[start],
                          createNode(cs,start+1,end,tailCount),
                          headCount);
    }
    static Node createTerminalNode(long count) {
        if (count <= Byte.MAX_VALUE)
            return new TerminalNodeByte(count);
        else if (count <= Short.MAX_VALUE)
            return new TerminalNodeShort(count);
        else if (count <= Integer.MAX_VALUE)
            return new TerminalNodeInt(count);
        else
            return new TerminalNodeLong(count);
    }
    static Node createNode(char c, long count) {
        if (count == 1)
            return new PAT1NodeOne(c);
        else if (count == 2)
            return new PAT1NodeTwo(c);
        else if (count == 3)
            return new PAT1NodeThree(c);
        else if (count <= Byte.MAX_VALUE)
            return new PAT1NodeByte(c,count);
        else if (count <= Short.MAX_VALUE)
            return new PAT1NodeShort(c,count);
        else if (count <= Integer.MAX_VALUE)
            return new PAT1NodeInt(c,count);
        else
            return new PAT1NodeLong(c,count);
    }
    static Node createNode(char c1, char c2, long count) {
        if (count == 1)
            return new PAT2NodeOne(c1,c2);
        else if (count == 2)
            return new PAT2NodeTwo(c1,c2);
        else if (count == 3)
            return new PAT2NodeThree(c1,c2);
        else if (count <= Byte.MAX_VALUE)
            return new PAT2NodeByte(c1,c2,count);
        else if (count <= Short.MAX_VALUE)
            return new PAT2NodeShort(c1,c2,count);
        else if (count <= Integer.MAX_VALUE)
            return new PAT2NodeInt(c1,c2,count);
        else
            return new PAT2NodeLong(c1,c2,count);
    }
    static Node createNode(char c1, char c2, char c3, long count) {
        if (count == 1)
            return new PAT3NodeOne(c1,c2,c3);
        else if (count == 2)
            return new PAT3NodeTwo(c1,c2,c3);
        else if (count == 3)
            return new PAT3NodeThree(c1,c2,c3);
        else if (count <= Byte.MAX_VALUE)
            return new PAT3NodeByte(c1,c2,c3,count);
        else if (count <= Short.MAX_VALUE)
            return new PAT3NodeShort(c1,c2,c3,count);
        else if (count <= Integer.MAX_VALUE)
            return new PAT3NodeInt(c1,c2,c3,count);
        else
            return new PAT3NodeLong(c1,c2,c3,count);
    }
    static Node createNode(char c1, char c2, char c3, char c4, long count) {
        if (count == 1)
            return new PAT4NodeOne(c1,c2,c3,c4);
        else if (count == 2)
            return new PAT4NodeTwo(c1,c2,c3,c4);
        else if (count == 3)
            return new PAT4NodeThree(c1,c2,c3,c4);
        else if (count <= Byte.MAX_VALUE)
            return new PAT4NodeByte(c1,c2,c3,c4,count);
        else if (count <= Short.MAX_VALUE)
            return new PAT4NodeShort(c1,c2,c3,c4,count);
        else if (count <= Integer.MAX_VALUE)
            return new PAT4NodeInt(c1,c2,c3,c4,count);
        else
            return new PAT4NodeLong(c1,c2,c3,c4,count);
    }
    static Node createPATArrayNode(char[] cs, long count) {
        if (count == 1)
            return new PATArrayNodeOne(cs);
        else if (count == 2)
            return new PATArrayNodeTwo(cs);
        else if (count == 3)
            return new PATArrayNodeThree(cs);
        else if (count <= Byte.MAX_VALUE)
            return new PATArrayNodeByte(cs,count);
        else if (count <= Short.MAX_VALUE)
            return new PATArrayNodeShort(cs,count);
        else if (count <= Integer.MAX_VALUE)
            return new PATArrayNodeInt(cs,count);
        else
            return new PATArrayNodeLong(cs,count);
    }
    static Node createPATNode(char firstC, char[] restCs, long count) {
        switch (restCs.length) {
        case 0: 
            return createNode(firstC,count);
        case 1:
            return createNode(firstC,restCs[0],count);
        case 2:
            return createNode(firstC,restCs[0],restCs[1],count);
        case 3:
            return createNode(firstC,restCs[0],restCs[1],restCs[2],count);
        default:
            char[] cs = new char[restCs.length+1];
            cs[0] = firstC;
            System.arraycopy(restCs,0,cs,1,restCs.length);
            return createPATArrayNode(cs,count);
        }
    }
    static Node createNodeFold(char c, Node dtr, long count) {
        if (dtr.count() == count) {
            if (dtr instanceof AbstractPATNode) {
                AbstractPATNode patDtr = (AbstractPATNode) dtr;
                return createPATNode(c,patDtr.chars(),count);        
            } 
            if (dtr instanceof TerminalNode) {
                return createNode(c,count);
            }
        }
        return createNode(c,dtr,count);
    }
    static Node createNode(char c, Node dtr, long count) {
        if (count <= Byte.MAX_VALUE)
            return new OneDtrNodeByte(c,dtr,count);
        else if (count <= Short.MAX_VALUE)
            return new OneDtrNodeShort(c,dtr,count);
        else if (count <= Integer.MAX_VALUE)
            return new OneDtrNodeInt(c,dtr,count);
        else
            return new OneDtrNodeLong(c,dtr,count);
    }
    static Node createNode(char c1, Node dtr1,
                           char c2, Node dtr2,
                           long count) {
        if (count <= Byte.MAX_VALUE)
            return new TwoDtrNodeByte(c1,dtr1,c2,dtr2,count);
        else if (count <= Short.MAX_VALUE)
            return new TwoDtrNodeShort(c1,dtr1,c2,dtr2,count);
        else if (count <= Integer.MAX_VALUE)
            return new TwoDtrNodeInt(c1,dtr1,c2,dtr2,count);
        else
            return new TwoDtrNodeLong(c1,dtr1,c2,dtr2,count);
    }
    static Node createNode(char c1, Node dtr1,
                           char c2, Node dtr2,
                           char c3, Node dtr3,
                           long count) {
        if (count <= Byte.MAX_VALUE)
            return new ThreeDtrNodeByte(c1,dtr1,c2,dtr2,c3,dtr3,count);
        else if (count <= Short.MAX_VALUE)
            return new ThreeDtrNodeShort(c1,dtr1,c2,dtr2,c3,dtr3,count);
        else if (count <= Integer.MAX_VALUE)
            return new ThreeDtrNodeInt(c1,dtr1,c2,dtr2,c3,dtr3,count);
        else
            return new ThreeDtrNodeLong(c1,dtr1,c2,dtr2,c3,dtr3,count);
    }
    static Node createArrayDtrNode(char[] cs, Node[] dtrs, long count) {
        if (count <= Byte.MAX_VALUE)
            return new ArrayDtrNodeByte(cs,dtrs,count);
        else if (count <= Short.MAX_VALUE)
            return new ArrayDtrNodeShort(cs,dtrs,count);
        else if (count <= Integer.MAX_VALUE)
            return new ArrayDtrNodeInt(cs,dtrs,count);
        else
            return new ArrayDtrNodeLong(cs,dtrs,count);
    }

    static Node[] EMPTY_NODES = new Node[0];
}


class NBestCounter extends NBestSet<NBestCounter.NBEntry> {
    static final long serialVersionUID = -1604467508550079460L;
    private final boolean mReversed;  // [carp: my hack]
    public NBestCounter(int maxEntries) {
        this(maxEntries,false);
    }
    public NBestCounter(int maxEntries, boolean reversed) {
        super(maxEntries);
        mReversed = reversed;
    }
    public ObjectToCounterMap<String> toObjectToCounter() {
        ObjectToCounterMap<String> otc = new ObjectToCounterMap<String>();
        for (NBEntry entry : this) {
            if (entry.mCount > Integer.MAX_VALUE) {
                String msg = "Entry too large.";
                throw new IllegalArgumentException(msg);
            }
            otc.set(entry.mString,(int)entry.mCount);
        }
        return otc;
    }
    public void put(char[] cs, int length, long count) {
        add(new NBEntry(cs,length,count));
    }
    class NBEntry implements Comparable<NBEntry> {
        // static w/o hack
        final String mString;
        final long mCount;
        public NBEntry(char[] cs, int length, long count) {
            mString = new String(cs,0,length);
            mCount = count;
        }
        public int compareTo(NBEntry thatEntry) {
            if (thatEntry.mCount == mCount)
                return thatEntry.mString.compareTo(mString);
            long diff = thatEntry.mCount - mCount;
            int comp 
                = (diff < 0)
                ? -1
                : ( (diff > 0)
                    ? 1
                    : 0 );
            return mReversed ? -comp : comp;
        }
    }
}