@Override public void eyePtChanged() { Point3d eyePt = getViewPosInLocal(frontRoot); // System.out.println("eye pt = " + eyePt) if (eyePt != null) { for (int i = 0; i < 6; i++) { // if (perspectiveAttr.getValue() == true) // { // eyeVec.sub(eyePt, faceCenter[i]); // } else { eyeVec.sub(eyePt, volCenter); } frontFaceBits.set(i); backFaceBits.clear(i); if (eyeVec.dot(faceNormal[i]) < 0) { backFaceBits.set(i); frontFaceBits.clear(i); } else { frontFaceBits.set(i); backFaceBits.clear(i); } } frontAnnotations.setChildMask(frontFaceBits); backAnnotations.setChildMask(backFaceBits); } }
private IdentifierInfo clear() { requiredScripts.clear(); scriptSetSet.clear(); numerics.clear(); commonAmongAlternates.clear(); return this; }
/** * Updates the interal bitset from <code>iterator</code>. This will set <code>validMask</code> to * true if <code>iterator</code> is non-null. */ private void updateMask(AttributedCharacterIterator iterator) { if (iterator != null) { validMask = true; this.iterator = iterator; // Update the literal mask if (literalMask == null) { literalMask = new BitSet(); } else { for (int counter = literalMask.length() - 1; counter >= 0; counter--) { literalMask.clear(counter); } } iterator.first(); while (iterator.current() != CharacterIterator.DONE) { Map attributes = iterator.getAttributes(); boolean set = isLiteral(attributes); int start = iterator.getIndex(); int end = iterator.getRunLimit(); while (start < end) { if (set) { literalMask.set(start); } else { literalMask.clear(start); } start++; } iterator.setIndex(start); } } }
private void changeServiceDependencies(final double addFactor, final double removeFactor) { BitSet servicesInNeighbourhood[] = new BitSet[numNeighbourhoods]; for (int s = 0; s < servicesInNeighbourhood.length; ++s) { servicesInNeighbourhood[s] = new BitSet(); } IntAVLTreeSet serviceToNeighbourhoods[] = new IntAVLTreeSet[services.length]; for (int s = 0; s < services.length; ++s) serviceToNeighbourhoods[s] = new IntAVLTreeSet(); for (Process p : processes) { int n = machines[assignment[p.id]].neighborhood; int s = p.service; servicesInNeighbourhood[n].set(s); serviceToNeighbourhoods[s].add(n); } for (int sid = 0; sid < services.length; sid++) { IntAVLTreeSet neighbourhoods = serviceToNeighbourhoods[sid]; BitSet intersection = null; for (int n : neighbourhoods) { if (intersection == null) { intersection = new BitSet(); intersection.or(servicesInNeighbourhood[n]); } else intersection.and(servicesInNeighbourhood[n]); } // intersection - all possible services I can depend on for (int d : services[sid].dependencies) intersection.clear(d); intersection.clear(sid); // exclude itself // services we can add as new dependencies int[] list = new int[intersection.cardinality()]; int i = 0; for (int q = intersection.nextSetBit(0); q >= 0; q = intersection.nextSetBit(q + 1)) { list[i++] = q; } MyArrayUtils.shuffle(list, random); int addCount = nextInt(0, 1 + (int) (addFactor * services[sid].dependencies.length)); // addCount = 0; int removeCount = nextInt(0, 1 + (int) (addFactor * services[sid].dependencies.length)); int[] newdependencies = org.apache.commons.lang.ArrayUtils.addAll( services[sid].dependencies, Arrays.copyOfRange(list, 0, Math.min(list.length, addCount))); MyArrayUtils.shuffle(newdependencies, random); services[sid].dependencies = Arrays.copyOfRange(newdependencies, 0, Math.max(0, newdependencies.length - removeCount)); } }
/** Hydra task to execution ops, then stop scheduling. */ public static void HydraTask_doOps() { BitSet availableOps = new BitSet(operations.length); availableOps.flip(FIRST_OP, LAST_OP + 1); // don't do local ops in bridge configuration availableOps.clear(LOCAL_INVALIDATE); availableOps.clear(LOCAL_DESTROY); testInstance.doOps(availableOps); if (availableOps.cardinality() == 0) { CQUtilBB.getBB().getSharedCounters().increment(CQUtilBB.TimeToStop); throw new StopSchedulingTaskOnClientOrder("Finished with ops"); } }
/** * Sets the game state from a string: the inverse of getGameState(). It reconstructs all the * game's variables from the string. * * @param gameState The game state represented as a string */ public void setGameState(String gameState) { String[] values = gameState.split(","); int index = 0; indiceDeLaberinto = Integer.parseInt(values[index++]); tiempoTotal = Integer.parseInt(values[index++]); score = Integer.parseInt(values[index++]); tiempoLvlActual = Integer.parseInt(values[index++]); cuentaElLvl = Integer.parseInt(values[index++]); pacman = new PacMan( Integer.parseInt(values[index++]), MOVE.valueOf(values[index++]), Integer.parseInt(values[index++]), Boolean.parseBoolean(values[index++])); fantasmas = new EnumMap<GHOST, Ghost>(GHOST.class); for (GHOST ghostType : GHOST.values()) fantasmas.put( ghostType, new Ghost( ghostType, Integer.parseInt(values[index++]), Integer.parseInt(values[index++]), Integer.parseInt(values[index++]), MOVE.valueOf(values[index++]))); _setPills(laberintoActua = laberintos[indiceDeLaberinto]); for (int i = 0; i < values[index].length(); i++) if (values[index].charAt(i) == '1') pills.set(i); else pills.clear(i); index++; for (int i = 0; i < values[index].length(); i++) if (values[index].charAt(i) == '1') powerPills.set(i); else powerPills.clear(i); timeOfLastGlobalReversal = Integer.parseInt(values[++index]); pacmanFueComido = Boolean.parseBoolean(values[++index]); fantasmaComido = new EnumMap<GHOST, Boolean>(GHOST.class); for (GHOST ghost : GHOST.values()) fantasmaComido.put(ghost, Boolean.parseBoolean(values[++index])); pastillaFueComida = Boolean.parseBoolean(values[++index]); pildoraPoderFueComida = Boolean.parseBoolean(values[++index]); }
private void tryToMatch(int i) throws ContradictionException { int mate = augmentPath_BFS(i); if (mate != -1) { free.clear(mate); free.clear(i); int tmp = mate; while (tmp != i) { digraph.removeArc(father[tmp], tmp); digraph.addArc(tmp, father[tmp]); tmp = father[tmp]; } } }
public void set(int bitIndex, boolean value) { if (value == true) { set(bitIndex); } else { clear(bitIndex); } }
public void set(int fromIndex, int toIndex, boolean value) { if (value == true) { set(fromIndex, toIndex); } else { clear(fromIndex, toIndex); } }
public final void flushAll() { assert currentState == ISequencer.State.SLEEPING : "wrong state: " + currentState; for (int i = toPropagate.nextSetBit(0); i >= 0; i = toPropagate.nextSetBit(i + 1)) { master.requests[i].deque(); toPropagate.clear(i); } }
public void andNot(BitSet set) { // a & !a is false if (this == set) { // all falses result in an empty BitSet clear(); return; } // trim the second set to avoid extra work trimToSize(array); int length = array.length(); // truth table // // case | a | b | !b | a & !b | change? // 1 | false | false | true | false | a is already false // 2 | false | true | false | false | a is already false // 3 | true | false | true | true | a is already true // 4 | true | true | false | false | set a to false // // we only need to change something in case 4 // whenever b is true, a should be false, so iterate over set b int index = 0; while ((index = nextSetWord(set.array, index)) != -1) { setWord(array, index, getWord(array, index) & ~set.array.get(index)); if (++index >= length) { // nothing further will affect anything break; } } }
/** Performs a deep copy on <i>other</i>. */ public Appl(Appl other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetId()) { this.id = other.id; } if (other.isSetType()) { this.type = other.type; } this.excuteAction = other.excuteAction; if (other.isSetExcuteDescribe()) { this.excuteDescribe = other.excuteDescribe; } if (other.isSetPkgName()) { this.pkgName = other.pkgName; } if (other.isSetLevel()) { this.level = other.level; } if (other.isSetCategory()) { this.category = other.category; } if (other.isSetName()) { this.name = other.name; } }
/** Performs a deep copy on <i>other</i>. */ public ChosenMenuItem(ChosenMenuItem other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); this.menuItemId = other.menuItemId; if (other.isSetSingleChoiceOptions()) { List<org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption> __this__singleChoiceOptions = new ArrayList<org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption>(); for (org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption other_element : other.singleChoiceOptions) { __this__singleChoiceOptions.add( new org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption( other_element)); } this.singleChoiceOptions = __this__singleChoiceOptions; } if (other.isSetMultiChoiceOptions()) { List<org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption> __this__multiChoiceOptions = new ArrayList<org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption>(); for (org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption other_element : other.multiChoiceOptions) { __this__multiChoiceOptions.add( new org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption(other_element)); } this.multiChoiceOptions = __this__multiChoiceOptions; } if (other.isSetComments()) { this.comments = other.comments; } }
/** The longest dep set of the sub-sequence s[0..idx]. */ public static BitSet longestDepSet(Sequence s, int idx) { if (s.size() == 0) throw new IllegalArgumentException("size must be greater than 0."); if (idx < 0 || idx >= s.size()) throw new IllegalArgumentException(); assert s.size() <= maxlength; int max = -1; int maxidx = -1; for (int i = 0; i <= idx; i++) { BitSet set = sets[i]; set.clear(); set.set(i); lastuse[i] = i; for (Variable invar : s.getInputs(i)) { set.or(sets[lastuse[invar.index]]); lastuse[invar.index] = i; } int size = set.cardinality(); if (size > max) { max = size; maxidx = i; } } for (int i = 0; i < s.size(); i++) { // System.out.println("@ " + sets[i]); } return sets[maxidx]; }
// Eats a power pill - turns ghosts edible (blue) protected boolean eatPowerPill() { boolean reverse = false; int powerPillIndex = getPowerPillIndex(curPacManLoc); if (powerPillIndex >= 0 && powerPills.get(powerPillIndex)) { score += G.POWER_PILL; ghostEatMultiplier = 1; powerPills.clear(powerPillIndex); // This ensures that only ghosts outside the lair (i.e., inside the maze) turn edible int newEdibleTime = (int) (G.EDIBLE_TIME * (Math.pow(G.EDIBLE_TIME_REDUCTION, totLevel))); for (int i = 0; i < NUM_GHOSTS; i++) if (lairTimes[i] == 0) edibleTimes[i] = newEdibleTime; else edibleTimes[i] = 0; // This turns all ghosts edible, independent on whether they are in the lair or not // // Arrays.fill(edibleTimes,(int)(G.EDIBLE_TIME*(Math.pow(G.EDIBLE_TIME_REDUCTION,totLevel)))); reverse = true; } else if (levelTime > 1 && Math.random() < G.GHOST_REVERSAL) // random ghost reversal reverse = true; return reverse; }
/** * Prob0 precomputation algorithm. i.e. determine the states of an STPG which, with min/max * probability 0, reach a state in {@code target}, while remaining in those in @{code remain}. * {@code min}=true gives Prob0E, {@code min}=false gives Prob0A. * * @param stpg The STPG * @param remain Remain in these states (optional: null means "all") * @param target Target states * @param min1 Min or max probabilities for player 1 (true=lower bound, false=upper bound) * @param min2 Min or max probabilities for player 2 (true=min, false=max) */ public BitSet prob0(STPG stpg, BitSet remain, BitSet target, boolean min1, boolean min2) { int n, iters; BitSet u, soln, unknown; boolean u_done; long timer; // Start precomputation timer = System.currentTimeMillis(); if (verbosity >= 1) mainLog.println( "Starting Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")..."); // Special case: no target states if (target.cardinality() == 0) { soln = new BitSet(stpg.getNumStates()); soln.set(0, stpg.getNumStates()); return soln; } // Initialise vectors n = stpg.getNumStates(); u = new BitSet(n); soln = new BitSet(n); // Determine set of states actually need to perform computation for unknown = new BitSet(); unknown.set(0, n); unknown.andNot(target); if (remain != null) unknown.and(remain); // Fixed point loop iters = 0; u_done = false; // Least fixed point - should start from 0 but we optimise by // starting from 'target', thus bypassing first iteration u.or(target); soln.or(target); while (!u_done) { iters++; // Single step of Prob0 stpg.prob0step(unknown, u, min1, min2, soln); // Check termination u_done = soln.equals(u); // u = soln u.clear(); u.or(soln); } // Negate u.flip(0, n); // Finished precomputation timer = System.currentTimeMillis() - timer; if (verbosity >= 1) { mainLog.print("Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")"); mainLog.println(" took " + iters + " iterations and " + timer / 1000.0 + " seconds."); } return u; }
protected void setImageDescriptor(ImageDescriptor descriptor) { if (Util.equals(imageDescriptor, descriptor)) { return; } Image oldImage = image; ImageDescriptor oldDescriptor = imageDescriptor; image = null; imageDescriptor = descriptor; // Don't queue events triggered by image changes. We'll dispose the image // immediately after firing the event, so we need to fire it right away. immediateFirePropertyChange(IWorkbenchPartConstants.PROP_TITLE); if (queueEvents) { // If there's a PROP_TITLE event queued, remove it from the queue because // we've just fired it. queuedEvents.clear(IWorkbenchPartConstants.PROP_TITLE); } // If we had allocated the old image, deallocate it now (AFTER we fire the property change // -- listeners may need to clean up references to the old image) if (oldImage != null) { JFaceResources.getResources().destroy(oldDescriptor); } }
void initializeState(String name) { assert !myBusy; myBusy = true; myNameLength = name.length(); isAsciiName = IOUtil.isAscii(name); myTable.clear(); }
synchronized boolean remove(long hash, K key) { int h = smallMap.startSearch(hash); boolean found = false; while (true) { int pos = smallMap.nextPos(); if (pos < 0) { break; } bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize); K key2 = getKey(); if (equals(key, key2)) { usedSet.clear(pos); smallMap.remove(h, pos); found = true; this.size--; break; } } K key2 = key instanceof CharSequence ? (K) key.toString() : key; DirectStore remove = map.remove(key2); if (remove == null) return found; offHeapUsed -= remove.size(); remove.free(); this.size--; return true; }
public Transformer(FiniteStateTable dfa) { this.dfa = dfa; flatFST = new FlatFST(); used = new BitSet(dfa.getTransitionTable().size()); used.clear(); statePosition = new int[dfa.getDFA().size()]; }
/** * Replaces an old successor with a new successor. This will throw RuntimeException if {@code * oldIndex} was not a successor. * * @param oldIndex index of old successor block * @param newIndex index of new successor block */ public void replaceSuccessor(int oldIndex, int newIndex) { if (oldIndex == newIndex) { return; } // Update us. successors.set(newIndex); if (primarySuccessor == oldIndex) { primarySuccessor = newIndex; } for (int i = successorList.size() - 1; i >= 0; i--) { if (successorList.get(i) == oldIndex) { successorList.set(i, newIndex); } } successors.clear(oldIndex); // Update new successor. parent.getBlocks().get(newIndex).predecessors.set(index); // Update old successor. parent.getBlocks().get(oldIndex).predecessors.clear(index); }
/** * Constructs and inserts a new empty GOTO block {@code Z} between this block ({@code A}) and a * current successor block ({@code B}). The new block will replace B as A's successor and A as B's * predecessor. A and B will no longer be directly connected. If B is listed as a successor * multiple times, all references are replaced. * * @param other current successor (B) * @return {@code non-null;} an appropriately-constructed instance */ public SsaBasicBlock insertNewSuccessor(SsaBasicBlock other) { SsaBasicBlock newSucc = parent.makeNewGotoBlock(); if (!successors.get(other.index)) { throw new RuntimeException( "Block " + other.getRopLabelString() + " not successor of " + getRopLabelString()); } // Update the new block. newSucc.predecessors.set(this.index); newSucc.successors.set(other.index); newSucc.successorList.add(other.index); newSucc.primarySuccessor = other.index; // Update us. for (int i = successorList.size() - 1; i >= 0; i--) { if (successorList.get(i) == other.index) { successorList.set(i, newSucc.index); } } if (primarySuccessor == other.index) { primarySuccessor = newSucc.index; } successors.clear(other.index); successors.set(newSucc.index); // Update "other". other.predecessors.set(newSucc.index); other.predecessors.set(index, successors.get(other.index)); return newSucc; }
@Override public void visitCode(Code obj) { Method m = getMethod(); if (m.getReturnType() == Type.VOID) { return; } stack.resetForMethodEntry(this); ifBlocks.clear(); activeUnconditional = null; CodeException[] ces = obj.getExceptionTable(); if (CollectionUtils.isEmpty(ces)) { catchPCs = null; } else { catchPCs = new BitSet(); for (CodeException ce : ces) { catchPCs.set(ce.getHandlerPC()); } } gotoBranchPCs.clear(); casePositions.clear(); lookingForResetOp = false; try { super.visitCode(obj); } catch (StopOpcodeParsingException e) { // reported an issue, so get out } }
/** Performs a deep copy on <i>other</i>. */ public OrderPlacedByClient(OrderPlacedByClient other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetChosenItems()) { List<ChosenMenuItem> __this__chosenItems = new ArrayList<ChosenMenuItem>(); for (ChosenMenuItem other_element : other.chosenItems) { __this__chosenItems.add(new ChosenMenuItem(other_element)); } this.chosenItems = __this__chosenItems; } this.expectedPrice = other.expectedPrice; this.userId = other.userId; if (other.isSetHowWillPay()) { this.howWillPay = other.howWillPay; } this.pickUp = other.pickUp; if (other.isSetAddress()) { this.address = other.address; } if (other.isSetPhoneNumber()) { this.phoneNumber = other.phoneNumber; } this.timestamp = other.timestamp; this.tableId = other.tableId; if (other.isSetPhoneId()) { this.phoneId = other.phoneId; } this.orderId = other.orderId; if (other.isSetUsername()) { this.username = other.username; } }
/** * Faster removal of components from a entity. * * @param type the type of component to remove from this entity * @return this EntityEdit for chaining */ public EntityEdit remove(ComponentType type) { if (componentBits.get(type.getIndex())) { world.getComponentManager().removeComponent(entity, type); componentBits.clear(type.getIndex()); } return this; }
private int augmentPath_BFS(int root) { in.clear(); int indexFirst = 0, indexLast = 0; fifo[indexLast++] = root; in.set(root); // TODO CORRECTION JG 15/11/12 to test on minizinc instance int x, y; ISet succs; while (indexFirst != indexLast) { x = fifo[indexFirst++]; succs = digraph.getSuccessorsOf(x); for (y = succs.getFirstElement(); y >= 0; y = succs.getNextElement()) { if (!in.get(y)) { father[y] = x; fifo[indexLast++] = y; in.set(y); if (flow[y] < this.ub[y]) { if (y < n) { throw new UnsupportedOperationException(); } return y; } } } } return -1; }
/** * Transition to the next generation by applying the Conway's Game Of Life rule. * * <ol> * <li>Any live cell with fewer than two live neighbours dies, as if caused by under-population. * <li>Any live cell with two or three live neighbours lives on to the next generation. * <li>Any live cell with more than three live neighbours dies, as if by overcrowding. * <li>Any dead cell with exactly three live neighbours becomes a live cell, as if by * reproduction. * </ol> */ public void nextGeneration() { // At each step time, looping all cells in the current generation to apply the rules for (int i = 0; i < vertical; i++) { for (int j = 0; j < horizontal; j++) { byte liveCellNeighbours = countLiveNeighbourCells(i, j); // If the cell is dead and have exactly 3 live cells neighbours becomes a live cell if (!currentGeneration.get(getIndex(i, j))) { if (liveCellNeighbours == 3) { tempGeneration.set(getIndex(i, j)); } } else { // If the cell is live cell // If live cell with fewer than two live neighbours dies // If live cell with more than three live neighbours dies, as if by overcrowding. if (liveCellNeighbours < 2 || liveCellNeighbours > 3) { tempGeneration.clear(getIndex(i, j)); } else { // Otherwise, keep the current state of the cell tempGeneration.set(getIndex(i, j), currentGeneration.get(getIndex(i, j))); } } } } // Swap the next generation to the current generation for the next step time BitSet bs = currentGeneration; currentGeneration = tempGeneration; tempGeneration = bs; }
/** * Do operations on the REGION_NAME's keys using keyIntervals to specify which keys get which * operations. This will return when all operations in all intervals have completed. * * @param availableOps - Bits which are true correspond to the operations that should be executed. */ public void doOps(BitSet availableOps) { boolean useTransactions = getInitialImage.InitImagePrms.useTransactions(); while (availableOps.cardinality() != 0) { int whichOp = getOp(availableOps, operations.length); boolean doneWithOps = false; if (useTransactions) { TxHelper.begin(); } switch (whichOp) { case ADD_NEW_KEY: doneWithOps = addNewKey(); break; case INVALIDATE: doneWithOps = invalidate(); break; case DESTROY: doneWithOps = destroy(); break; case UPDATE_EXISTING_KEY: doneWithOps = updateExistingKey(); break; case GET: doneWithOps = get(); break; case LOCAL_INVALIDATE: doneWithOps = localInvalidate(); break; case LOCAL_DESTROY: doneWithOps = localDestroy(); break; default: { throw new TestException("Unknown operation " + whichOp); } } if (useTransactions) { try { TxHelper.commit(); } catch (CommitConflictException e) { // currently not expecting any conflicts ... throw new TestException( "Unexpected CommitConflictException " + TestHelper.getStackTrace(e)); } } if (doneWithOps) { Log.getLogWriter().info("Done with operation " + whichOp); availableOps.clear(whichOp); } if (sleepBetweenOps) { Log.getLogWriter().info("Sleeping between ops for " + SLEEP_BETWEEN_OPS_MILLIS + " millis"); MasterController.sleepForMs(SLEEP_BETWEEN_OPS_MILLIS); } } }
@Override public void propagate(int evtmask) throws ContradictionException { if (PropagatorEventType.isFullPropagation(evtmask)) { if (n2 < n + vars[n].getLB()) { fails(); // TODO: could be more precise, for explanation purpose } buildDigraph(); } digraph.removeNode(n2); digraph.removeNode(n2 + 1); free.clear(); for (int i = 0; i < n; i++) { if (digraph.getPredOf(i).size() == 0) { free.set(i); } } for (int i = n; i < n2; i++) { if (digraph.getSuccOf(i).size() == 0) { free.set(i); } } int card = repairMatching(); vars[n].updateUpperBound(card, this); if (vars[n].getLB() == card) { filter(); } for (int i = 0; i < idms.length; i++) { idms[i].unfreeze(); } }
/** * Converse of addRule. Since we know all the rules ever stored in this flowmap we simply retrieve * the rule using the id provided and remove each of its fields from the underlying structures. * * @param id - the id of the rule to remove * @throws FlowEntryNotFound - if this id is unknown. Could indicate that rule has already been * removed. * @return */ public void removeRule(int id) throws FlowEntryNotFound { ruleCount--; if (!rules.containsKey(id)) throw new FlowEntryNotFound(id); FlowEntry rule = rules.get(id); BitSet flowRuleSet = getFlowRuleSet(rule); remove(port, rule.getRuleMatch().getInputPort(), flowRuleSet); remove(dpids, rule.dpid, flowRuleSet); remove(vlan, (int) rule.getRuleMatch().getDataLayerVirtualLan(), flowRuleSet); remove(vlan, rule.getRuleMatch().getDataLayerVirtualLanPriorityCodePoint() << 16, flowRuleSet); remove(dl_type, rule.getRuleMatch().getDataLayerType(), flowRuleSet); remove(nw, (short) rule.getRuleMatch().getNetworkProtocol(), flowRuleSet); remove(nw, (short) (rule.getRuleMatch().getNetworkTypeOfService() << 8), flowRuleSet); remove(tp, (int) rule.getRuleMatch().getTransportSource(), flowRuleSet); remove(tp, rule.getRuleMatch().getTransportDestination() << 16, flowRuleSet); remove(dl_src, FVMatch.toLong(rule.getRuleMatch().getDataLayerSource()), flowRuleSet); remove(dl_dst, FVMatch.toLong(rule.getRuleMatch().getDataLayerDestination()), flowRuleSet); remove(prioSet, rule.getPriority(), flowRuleSet); vlan_ignore.clear(rule.getId()); rules.remove(rule.getId()); allRules.andNot(flowRuleSet); }