FUTURE remove, this methods are only used by compiled code in archives older than 5.2.3
490932
public static String call(PageContext pc, Object var, boolean serializeQueryByColumns, String strCharset) throws PageException {
	Charset cs = StringUtil.isEmpty(strCharset) ? pc.getWebCharset() : CharsetUtil.toCharset(strCharset);
	return _call(pc, var, serializeQueryByColumns, cs);
    }
998763
function cleanUp() {
			_Helper.removeByPath(that.mPostRequests, sPath, oEntityData);
			aCollection.splice(aCollection.indexOf(oEntityData), 1);
			aCollection.$created -= 1;
			addToCount(that.mChangeListeners, sPath, aCollection, -1);
			delete aCollection.$byPredicate[sTransientPredicate];
			if (!sPath) {
				// Note: sPath is empty only in a CollectionCache, so we may call adjustReadRequests
				that.adjustReadRequests(0, -1);
			}
			fnCancelCallback();
		}
392220
private void removeTemporaryMethodData(BeanMetaData bmd) {
        bmd.methodsExposedOnLocalHomeInterface = null;
        bmd.methodsExposedOnLocalInterface = null;
        bmd.methodsExposedOnRemoteHomeInterface = null;
        bmd.methodsExposedOnRemoteInterface = null;
        bmd.allPublicMethodsOnBean = null;
        bmd.methodsToMethodInfos = null;
    }
1148969
function() {
        for (var key in this.layerCache) {
            delete this.layerCache[key];
        }
        for (var key in this.wfsCache) {
            delete this.wfsCache[key];
        }
        OpenLayers.Control.prototype.destroy.apply(this, arguments);
    }
1046166
def versionable_delete(self, instance, timestamp):
        
        instance._delete_at(timestamp, using=self.using)
38127
function destroy(foPairs, index, collection, operand) {
  if (foPairs[index][collection].size === 1) {
    if (containsOne(foPairs[index])) {
      delete foPairs[index];
    } else {
      delete foPairs[index][collection];
    }
  }else {
    foPairs[index][collection].delete(operand);
  }
}
871683
function removeDuplicates(collection) {
  return collection.filter(function(e, i, arr) {
    return isValue(e) && arr.lastIndexOf(e) === i;
  });
}
350489
public <T> Future<?> removeDataFromCache(final Class<T> clazz) {
        if (clazz == null) {
            throw new IllegalArgumentException("Clazz must be non null.");
        }
        return executeCommand(new RemoveDataClassFromCacheCommand(this, clazz));
    }
78847
def remove(self, document_id, namespace, timestamp):
        
        database, coll = self._db_and_collection(namespace)

        meta_collection = self._get_meta_collection(namespace)

        doc2 = self.meta_database[meta_collection].find_one_and_delete(
            {self.id_field: document_id}
        )
        if doc2 and doc2.get("gridfs_id"):
            GridFS(self.mongo[database], coll).delete(doc2["gridfs_id"])
        else:
            self.mongo[database][coll].delete_one({"_id": document_id})
1286481
@Override
    public void onPreRemove(final IoFilterChain chain, final String name,
            final NextFilter nextFilter) {
        IoSession session = chain.getSession();
        session.removeAttribute(ProxyIoSession.PROXY_SESSION);
    }
943330
@Override
  public <T> List<T> remove(Collection<? extends T> batchToRemove, Class<T> entityClass) {
    return remove(batchToRemove, Util.determineCollectionName(entityClass));
  }
784852
def remove
            raise "Not all necessary api methods are defined to process this action!" unless api_methods[:remove]
            self.class.in_transaction(true) do |token|
                self.class.make_call(api_methods[:remove],name,token)
            end
        end
540729
def delete(self, **kwargs):
        
        self.reload_context(es_based=False, **kwargs)
        return super(ESCollectionView, self).delete(**kwargs)
1209477
public synchronized void remove(RemoteAsyncResultImpl asyncResult) {
        ivAllRemoteAsyncResults.remove(asyncResult);
        releaseResources(asyncResult); // d690014.3

        // If no server-side Future objects and an alarm is set then cancel the alarm.  d623593
        if (ivAllRemoteAsyncResults.isEmpty() && ivFuture != null) {
            ivFuture.cancel(false);
            ivFuture = null;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "remove " + asyncResult + "; size=" + ivAllRemoteAsyncResults.size());
    }
175552
function removeSelectedItem(e) {
        var recentProjects = getRecentProjects(),
            $cacheItem = $dropdownItem,
            index = recentProjects.indexOf($cacheItem.data("path"));

        // When focus is not on project item
        if (index === -1) {
            return false;
        }

        // remove project
        recentProjects.splice(index, 1);
        PreferencesManager.setViewState("recentProjects", recentProjects);
        checkHovers(e.pageX, e.pageY);

        if (recentProjects.length === 1) {
            $dropdown.find(".divider").remove();
        }
        selectNextItem(+1);
        $cacheItem.closest("li").remove();
        return true;
    }
1138681
def destroy(update_collection=true)
      return if new_record?
      previous_name = name_changed? ? name_was : name
      parent.modify_engine do |nat|
        nat.remove_redirect(previous_name)
      end
      parent_collection.delete(self, true) if parent_collection && update_collection
      new_record!
      true
    end
1019011
@Override
  public <T> T remove(Object objectToRemove, Class<T> entityClass) {
    return remove(objectToRemove, Util.determineCollectionName(entityClass));
  }