wrapped with delete_collection, override that in a sublcass to customize
488890
def _delete_collection(self, **kwargs):
        
        error_message = "The request must include \"requests_params\": {\"params\": \"options=<glob pattern>\"} as kwarg"
        try:
            if kwargs['requests_params']['params'].split('=')[0] != 'options':
                raise MissingRequiredRequestsParameter(error_message)
        except KeyError:
            raise

        requests_params = self._handle_requests_params(kwargs)
        delete_uri = self._meta_data['uri']
        session = self._meta_data['bigip']._meta_data['icr_session']

        session.delete(delete_uri, **requests_params)
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();
		}
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
1334533
def remove_many(self, it):
        """"""
        # find indicies of objects in iterable
        to_be_deleted = list(it)
        del_indices = []
        for i, ob in enumerate(self.obs):
            try:
                tbd_index = to_be_deleted.index(ob)
            except ValueError:
                continue
            else:
                del_indices.append(i)
                to_be_deleted.pop(tbd_index)

            # quit early if we have found them all
            if not to_be_deleted:
                break

        for i in sorted(del_indices, reverse=True):
            self.pop(i)

        return self
962286
def delete(self, context):
	
		
		
		encoded_name = urllib.parse.quote_plus(self.__name)
		status_code, msg = self.__endpoint.delete(
			"/resources/custom-resource/{}".format(encoded_name)
		)
		self.__available = False
895182
def delete(self, rid, raise_on_error=True):
        
        return self.ds.delete(rid, raise_on_error)
257365
def remove(self):

        ''' 
            
        '''

        _title = '%s.remove' % self.__class__.__name__

    # TODO  error handling is turned off to avoid system blocking
    #       fix potential to create artifacts in the system

    # remove collection tree
        try:
            import shutil
            shutil.rmtree(self.collection_folder, ignore_errors=True)
        except:
            raise Exception('%s failed to remove %s collection from app data.' % (_title, self.collection_folder))

        exit_msg = '%s collection has been removed from app data.' % self.collection_folder
        return exit_msg
576875
def delete_if_not_in_zsets(self, key, member, set_list, client=None):
        
        return self._delete_if_not_in_zsets(
            keys=[key]+set_list,
            args=[member],
            client=client)
973046
function deleteRecord(rType, idFun) {
  return function(item, callback) {
    GLOBAL.debug('deleting', item, rType);
    var tc = [];
    getEs().delete({ _type: rType, _id : encodeURIComponent(idFun(item))}, function(err, deleteRes) {
      callback(err, deleteRes);
    });
  };
}
350153
def resource_collection_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/resource_collections/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
350348
def delete_many(self, **kwargs):
        
        db_objects = self.get_dbcollection_with_es(**kwargs)
        return self.Model._delete_many(db_objects, self.request)
606619
function removeThis()
    {
        $itemOptionList = eZProductCollectionItemOption::fetchList( $this->attribute( 'id' ) );

        $db = eZDB::instance();
        $db->begin();
        foreach( $itemOptionList as $itemOption )
        {
            $itemOption->remove();
        }
        $this->remove();
        $db->commit();
    }
1171994
function(collection, blacklist){
        var obj,
            result = [],
            prop,
            i,
            j,
            collLen,
            listLen;

        blacklist = blacklist || ["__columns"];

        if(!collection || !collection.length){
            return result;
        }

        collLen = collection.length;

        for(i=0; i<collLen; i++){
            obj = collection[i];

            //delete null properties
            for(prop in obj){
                if(obj[prop] === null){
                    delete obj[prop];
                }
            }

            listLen = blacklist.length;
            for(j=0; j<listLen; j++){
                delete obj[blacklist[j]];
            }
            //These are javascript objects and not json, so we have to do this magic to strip it of get methods.
            result.push(JSON.parse(JSON.stringify(obj)));
        }

        return result;
    }
219238
def remove_all(self, other):
		
		if not self.is_superset(other):
			raise ValueError('Passed collection is not a subset of this bag')
		self.discard_all(other)
1156998
def purge_collection(keys):
    ""
    for key in keys:
        m = re.match(r'(.*) \((\d+)\)', key)
        name = m.group(1)
        node_id = m.group(2)
        value = render_value_for_node(node_id)
        print 'remove node with name:{0} and id:{1}'.format(name, node_id)

        delete_node(node_id=node_id)
        if isinstance(value, dict):
            purge_collection(value.keys())
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);
  }
}
633913
function(argument_value) {

		if (argument_value.isCollection) {

			if (this._own_collection) {

				this._value.destroy();
				this._own_collection = false;
				this._value = null;

			}

			if (this._value != argument_value) {
				this._value = argument_value;
				this._fire('new_enumerable');
			}

		} else if (this._own_collection) {

			this._value.refreshFromDataSource(argument_value);

		} else {

			this._createCollection(argument_value);

		}

	}