public void clear() { data = new Object[DEF_INITIAL_SIZE]; indices = MutableSparseIntSet.makeEmpty(); }
@Override public IntSet union(IntSet that) { MutableSparseIntSet temp = new MutableSparseIntSet(); temp.addAll(this); temp.addAll(that); return temp; }
/** * This iteration _will_ cover all indices even when remove is called while * the iterator is active. */ public IntIterator safeIterateIndices() { return MutableSparseIntSet.make(indices).intIterator(); }
public static MutableSparseIntSet diff(MutableSparseIntSet A, MutableSparseIntSet B) { return new MutableSparseIntSet(diffInternal(A, B)); }
/** * Flow function composition * * @return { (x, z) | (x, y) \in g, (y, z) \in f } */ private static IUnaryFlowFunction compose(final IUnaryFlowFunction f, final IUnaryFlowFunction g) { return d1 -> { final MutableSparseIntSet set = MutableSparseIntSet.makeEmpty(); g.getTargets(d1).foreach(x -> set.addAll(f.getTargets(x))); return set; }; }
private OrdinalSet<InstanceKey> toOrdinalSet(InstanceKey[] ik) { MutableSparseIntSet s = MutableSparseIntSet.makeEmpty(); for (InstanceKey element : ik) { int index = instanceKeys.getMappedIndex(element); if (index != -1) { s.add(index); } else { assert index != -1 : "instance " + element + " not mapped!"; } } return new OrdinalSet<>(s, instanceKeys); }
@Override public IntSet getSuccNodeNumbers(T node) { int number = getNumber(node); IntSet s = normalEdgeManager.getSuccNodeNumbers(node); MutableSparseIntSet result = s == null ? MutableSparseIntSet.makeEmpty() : MutableSparseIntSet.make(s); s = exceptionalEdgeManager.getSuccNodeNumbers(node); if (s != null) { result.addAll(s); } if (normalToExit.get(number) || exceptionalToExit.get(number)) { result.add(exit.getNumber()); } if (fallThru.get(number)) { result.add(number + 1); } return result; }
@Override public IntIterator intIterator() { MutableSparseIntSet bits = MutableSparseIntSet.makeEmpty(); for (IntIterator pi = primaryImpl.intIterator(); pi.hasNext();) { int x = pi.next(); assert !bits.contains(x); bits.add(x); } for (IntIterator si = secondaryImpl.intIterator(); si.hasNext();) { int x = si.next(); assert bits.contains(x); bits.remove(x); } assert bits.isEmpty(); return primaryImpl.intIterator(); }
MutableSparseIntSet reached = MutableSparseIntSet.makeEmpty(); final Collection<T> returnSitesForCallee = Iterator2Collection.toSet(supergraph.getReturnSites(edge.target, supergraph .getProcOf(calleeEntry))); IntSet r = computeFlow(edge.d2, f); if (r != null) { reached.addAll(r); IntSet r = computeFlow(edge.d2, f); if (r != null) { reached.addAll(r); final int s_p_num = supergraph.getLocalBlockNumber(calleeEntry); reached.foreach(d1 -> {
@Override public void set(int x, int value) { maxIndex = Math.max(maxIndex,x); int index = indices.getIndex(x); if (index == -1) { indices.add(x); index = indices.getIndex(x); ensureCapacity(indices.size() + 1); if (index < (data.length - 1)) { System.arraycopy(data, index, data, index + 1, indices.size() - index); } } data[index] = value; }
@Override public MutableSparseIntSet makeCopy(IntSet x) throws IllegalArgumentException { if (x == null) { throw new IllegalArgumentException("x == null"); } return MutableSparseIntSet.make(x); }
@Override public boolean remove(int i) { if (privatePart != null) { if (privatePart.contains(i)) { privatePart.remove(i); if (privatePart.size() == 0) { privatePart = null; } return true; } } if (sharedPart != null) { if (sharedPart.contains(i)) { privatePart = makeSparseCopy(); privatePart.remove(i); if (privatePart.size() == 0) { privatePart = null; } sharedPart = null; checkOverflow(); return true; } } return false; }
sparsePart = MutableSparseIntSet.diff(sparsePart, B.sparsePart); } else { MutableSparseIntSet C = MutableSparseIntSet.diff(sparsePart, B.sparsePart); for (IntIterator bits = sparsePart.intIterator(); bits.hasNext();) { int bit = bits.next(); if (B.densePart.get(bit)) { C.remove(bit); for (IntIterator bits = B.sparsePart.intIterator(); bits.hasNext();) { densePart.clear(bits.next()); sparsePart = MutableSparseIntSet.diff(sparsePart, B.sparsePart); } else { densePart.andNot(B.densePart); for (IntIterator bits = B.sparsePart.intIterator(); bits.hasNext();) { densePart.clear(bits.next()); MutableSparseIntSet C = MutableSparseIntSet.diff(sparsePart, B.sparsePart); for (IntIterator bits = sparsePart.intIterator(); bits.hasNext();) { int bit = bits.next(); if (B.densePart.get(bit)) { C.remove(bit);
private void foreachExcludingInternal(MutableSharedBitVectorIntSet X, IntSetAction action) { if (sameSharedPart(this, X)) { if (privatePart != null) { if (X.privatePart != null) { privatePart.foreachExcluding(X.privatePart, action); } else { privatePart.foreach(action); } } } else { if (privatePart != null) { privatePart.foreachExcluding(X, action); } if (sharedPart != null) { sharedPart.foreachExcluding(X.makeDenseCopy(), action); } } }
@Override public void foreach(IntSetAction action) { if (privatePart != null) { privatePart.foreach(action); } if (sharedPart != null) { sharedPart.foreach(action); } }
/** * TODO optimize * * @throws IllegalArgumentException * if set is null */ public void removeAll(MutableSparseIntSet set) { if (set == null) { throw new IllegalArgumentException("set is null"); } for (IntIterator it = set.intIterator(); it.hasNext();) { remove(it.next()); } }
/** * Remove an integer from this set. * * @param i integer to remove * @return true iff the value of this changes. */ @Override public boolean remove(int i) { if (densePart != null && densePart.get(i)) { densePart.clear(i); if (densePart.nextSetBit(0) == -1) { densePart = null; } return true; } else if (sparsePart.contains(i)) { sparsePart.remove(i); return true; } else { return false; } }
public static MutableSparseIntSet makeEmpty() { return new MutableSparseIntSet(); }