Atomically remove the given flags from the current set

@param flags to unset
@return the previous value
167651
public int unset( final int    flags )
    {
        for (;;)
        {
            int    current = _flags.get();
            int    newValue = current & ~flags;

            if ( _flags.compareAndSet( current, newValue ) )
            {
                return current;
            }
        }
    }
1060072
public long remove(K key)
  {
    if (key == null) {
      long old = _nullValue;
      _nullValue = NULL;
      return old;
    }

    int hash = key.hashCode() & _mask;

    while (true) {
      Object mapKey = _keys[hash];

      if (mapKey == null)
        return NULL;
      else if (mapKey.equals(key)) {
        _flags[hash] |= DELETED;

        _size--;

        _keys[hash] = null;

        return _values[hash];
      }

      hash = (hash + 1) & _mask;
    }
  }
105893
synchronized List<AllocatedSlice> removeAllAllocatedSlices() {

		final List<AllocatedSlice> slices = new ArrayList<AllocatedSlice>(this.allocatedSlices.values());
		final Iterator<AllocatedSlice> it = slices.iterator();
		while (it.hasNext()) {
			removeAllocatedSlice(it.next().getAllocationID());
		}

		return slices;
	}
946622
def remove(self, uids: Iterable[int]) -> None:
        
        for uid in uids:
            self._recent.discard(uid)
            self._flags.pop(uid, None)
580454
public void delete(final PutFlags... f) {
    if (SHOULD_CHECK) {
      checkNotClosed();
      txn.checkReady();
      txn.checkWritesAllowed();
    }
    final int flags = mask(f);
    checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
  }
1183093
public static Unset unset(String... fields) {
        Unset x = new Unset();
        for (String f : fields) {
            x.more(f);
        }
        return x;
    }
1265491
public static Pattern remove(String regex, int flags) {
		return POOL.remove(new RegexWithFlag(regex, flags));
	}
382630
private static int switchFlag(final int flags, final int mask, final boolean value) {
		int newFlags = value ? flags | mask : flags & ~mask;
		return newFlags;
	}
442820
public M remove(String... attrs) {
		if (attrs != null)
			for (String a : attrs) {
				this.attrs.remove(a);
				this._getModifyFlag().remove(a);
			}
		return (M)this;
	}
584575
@Override
  public void remove() {
    Assert.state(nextCalled.compareAndSet(true, false), "next was not called before remove");
    iterators.peek().remove();
  }
1368342
BaseRow removeLast() {
		Map.Entry<BaseRow, Collection<BaseRow>> last = treeMap.lastEntry();
		BaseRow lastElement = null;
		if (last != null) {
			Collection<BaseRow> list = last.getValue();
			lastElement = getLastElement(list);
			if (lastElement != null) {
				if (list.remove(lastElement)) {
					currentTopNum -= 1;
				}
				if (list.size() == 0) {
					treeMap.remove(last.getKey());
				}
			}
		}
		return lastElement;
	}
497352
public long toFlagsBitSet() {
      PersistenceMode persistenceMode = (PersistenceMode) params[PersistenceMode.ID].get();
      LockingMode lockingMode = (LockingMode) params[LockingMode.ID].get();
      ExecutionMode executionMode = (ExecutionMode) params[ExecutionMode.ID].get();
      StatisticsMode statisticsMode = (StatisticsMode) params[StatisticsMode.ID].get();
      ReplicationMode replicationMode = (ReplicationMode) params[ReplicationMode.ID].get();
      long flagsBitSet = 0;
      switch (persistenceMode) {
         case SKIP_PERSIST:
            flagsBitSet |= FlagBitSets.SKIP_CACHE_STORE;
            break;
         case SKIP_LOAD:
            flagsBitSet |= FlagBitSets.SKIP_CACHE_LOAD;
            break;
         case SKIP:
            flagsBitSet |= FlagBitSets.SKIP_CACHE_LOAD | FlagBitSets.SKIP_CACHE_STORE;
            break;
      }
      switch (lockingMode) {
         case SKIP:
            flagsBitSet |= FlagBitSets.SKIP_LOCKING;
            break;
         case TRY_LOCK:
            flagsBitSet |= FlagBitSets.ZERO_LOCK_ACQUISITION_TIMEOUT;
            break;
      }
      switch (executionMode) {
         case LOCAL:
            flagsBitSet |= FlagBitSets.CACHE_MODE_LOCAL;
            break;
         case LOCAL_SITE:
            flagsBitSet |= FlagBitSets.SKIP_XSITE_BACKUP;
            break;
      }
      if (statisticsMode == StatisticsMode.SKIP) {
         flagsBitSet |= FlagBitSets.SKIP_STATISTICS;
      }
      switch (replicationMode) {
         case SYNC:
            flagsBitSet |= FlagBitSets.FORCE_SYNCHRONOUS;
            break;
         case ASYNC:
            flagsBitSet |= FlagBitSets.FORCE_ASYNCHRONOUS;
            break;
      }
      return flagsBitSet;
   }
1360239
public final Transcoding transcoding(int flags) {
        Transcoding tc = new Transcoding(this, flags);

        if (hasStateInit()) {
            stateInit(tc.state);
        }

        return tc;
    }
920311
public T remove(final int key) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);

		int entry = elementKeys[index];
		if (key == entry) {
			final T oldvalue = elementValues[index];
			elementKeys[index] = Integer.MIN_VALUE;
			elementValues[index] = null;
			elementCount--;
			return oldvalue;
		}
		return null;
	}
384307
public int change( final int    add,
                       final int    remove )
    {
        for (;;)
        {
            int    current = _flags.get();
            int    newValue = ( current | add ) & ~remove;

            if ( _flags.compareAndSet( current, newValue ) )
            {
                return current;
            }
        }
    }
846318
def set_flagstate(flagset):
    
    if not flagset <= _all_flags:
        raise ValueError("unrecognized flags in flagset")

    for f in flagset:
        set_flag(f)
    for f in _all_flags - flagset:
        clear_flag(f)
682551
static protected void removeValues(TreeMultimap<Long, Long> mm, Set<Long> values) {
        Iterator<Map.Entry<Long, Long>> itr = mm.entries().iterator();
        while (itr.hasNext()) {
            Map.Entry<Long, Long> e = itr.next();
            if (values.contains(e.getValue())) {
                itr.remove();
            }
        }
    }