Removes any stale contexts from the row context map.

@param rowIds the current set of row Ids.
340425
protected void cleanupStaleContexts(final Set<?> rowIds) {
		RepeaterModel model = getOrCreateComponentModel();

		if (model.rowContextMap != null) {
			for (Iterator<Map.Entry<Object, SubUIContext>> i = model.rowContextMap.entrySet().
					iterator(); i.hasNext();) {
				Map.Entry<Object, SubUIContext> entry = i.next();
				Object rowId = entry.getKey();

				if (!rowIds.contains(rowId)) {
					i.remove();
				}
			}
			if (model.rowContextMap.isEmpty()) {
				model.rowContextMap = null;
			}
		}
	}
15146
private void removeExistingKeys(Collection<Data> keys) {
        if (keys == null || keys.isEmpty()) {
            return;
        }
        Storage storage = recordStore.getStorage();
        keys.removeIf(storage::containsKey);
    }
1341667
public void deleteFromIndexes(DecoratedKey key, List<Cell> indexedColumnsInRow, OpOrder.Group opGroup)
    {
        // Update entire row only once per row level index
        Set<Class<? extends SecondaryIndex>> cleanedRowLevelIndexes = null;

        for (Cell cell : indexedColumnsInRow)
        {
            for (SecondaryIndex index : indexFor(cell.name()))
            {
                if (index instanceof PerRowSecondaryIndex)
                {
                    if (cleanedRowLevelIndexes == null)
                        cleanedRowLevelIndexes = new HashSet<>();
                    if (cleanedRowLevelIndexes.add(index.getClass()))
                        ((PerRowSecondaryIndex) index).delete(key, opGroup);
                }
                else
                {
                    ((PerColumnSecondaryIndex) index).deleteForCleanup(key.getKey(), cell, opGroup);
                }
            }
        }
    }
146301
public void clear()
    {
        final Object[] keys = _keys;
        final int[] values = _values;

        for (int i = keys.length - 1; i >= 0; i--) {
            keys[i] = null;
            values[i] = 0;
        }

        _size = 0;
    }
944096
private void removeBlockFromAddedBlocks(long blockId) {
    Iterator<Entry<String, List<Long>>> iterator = mAddedBlocks.entrySet().iterator();
    while (iterator.hasNext()) {
      Entry<String, List<Long>> entry = iterator.next();
      List<Long> blockList = entry.getValue();
      if (blockList.contains(blockId)) {
        blockList.remove(blockId);
        if (blockList.isEmpty()) {
          iterator.remove();
        }
        // exit the loop when already find and remove block id from mAddedBlocks
        break;
      }
    }
  }
244096
@Pure
	void clearBounds() {
		this.dataBounds = null;
		final N parent = getParentNode();
		if (parent != null) {
			parent.clearBounds();
		}
	}
217869
public void remove(RowKey key) {
		currentState.put( key, new AssociationOperation( key, null, REMOVE ) );
	}
837367
public void delete(Collection<String> eventIds, boolean cancelClaims) {
        _eventStore.delete(_readChannel, eventIds, cancelClaims);
    }
512552
protected void removeExpired(Map<Integer, Context> contexts) {
        Iterator<Context> contextsIter = contexts.values().iterator();
        while (contextsIter.hasNext()) {
            Context context = contextsIter.next();
            if (context.completeMoment != null
                    && System.currentTimeMillis() - context.completeMoment > contextTimeout) {
                contextsIter.remove();
            }
        }
    }
1334643
public void clear(Collection keys) {
		synchronized (mirror) {
			synchronized (data) {
				Iterator i = keys.iterator();
				while (i.hasNext()) {
					Object key = i.next();
					data.remove(key);
					mirror.remove(key);
				}
			}
		}
	}
922085
private void removeContext(final String contextID) {

    synchronized (this.contextStack) {

      if (!contextID.equals(this.contextStack.peek().getIdentifier())) {
        throw new IllegalStateException("Trying to close context with id `" + contextID +
            "`. But the top context has id `" +
            this.contextStack.peek().getIdentifier() + "`");
      }

      this.contextStack.peek().close();
      if (this.contextStack.size() > 1) {
        /* We did not close the root context. Therefore, we need to inform the
         * driver explicitly that this context is closed. The root context notification
         * is implicit in the Evaluator close/done notification.
         */
        this.heartBeatManager.sendHeartbeat(); // Ensure Driver gets notified of context DONE state
      }
      this.contextStack.pop();
      /*
      * At this moment, the Evaluator is actually idle and has some time till the Driver sends it additional work.
      * Also, a potentially large object graph just became orphaned: all the objects instantiated by the context
      * and service injectors can now be garbage collected. So GC call is justified.
      * */
      System.gc();
    }
  }
56322
public void clear() {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                mOriginalValues.clear();
            } else {
                mObjects.clear();
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }
467870
public void setRemoveSecurityGroupIds(java.util.Collection<String> removeSecurityGroupIds) {
        if (removeSecurityGroupIds == null) {
            this.removeSecurityGroupIds = null;
            return;
        }

        this.removeSecurityGroupIds = new com.amazonaws.internal.SdkInternalList<String>(removeSecurityGroupIds);
    }
448204
public void setRows(com.google.api.ads.admanager.axis.v201808.Row[] rows) {
        this.rows = rows;
    }
882939
private void decreaseRowIndexes(RowIndex fromRowIndex) {
        RowIndex[] indexes = removeRowIndexes(fromRowIndex);
        for (RowIndex rowIndex : indexes) {
            rowIndex.decreaseValue();
        }
        rowIndexes.addAll(Arrays.asList(indexes));
    }
684288
public void removeParticipants(@NonNull final String conversationId, @NonNull final List<String> ids, @Nullable Callback<ComapiResult<Void>> callback) {
        adapter.adapt(removeParticipants(conversationId, ids), callback);
    }
569643
private void removeFromIndexes(Object value, Object key, TransactionContext transactionContext) {
      performSearchWork(value, keyToString(key), WorkType.DELETE, transactionContext);
   }