remove an entry from the cache

@param pid
the entry's pid
761535
public final void remove(final String pid) {
        mapLock.lock();
		cacheMap.remove(pid);
        mapLock.unlock();
	}
1148794
public static void unregister(String ID) {
        displayNameCache.remove(new CaseInsensitiveString(ID));
        registry.remove(ID);
    }
766590
private void deletePolicy(String pid) throws GeneralException  {
        LOG.debug("Deleting policy " + pid);

        try {
            // in case the policy doesn't exist (corrupt policy index, failed to add because invalid, etc)
            m_policyIndex.deletePolicy(pid);
        } catch (PolicyIndexException e) {
            throw new GeneralException("Error deleting policy " + pid + " from policy index: " + e.getMessage(), e);
        }
    }
338812
public void remove(Identity oid)
    {
        if (oid == null) return;

        ObjectCache cache = getCache(oid, null, METHOD_REMOVE);
        if (cache != null)
        {
            cache.remove(oid);
        }
    }
1226601
def remove(self, block_id):
        
        with self._mutex:
            entry = self._block_map[block_id]
            self._queue.remove(entry)
612020
public synchronized void removeObject(String id) {

        m_cache = null;
        if (m_relativeOrdered) {
            if (m_uniqueIds) {
                Object o = getObject(id);
                Iterator<CmsIdObjectElement<T>> itObjs = m_orderedObjectList.iterator();
                while (itObjs.hasNext()) {
                    CmsIdObjectElement<T> object = itObjs.next();
                    if (object.getObject() == o) {
                        itObjs.remove();
                        break;
                    }
                }
                m_objectsById.remove(id);
            } else {
                Iterator<T> itRemove = m_objectsListsById.get(id).iterator();
                while (itRemove.hasNext()) {
                    T o = itRemove.next();
                    Iterator<CmsIdObjectElement<T>> itObjs = m_orderedObjectList.iterator();
                    while (itObjs.hasNext()) {
                        CmsIdObjectElement<T> object = itObjs.next();
                        if (object.getObject() == o) {
                            itObjs.remove();
                            break;
                        }
                    }
                }
                m_orderedObjectList.remove(id);
            }
        } else {
            Object o = getObject(id);
            m_objectList.remove(o);
            if (m_uniqueIds) {
                m_objectsById.remove(id);
            } else {
                m_objectsListsById.remove(id);
            }
        }
    }
916578
protected synchronized void remove(Object id) {
        // final String methodName = "remove(Object)";
        if (id == null) {
            return;
        }
        this.explicitBuffer.remove(id);
        this.scanBuffer.remove(id);
        // this.garbageCollectorBuffer.remove(id);
        // if (id instanceof HTODDynacache.EvictionTableEntry)
        // cod.htod.evictionEntryPool.add(id);

        // traceDebug(methodName, "id=" + id);
    }
896792
public void remove(int i, PersistentStore store) {

        writeLock.lock();

        try {
            CachedObject r = release(i);

            if (r != null) {
                int size = r.getStorageSize();

                freeBlocks.add(i, size);
            }
        } finally {
            writeLock.unlock();
        }
    }
814471
@Override
	public void removeByUuid(String uuid) {
		for (CPInstance cpInstance : findByUuid(uuid, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpInstance);
		}
	}
187705
def delete_pid(self, force_del=False):
        
        pid = self.read_pid()
        if pid != getpid() or force_del:
            logger.debug('process %d tried to delete pid' % getpid())
            return False

        if access(self.pid_file_name, F_OK):
            try:
                remove(self.pid_file_name)  # remove the old pid file
                logger.debug('delete pid (%d)' % getpid())
            except:
                logger.debug("can't delete pid file")
1132528
def clear_stale_pids(pids, pid_dir='/tmp', prefix='', multi=False):
    ''
    if isinstance(pids, (int, float, long)):
        pids = [pids]
    pids = str2list(pids, map_=unicode)
    procs = map(unicode, os.listdir('/proc'))
    running = [pid for pid in pids if pid in procs]
    logger.warn(
        "Found %s pids running: %s" % (len(running),
                                       running))
    prefix = prefix.rstrip('.') if prefix else None
    for pid in pids:
        if prefix:
            _prefix = prefix
        else:
            _prefix = unicode(pid)
        # remove non-running procs
        if pid in running:
            continue
        if multi:
            pid_file = '%s%s.pid' % (_prefix, pid)
        else:
            pid_file = '%s.pid' % (_prefix)
        path = os.path.join(pid_dir, pid_file)
        if os.path.exists(path):
            logger.debug("Removing pidfile: %s" % path)
            try:
                remove_file(path)
            except OSError as e:
                logger.warn(e)
    return running
465623
public synchronized void remove(Object key) {
        Object victim = null;
        if (cacheEvictionListenerSet.isEmpty() == false) {
            victim = get(key);
        }

        primaryTable.remove(key);
        secondaryTable.remove(key);
        tertiaryTable.remove(key);

        if (victim != null) {
            ArrayList<Object> evictedValues = new ArrayList<Object>();
            evictedValues.add(victim);
            for (CacheEvictionListener evictionCallback : cacheEvictionListenerSet) {
                evictionCallback.evicted(evictedValues);
            }
        }
    }
1242412
public void remove(Identity oid)
    {
        if(log.isDebugEnabled()) log.debug("Remove object " + oid);
        sessionCache.remove(oid);
        getApplicationCache().remove(oid);
    }
925082
@Override
    public synchronized void remove(String key) {
        boolean deleted = getFileForKey(key).delete();
        removeEntry(key);
        if (!deleted) {
            //todo add queue markers
//            JusLog.d("Could not delete cache entry for key=%s, filename=%s",
//                    key, getFilenameForKey(key));
        }
    }
521875
public function clearByPageId(int $pageId)
    {
        $cache = $this->get();
        $cacheEntries = \array_keys($cache->getByTag('pageId_' . $pageId));
        foreach ($cacheEntries as $cacheEntry) {
            $cache->remove($cacheEntry);
        }
    }
504280
@Override
    public void deleted(String pid) {
        final ServiceRegistration<T> registration = registrations.get(pid);
        if (registration != null) {
            LOGGER.info("Unregistering OSGi service for pid \"{}\"...", pid);
            final T service = bundleContext.getService(registration.getReference());
            registration.unregister();
            LOGGER.info("Destroying service object for pid \"{}\"...", pid);
            destroy(pid, service);
        }
    }
830869
public function _destroy($pId)
    {
        if (! isset($this->_items[$pId])) {
            $this->_items[$pId] = Agl::getModel(self::DB_COLLECTION);
            $this->_items[$pId]->loadByRealid($pId);
        }

        if ($this->_items[$pId]->getId()) {
            $this->_items[$pId]->delete();
        }

        return true;
    }