/*******************************************************************************
* Copyright (c) 2002 - 2006 IBM Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package com.ibm.wala.util.intset;
/**
*/
public final class OffsetBitVector extends BitVectorBase<OffsetBitVector> {
int offset;
private int wordDiff(int offset1, int offset2) {
return (offset1 > offset2) ? (offset1 - offset2) >> LOG_BITS_PER_UNIT : -((offset2 - offset1) >> LOG_BITS_PER_UNIT);
}
/**
* Expand this bit vector to size newCapacity.
*/
private void expand(int newOffset, int newCapacity) {
int wordDiff = wordDiff(newOffset, offset);
int[] oldbits = bits;
bits = new int[subscript(newCapacity) + 1];
for (int i = 0; i < oldbits.length; i++) {
bits[i - wordDiff] = oldbits[i];
}
offset = newOffset;
}
private void ensureCapacity(int newOffset, int newCapacity) {
if (newOffset < offset || newCapacity > (bits.length << LOG_BITS_PER_UNIT)) {
expand(newOffset, newCapacity);
}
}
public OffsetBitVector() {
this(0, 1);
}
/**
* Creates an empty string with the specified size.
*
* @param nbits the size of the string
*/
public OffsetBitVector(int offset, int nbits) {
if (nbits < 0) {
throw new IllegalArgumentException("invalid nbits: " + nbits);
}
if (offset < 0) {
throw new IllegalArgumentException("invalid offset: " + offset);
}
offset = (offset & ~LOW_MASK);
this.offset = offset;
this.bits = new int[subscript(nbits) + 1];
}
/**
* Creates a copy of a Bit String
*
* @param s the string to copy
* @throws IllegalArgumentException if s is null
*/
public OffsetBitVector(OffsetBitVector s) {
if (s == null) {
throw new IllegalArgumentException("s is null");
}
offset = s.offset;
bits = new int[s.bits.length];
System.arraycopy(s.bits, 0, bits, 0, s.bits.length);
}
@Override
public String toString() {
return super.toString() + "(offset:" + offset + ")";
}
void growCapacity(float fraction) {
expand(offset, (int) (fraction * (bits.length << LOG_BITS_PER_UNIT)));
}
public int getOffset() {
return offset;
}
int getSize() {
return bits.length;
}
/**
* Sets a bit.
*
* @param bit the bit to be set
*/
@Override
public final void set(int bit) {
if (bit < 0) {
throw new IllegalArgumentException("illegal bit: " + bit);
}
int shiftBits;
int subscript;
if (bit < offset) {
int newOffset = bit & ~LOW_MASK;
expand(newOffset, length() - 1 - newOffset);
shiftBits = bit & LOW_MASK;
subscript = 0;
} else {
bit -= offset;
shiftBits = bit & LOW_MASK;
subscript = subscript(bit);
if (subscript >= bits.length) {
expand(offset, bit);
}
}
try {
bits[subscript] |= (1 << shiftBits);
} catch (RuntimeException e) {
e.printStackTrace();
throw e;
}
}
/**
* Clears a bit.
*
* @param bit the bit to be cleared
*/
@Override
public final void clear(int bit) {
if (bit < offset) {
return;
}
bit -= offset;
int ss = subscript(bit);
if (ss >= bits.length) {
return;
}
int shiftBits = bit & LOW_MASK;
bits[ss] &= ~(1 << shiftBits);
}
/**
* Gets a bit.
*
* @param bit the bit to be gotten
*/
@Override
public final boolean get(int bit) {
if (DEBUG) {
assert bit >= 0;
}
if (bit < offset) {
return false;
}
bit -= offset;
int ss = subscript(bit);
if (ss >= bits.length) {
return false;
}
int shiftBits = bit & LOW_MASK;
return ((bits[ss] & (1 << shiftBits)) != 0);
}
/**
* @param start
* @return min j >= start s.t get(j)
*/
@Override
public int nextSetBit(int start) {
int nb = super.nextSetBit(Math.max(0, start - offset));
return nb == -1 ? -1 : offset + nb;
}
/**
* Logically NOT this bit string
*/
public final void not() {
if (offset != 0) {
expand(0, offset + length() - 1);
}
for (int i = 0; i < bits.length; i++) {
bits[i] ^= MASK;
}
}
@Override
public int max() {
return super.max() + offset;
}
/**
* Calculates and returns the set's size in bits. The maximum element in the set is the size - 1st element.
*/
@Override
public final int length() {
return (bits.length << LOG_BITS_PER_UNIT) + offset;
}
/**
* Sets all bits.
*/
public final void setAll() {
expand(0, length() - 1);
for (int i = 0; i < bits.length; i++) {
bits[i] = MASK;
}
}
/**
* Compares this object against the specified object.
*
* @param obj the object to compare with
* @return true if the objects are the same; false otherwise.
*/
@Override
public boolean equals(Object obj) {
if ((obj != null) && (obj instanceof OffsetBitVector)) {
if (this == obj) { // should help alias analysis
return true;
}
OffsetBitVector set = (OffsetBitVector) obj;
return sameBits(set);
}
return false;
}
/**
* Check if the intersection of the two sets is empty
*
* @param set the set to check intersection with
* @throws IllegalArgumentException if set == null
*/
@Override
public final boolean intersectionEmpty(OffsetBitVector set) throws IllegalArgumentException {
if (set == null) {
throw new IllegalArgumentException("set == null");
}
if (this == set) {
return isZero();
}
int wordDiff = wordDiff(offset, set.offset);
int maxWord = Math.min(bits.length, set.bits.length - wordDiff);
int i = Math.max(0, -wordDiff);
for (; i < maxWord; i++) {
if ((bits[i] & set.bits[i + wordDiff]) != 0) {
return false;
}
}
return true;
}
/**
* Compares this object against the specified object.
*
* @param set the object to compare with
* @return true if the objects are the same; false otherwise.
* @throws IllegalArgumentException if set == null
*/
@Override
public final boolean sameBits(OffsetBitVector set) throws IllegalArgumentException {
if (set == null) {
throw new IllegalArgumentException("set == null");
}
if (this == set) { // should help alias analysis
return true;
}
int wordDiff = wordDiff(offset, set.offset);
int maxWord = Math.min(bits.length, set.bits.length - wordDiff);
int i = 0;
if (wordDiff < 0) {
for (; i < -wordDiff; i++) {
if (bits[i] != 0) {
return false;
}
}
} else {
for (int j = 0; j < wordDiff; j++) {
if (set.bits[j] != 0) {
return false;
}
}
}
for (; i < maxWord; i++) {
if (bits[i] != set.bits[i + wordDiff]) {
return false;
}
}
for (int j = maxWord + wordDiff; j < set.bits.length; j++) {
if (set.bits[j] != 0) {
return false;
}
}
for (; i < bits.length; i++) {
if (bits[i] != 0) {
return false;
}
}
return true;
}
/*
* @param other @return true iff this is a subset of other
*/
@Override
public boolean isSubset(OffsetBitVector other) throws IllegalArgumentException {
if (other == null) {
throw new IllegalArgumentException("other == null");
}
if (this == other) { // should help alias analysis
return true;
}
int wordDiff = wordDiff(offset, other.offset);
int maxWord = Math.min(bits.length, other.bits.length - wordDiff);
int i = 0;
for (; i < -wordDiff; i++) {
if (bits[i] != 0) {
return false;
}
}
for (; i < maxWord; i++) {
if ((bits[i] & ~other.bits[i + wordDiff]) != 0) {
return false;
}
}
for (; i < bits.length; i++) {
if (bits[i] != 0) {
return false;
}
}
return true;
}
/**
* Copies the values of the bits in the specified set into this set.
*
* @param set the bit set to copy the bits from
* @throws IllegalArgumentException if set is null
*/
public final void copyBits(OffsetBitVector set) {
if (set == null) {
throw new IllegalArgumentException("set is null");
}
super.copyBits(set);
offset = set.offset;
}
/**
* Logically ANDs this bit set with the specified set of bits.
*
* @param set the bit set to be ANDed with
* @throws IllegalArgumentException if set == null
*/
@Override
public final void and(OffsetBitVector set) throws IllegalArgumentException {
if (set == null) {
throw new IllegalArgumentException("set == null");
}
if (this == set) {
return;
}
int wordDiff = wordDiff(offset, set.offset);
int maxWord = Math.min(bits.length, set.bits.length - wordDiff);
int i = 0;
for (; i < -wordDiff; i++) {
bits[i] = 0;
}
for (; i < maxWord; i++) {
bits[i] &= set.bits[i + wordDiff];
}
for (; i < bits.length; i++) {
bits[i] = 0;
}
}
/**
* Logically ORs this bit set with the specified set of bits.
*
* @param set the bit set to be ORed with
* @throws IllegalArgumentException if set == null
*/
@Override
public final void or(OffsetBitVector set) throws IllegalArgumentException {
if (set == null) {
throw new IllegalArgumentException("set == null");
}
if (this == set) { // should help alias analysis
return;
}
int newOffset = Math.min(offset, set.offset);
int newCapacity = Math.max(length(), set.length()) - newOffset;
ensureCapacity(newOffset, newCapacity);
int wordDiff = wordDiff(newOffset, set.offset);
for (int i = 0; i < set.bits.length; i++) {
bits[i - wordDiff] |= set.bits[i];
}
}
/**
* Logically XORs this bit set with the specified set of bits.
*
* @param set the bit set to be XORed with
* @throws IllegalArgumentException if set == null
*/
@Override
public final void xor(OffsetBitVector set) throws IllegalArgumentException {
if (set == null) {
throw new IllegalArgumentException("set == null");
}
if (this == set) {
clearAll();
return;
}
int newOffset = Math.min(offset, set.offset);
int newCapacity = Math.max(length(), set.length()) - newOffset;
ensureCapacity(newOffset, newCapacity);
int wordDiff = wordDiff(newOffset, set.offset);
for (int i = 0; i < set.bits.length; i++) {
bits[i - wordDiff] ^= set.bits[i];
}
}
@Override
public void andNot(OffsetBitVector set) throws IllegalArgumentException {
if (set == null) {
throw new IllegalArgumentException("set == null");
}
if (this == set) {
clearAll();
return;
}
int wordDiff = wordDiff(offset, set.offset);
int maxWord = Math.min(bits.length, set.bits.length - wordDiff);
int i = Math.max(0, -wordDiff);
for (; i < maxWord; i++) {
bits[i] &= ~set.bits[i + wordDiff];
}
}
/**
* Return the NOT of a bit string
*/
public static OffsetBitVector not(OffsetBitVector s) {
OffsetBitVector b = new OffsetBitVector(s);
b.not();
return b;
}
/**
* Return a new bit string as the AND of two others.
*
* @throws IllegalArgumentException if b2 == null
*/
public static OffsetBitVector and(OffsetBitVector b1, OffsetBitVector b2) throws IllegalArgumentException {
if (b2 == null) {
throw new IllegalArgumentException("b2 == null");
}
OffsetBitVector b = new OffsetBitVector(b1);
b.and(b2);
return b;
}
/**
* Return a new FixedSizeBitVector as the OR of two others
*
* @throws IllegalArgumentException if b2 == null
*/
public static OffsetBitVector or(OffsetBitVector b1, OffsetBitVector b2) throws IllegalArgumentException {
if (b2 == null) {
throw new IllegalArgumentException("b2 == null");
}
OffsetBitVector b = new OffsetBitVector(b1);
b.or(b2);
return b;
}
/**
* Return a new bit string as the AND of two others.
*/
public static OffsetBitVector andNot(OffsetBitVector b1, OffsetBitVector b2) {
OffsetBitVector b = new OffsetBitVector(b1);
b.andNot(b2);
return b;
}
}