FastBitSet.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.util;
 
import static javolution.lang.Realtime.Limit.LINEAR;
import javolution.lang.Realtime;
import javolution.util.internal.bitset.BitSetServiceImpl;
import javolution.util.service.BitSetService;
 
public class FastBitSet extends FastSet<Index> {
 
    private static final long serialVersionUID = 0x600L; // Version.
 
    private final BitSetService service;
 
    public FastBitSet() {
        service = new BitSetServiceImpl();
    }
 
    protected FastBitSet(BitSetService impl) {
        this.service = impl;
    }
 
    // Views.
    //
 
    @Override
    public FastBitSet unmodifiable() {
        throw new UnsupportedOperationException("NOT DONE YET"); // TODO
    }
 
    @Override
    public FastBitSet shared() {
        throw new UnsupportedOperationException("NOT DONE YET"); // TODO
    }
 
    // BitSet Operations.
    //
 
    @Realtime(limit = LINEAR)
    public void and(FastBitSet that) {
        service.and(that.service);
    }
 
    @Realtime(limit = LINEAR)
    public void andNot(FastBitSet that) {
        service.andNot(that.service);
    }
 
    public int cardinality() {
        return service.cardinality();
    }
 
    @Override
    public void clear() {
        service.clear();
    }
 
    public void clear(int bitIndex) {
        service.clear(bitIndex);
    }
 
    @Realtime(limit = LINEAR)
    public void clear(int fromIndex, int toIndex) {
        service.clear(fromIndex, toIndex);
    }
 
    public void flip(int bitIndex) {
        service.flip(bitIndex);
    }
 
    @Realtime(limit = LINEAR)
    public void flip(int fromIndex, int toIndex) {
        service.flip(fromIndex, toIndex);
    }
 
    public boolean get(int bitIndex) {
        return service.get(bitIndex);
    }
 
    @Realtime(limit = LINEAR)
    public FastBitSet get(int fromIndex, int toIndex) {
        return new FastBitSet(service.get(fromIndex, toIndex));
    }
 
    @Realtime(limit = LINEAR)
    public boolean intersects(FastBitSet that) {
        return service.intersects(that.service);
    }
 
    public int length() {
        return service.length();
    }
 
    public int nextClearBit(int fromIndex) {
        return service.nextClearBit(fromIndex);
    }
 
    public int nextSetBit(int fromIndex) {
        return service.nextSetBit(fromIndex);
    }
 
    public int previousClearBit(int fromIndex) {
        return service.previousClearBit(fromIndex);
    }
 
    public int previousSetBit(int fromIndex) {
        return service.previousSetBit(fromIndex);
    }
 
    @Realtime(limit = LINEAR)
    public void or(FastBitSet that) {
        service.or(that.service);
    }
 
    public void set(int bitIndex) {
        service.set(bitIndex);
    }
 
    public void set(int bitIndex, boolean value) {
        service.set(bitIndex, value);
    }
 
    @Realtime(limit = LINEAR)
    public void set(int fromIndex, int toIndex) {
        if ((fromIndex < 0) || (toIndex < fromIndex)) throw new IndexOutOfBoundsException();
        service.set(fromIndex, toIndex);
    }
 
    @Realtime(limit = LINEAR)
    public void set(int fromIndex, int toIndex, boolean value) {
        service.set(fromIndex, toIndex, value);
    }
 
    @Realtime(limit = LINEAR)
    public void xor(FastBitSet that) {
        service.xor(that.service);
    }
 
    // Misc.
    //
 
    @Override
    public FastBitSet addAll(Index... elements) {
        return (FastBitSet) super.addAll(elements);
    }
 
    @Override
    public FastBitSet addAll(FastCollection<? extends Index> elements) {
        return (FastBitSet) super.addAll(elements);
    }
 
    @Override
    protected BitSetService service() {
        return service;
    }
 
}