You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
550 lines
11 KiB
550 lines
11 KiB
10 years ago
|
/*
|
||
|
* Fernflower - The Analytical Java Decompiler
|
||
|
* http://www.reversed-java.com
|
||
|
*
|
||
|
* (C) 2008 - 2010, Stiver
|
||
|
*
|
||
|
* This software is NEITHER public domain NOR free software
|
||
|
* as per GNU License. See license.txt for more details.
|
||
|
*
|
||
|
* This software is distributed WITHOUT ANY WARRANTY; without
|
||
|
* even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
||
|
* A PARTICULAR PURPOSE.
|
||
|
*/
|
||
|
|
||
10 years ago
|
package org.jetbrains.java.decompiler.util;
|
||
10 years ago
|
|
||
|
import java.util.Collection;
|
||
|
import java.util.HashSet;
|
||
|
import java.util.Iterator;
|
||
|
import java.util.Set;
|
||
|
|
||
|
public class FastSparseSetFactory<E> {
|
||
|
|
||
|
private VBStyleCollection<int[], E> colValuesInternal = new VBStyleCollection<int[], E>();
|
||
|
|
||
|
private int lastBlock;
|
||
|
|
||
|
private int lastMask;
|
||
|
|
||
|
public FastSparseSetFactory(Collection<E> set) {
|
||
|
|
||
|
int block = -1;
|
||
|
int mask = -1;
|
||
|
int index = 0;
|
||
|
|
||
|
for(E element : set) {
|
||
|
|
||
|
block = index / 32;
|
||
|
|
||
|
if(index % 32 == 0) {
|
||
|
mask = 1;
|
||
|
} else {
|
||
|
mask <<= 1;
|
||
|
}
|
||
|
|
||
|
colValuesInternal.putWithKey(new int[] {block, mask}, element);
|
||
|
|
||
|
index++;
|
||
|
}
|
||
|
|
||
|
lastBlock = block;
|
||
|
lastMask = mask;
|
||
|
}
|
||
|
|
||
|
private int[] addElement(E element) {
|
||
|
|
||
|
if(lastMask == -1 || lastMask == 0x80000000) {
|
||
|
lastMask = 1;
|
||
|
lastBlock++;
|
||
|
} else {
|
||
|
lastMask <<= 1;
|
||
|
}
|
||
|
|
||
|
int[] pointer = new int[] {lastBlock, lastMask};
|
||
|
colValuesInternal.putWithKey(pointer, element);
|
||
|
|
||
|
return pointer;
|
||
|
}
|
||
|
|
||
|
public FastSparseSet<E> spawnEmptySet() {
|
||
|
return new FastSparseSet<E>(this);
|
||
|
}
|
||
|
|
||
|
public int getLastBlock() {
|
||
|
return lastBlock;
|
||
|
}
|
||
|
|
||
|
public int getLastMask() {
|
||
|
return lastMask;
|
||
|
}
|
||
|
|
||
|
private VBStyleCollection<int[], E> getInternalValuesCollection() {
|
||
|
return colValuesInternal;
|
||
|
}
|
||
|
|
||
|
|
||
|
public static class FastSparseSet<E> implements Iterable<E> {
|
||
|
|
||
|
private FastSparseSetFactory<E> factory;
|
||
|
|
||
|
private VBStyleCollection<int[], E> colValuesInternal;
|
||
|
|
||
|
private int[] data;
|
||
|
private int[] next;
|
||
|
|
||
|
private FastSparseSet(FastSparseSetFactory<E> factory) {
|
||
|
this.factory = factory;
|
||
|
this.colValuesInternal = factory.getInternalValuesCollection();
|
||
|
|
||
|
int length = factory.getLastBlock()+1;
|
||
|
this.data = new int[length];
|
||
|
this.next = new int[length];
|
||
|
}
|
||
|
|
||
|
private FastSparseSet(FastSparseSetFactory<E> factory, int[] data, int[] next) {
|
||
|
this.factory = factory;
|
||
|
this.colValuesInternal = factory.getInternalValuesCollection();
|
||
|
|
||
|
this.data = data;
|
||
|
this.next = next;
|
||
|
}
|
||
|
|
||
|
public FastSparseSet<E> getCopy() {
|
||
|
|
||
|
int arrlength = data.length;
|
||
|
int[] cpdata = new int[arrlength];
|
||
|
int[] cpnext = new int[arrlength];
|
||
|
|
||
|
System.arraycopy(data, 0, cpdata, 0, arrlength);
|
||
|
System.arraycopy(next, 0, cpnext, 0, arrlength);
|
||
|
|
||
|
FastSparseSet<E> copy = new FastSparseSet<E>(factory, cpdata, cpnext);
|
||
|
|
||
|
return copy;
|
||
|
}
|
||
|
|
||
|
private int[] ensureCapacity(int index) {
|
||
|
|
||
|
int newlength = data.length;
|
||
|
if(newlength == 0) {
|
||
|
newlength = 1;
|
||
|
}
|
||
|
|
||
|
while(newlength <= index) {
|
||
|
newlength *=2;
|
||
|
}
|
||
|
|
||
|
int[] newdata = new int[newlength];
|
||
|
System.arraycopy(data, 0, newdata, 0, data.length);
|
||
|
data = newdata;
|
||
|
|
||
|
int[] newnext = new int[newlength];
|
||
|
System.arraycopy(next, 0, newnext, 0, next.length);
|
||
|
next = newnext;
|
||
|
|
||
|
return newdata;
|
||
|
}
|
||
|
|
||
|
public void add(E element) {
|
||
|
int[] index = colValuesInternal.getWithKey(element);
|
||
|
|
||
|
if(index == null) {
|
||
|
index = factory.addElement(element);
|
||
|
}
|
||
|
|
||
|
int block = index[0];
|
||
|
if(block >= data.length) {
|
||
|
ensureCapacity(block);
|
||
|
}
|
||
|
|
||
|
data[block] |= index[1];
|
||
|
|
||
|
changeNext(next, block, next[block], block);
|
||
|
}
|
||
|
|
||
|
public void setAllElements() {
|
||
|
|
||
|
int lastblock = factory.getLastBlock();
|
||
|
int lastmask = factory.getLastMask();
|
||
|
|
||
|
if(lastblock >= data.length) {
|
||
|
ensureCapacity(lastblock);
|
||
|
}
|
||
|
|
||
|
for(int i=lastblock-1;i>=0;i--) {
|
||
|
data[i] = 0xFFFFFFFF;
|
||
|
next[i] = i+1;
|
||
|
}
|
||
|
|
||
|
data[lastblock] = lastmask | (lastmask-1);
|
||
|
next[lastblock] = 0;
|
||
|
}
|
||
|
|
||
|
public void addAll(Set<E> set) {
|
||
|
for(E element : set) {
|
||
|
add(element);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public void remove(E element) {
|
||
|
int[] index = colValuesInternal.getWithKey(element);
|
||
|
|
||
|
if(index == null) {
|
||
|
index = factory.addElement(element);
|
||
|
}
|
||
|
|
||
|
int block = index[0];
|
||
|
if(block < data.length) {
|
||
|
data[block] &= ~index[1];
|
||
|
|
||
|
if(data[block] == 0) {
|
||
|
changeNext(next, block, block, next[block]);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public void removeAll(Set<E> set) {
|
||
|
for(E element : set) {
|
||
|
remove(element);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public boolean contains(E element) {
|
||
|
int[] index = colValuesInternal.getWithKey(element);
|
||
|
|
||
|
if(index == null) {
|
||
|
index = factory.addElement(element);
|
||
|
}
|
||
|
|
||
|
return index[0] >= data.length?false:((data[index[0]] & index[1]) != 0);
|
||
|
}
|
||
|
|
||
|
public boolean contains(FastSparseSet<E> set) {
|
||
|
int[] extdata = set.getData();
|
||
|
int[] intdata = data;
|
||
|
|
||
|
int minlength = Math.min(extdata.length, intdata.length);
|
||
|
|
||
|
for(int i=minlength-1;i>=0;i--) {
|
||
|
if((extdata[i] & ~intdata[i]) != 0) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for(int i=extdata.length-1;i>=minlength;i--) {
|
||
|
if(extdata[i] != 0) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
private void setNext() {
|
||
|
|
||
|
int link = 0;
|
||
|
for(int i=data.length-1;i>=0;i--) {
|
||
|
next[i] = link;
|
||
|
if(data[i] != 0) {
|
||
|
link = i;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private void changeNext(int[] arrnext, int key, int oldnext, int newnext) {
|
||
|
for(int i=key-1;i>=0;i--) {
|
||
|
if(arrnext[i] == oldnext) {
|
||
|
arrnext[i] = newnext;
|
||
|
} else {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public void union(FastSparseSet<E> set) {
|
||
|
|
||
|
int[] extdata = set.getData();
|
||
|
int[] extnext = set.getNext();
|
||
|
int[] intdata = data;
|
||
|
int intlength = intdata.length;
|
||
|
|
||
|
int pointer = 0;
|
||
|
do {
|
||
|
if(pointer >= intlength) {
|
||
|
intdata = ensureCapacity(extdata.length - 1);
|
||
|
}
|
||
|
|
||
|
boolean nextrec = (intdata[pointer] == 0);
|
||
|
intdata[pointer] |= extdata[pointer];
|
||
|
|
||
|
if(nextrec) {
|
||
|
changeNext(next, pointer, next[pointer], pointer);
|
||
|
}
|
||
|
|
||
|
pointer = extnext[pointer];
|
||
|
|
||
|
} while(pointer!=0);
|
||
|
}
|
||
|
|
||
|
public void intersection(FastSparseSet<E> set) {
|
||
|
int[] extdata = set.getData();
|
||
|
int[] intdata = data;
|
||
|
|
||
|
int minlength = Math.min(extdata.length, intdata.length);
|
||
|
|
||
|
for(int i=minlength-1;i>=0;i--) {
|
||
|
intdata[i] &= extdata[i];
|
||
|
}
|
||
|
|
||
|
for(int i=intdata.length-1;i>=minlength;i--) {
|
||
|
intdata[i] = 0;
|
||
|
}
|
||
|
|
||
|
setNext();
|
||
|
}
|
||
|
|
||
|
public void symdiff(FastSparseSet<E> set) {
|
||
|
int[] extdata = set.getData();
|
||
|
int[] intdata = data;
|
||
|
|
||
|
int minlength = Math.min(extdata.length, intdata.length);
|
||
|
|
||
|
for(int i=minlength-1;i>=0;i--) {
|
||
|
intdata[i] ^= extdata[i];
|
||
|
}
|
||
|
|
||
|
boolean expanded = false;
|
||
|
for(int i=extdata.length-1;i>=minlength;i--) {
|
||
|
if(extdata[i] != 0) {
|
||
|
if(!expanded) {
|
||
|
intdata = ensureCapacity(extdata.length - 1);
|
||
|
}
|
||
|
intdata[i] = extdata[i];
|
||
|
}
|
||
|
}
|
||
|
|
||
|
setNext();
|
||
|
}
|
||
|
|
||
|
public void complement(FastSparseSet<E> set) {
|
||
|
|
||
|
int[] extdata = set.getData();
|
||
|
int[] intdata = data;
|
||
|
int extlength = extdata.length;
|
||
|
|
||
|
int pointer = 0;
|
||
|
do {
|
||
|
if(pointer >= extlength) {
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
intdata[pointer] &= ~extdata[pointer];
|
||
|
if(intdata[pointer] == 0) {
|
||
|
changeNext(next, pointer, pointer, next[pointer]);
|
||
|
}
|
||
|
|
||
|
pointer = next[pointer];
|
||
|
|
||
|
} while(pointer!=0);
|
||
|
}
|
||
|
|
||
|
|
||
10 years ago
|
public boolean equals(Object o) {
|
||
|
if(o == this) return true;
|
||
|
if(o == null || !(o instanceof FastSparseSet)) return false;
|
||
10 years ago
|
|
||
10 years ago
|
int[] longdata = ((FastSparseSet)o).getData();
|
||
10 years ago
|
int[] shortdata = data;
|
||
|
|
||
|
if(data.length > longdata.length) {
|
||
|
shortdata = longdata;
|
||
|
longdata = data;
|
||
|
}
|
||
|
|
||
|
for(int i=shortdata.length-1;i>=0;i--) {
|
||
|
if(shortdata[i] != longdata[i]) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for(int i=longdata.length-1;i>=shortdata.length;i--) {
|
||
|
if(longdata[i] != 0) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
public int getCardinality() {
|
||
|
|
||
|
boolean found = false;
|
||
|
int[] intdata = data;
|
||
|
|
||
|
for(int i=intdata.length-1;i>=0;i--) {
|
||
|
int block = intdata[i];
|
||
|
if(block != 0) {
|
||
|
if(found) {
|
||
|
return 2;
|
||
|
} else {
|
||
|
if ((block & (block-1)) == 0) {
|
||
|
found = true;
|
||
|
} else {
|
||
|
return 2;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return found?1:0;
|
||
|
}
|
||
|
|
||
|
public boolean isEmpty() {
|
||
|
return data.length == 0 || (next[0] == 0 && data[0] == 0);
|
||
|
}
|
||
|
|
||
|
public Iterator<E> iterator() {
|
||
|
return new FastSparseSetIterator<E>(this);
|
||
|
}
|
||
|
|
||
|
public Set<E> toPlainSet() {
|
||
|
HashSet<E> set = new HashSet<E>();
|
||
|
|
||
|
int[] intdata = data;
|
||
|
|
||
|
int size = data.length*32;
|
||
|
if(size > colValuesInternal.size()) {
|
||
|
size = colValuesInternal.size();
|
||
|
}
|
||
|
|
||
|
for(int i=size-1;i>=0;i--) {
|
||
|
int[] index = colValuesInternal.get(i);
|
||
|
|
||
|
if((intdata[index[0]] & index[1]) != 0) {
|
||
|
set.add(colValuesInternal.getKey(i));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return set;
|
||
|
}
|
||
|
|
||
|
public String toString() {
|
||
|
return toPlainSet().toString();
|
||
|
}
|
||
|
|
||
|
public String toBinary() {
|
||
|
|
||
|
StringBuilder buffer = new StringBuilder();
|
||
|
int[] intdata = data;
|
||
|
|
||
|
for(int i=0;i<intdata.length;i++) {
|
||
|
buffer.append(" ").append(Integer.toBinaryString(intdata[i]));
|
||
|
}
|
||
|
|
||
|
return buffer.toString();
|
||
|
}
|
||
|
|
||
|
private int[] getData() {
|
||
|
return data;
|
||
|
}
|
||
|
|
||
|
private int[] getNext() {
|
||
|
return next;
|
||
|
}
|
||
|
|
||
|
public int[] getLoad() {
|
||
|
int[] intdata = data;
|
||
|
int notempty = 0;
|
||
|
|
||
|
for(int i=0;i<intdata.length;i++) {
|
||
|
if(intdata[i] != 0) {
|
||
|
notempty++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return new int[]{intdata.length, notempty};
|
||
|
}
|
||
|
|
||
|
public FastSparseSetFactory<E> getFactory() {
|
||
|
return factory;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
public static class FastSparseSetIterator<E> implements Iterator<E> {
|
||
|
|
||
|
private VBStyleCollection<int[], E> colValuesInternal;
|
||
|
private int[] data;
|
||
|
private int[] next;
|
||
|
private int size;
|
||
|
|
||
|
private int pointer = -1;
|
||
|
private int next_pointer = -1;
|
||
|
|
||
|
private FastSparseSetIterator(FastSparseSet<E> set) {
|
||
|
colValuesInternal = set.getFactory().getInternalValuesCollection();
|
||
|
data = set.getData();
|
||
|
next = set.getNext();
|
||
|
size = colValuesInternal.size();
|
||
|
}
|
||
|
|
||
|
private int getNextIndex(int index) {
|
||
|
|
||
|
index++;
|
||
|
int bindex = index >>> 5;
|
||
|
int dindex = index & 0x1F;
|
||
|
|
||
|
while(bindex < data.length) {
|
||
|
int block = data[bindex];
|
||
|
|
||
|
if(block != 0) {
|
||
|
block >>>= dindex;
|
||
|
while(dindex < 32) {
|
||
|
if((block & 1) != 0) {
|
||
|
return (bindex << 5) + dindex;
|
||
|
}
|
||
|
block >>>= 1;
|
||
|
dindex++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
dindex = 0;
|
||
|
bindex = next[bindex];
|
||
|
|
||
|
if(bindex == 0) {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
public boolean hasNext() {
|
||
|
next_pointer = getNextIndex(pointer);
|
||
|
return (next_pointer >= 0);
|
||
|
}
|
||
|
|
||
|
public E next() {
|
||
|
if(next_pointer >= 0) {
|
||
|
pointer = next_pointer;
|
||
|
} else {
|
||
|
pointer = getNextIndex(pointer);
|
||
|
if(pointer == -1) {
|
||
|
pointer = size;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
next_pointer = -1;
|
||
|
return pointer<size?colValuesInternal.getKey(pointer):null;
|
||
|
}
|
||
|
|
||
|
public void remove() {
|
||
|
int[] index = colValuesInternal.get(pointer);
|
||
|
data[index[0]] &= ~index[1];
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|