Deletes the item corresponding to ``id``.
767005
def delete(self, id, id_name='id', **kwargs):
        
        response = self._new_response()
        if self._check_supported_op('delete', response):
            params = {'Key': {id_name: id}}
            self._call_ddb_method(self.table.delete_item, params, response)
            response.data = 'true'
        response.prepare()
        return response
266427
function deleteItem(id) {
  return new Promise((resolve, reject) => {
    return instance.pkgs.then(db => {
      const req = db.transaction(db.name, 'readwrite')
        .objectStore(db.name).delete(id);
      req.onerror = event => reject(event);
      req.onsuccess = () => resolve();
    });
  });
}
390296
public function deleteItem( $id )
	{
		$siteid = $this->_getContext()->getLocale()->getSiteId();
		$this->begin();

		try
		{
			$this->_createTreeManager( $siteid )->deleteNode( $id );
			$this->commit();
		}
		catch( Exception $e )
		{
			$this->rollback();
			throw $e;
		}
	}
798370
def remove(self, id):
        
        before_len = len(self.model.db)
        self.model.db = [t for t in self.model.db if t["id"] != id]
        if not self._batch.enable.is_set():
            self.model.save_db()
        return before_len - len(self.model.db)
1189051
public function remove($itemId)
    {
        $items = &$this->items;

        foreach ($items as $position => $item) {
            if ($itemId === $item->id) {
                unset($items[$position]);
            }
        }
    }
970952
def delete(cls, id):
        '''
        
        '''
        client = cls._new_api_client()
        return client.make_request(cls, 'delete', url_params={'id': id})
1176691
public void remove(Id id){
        String dir = getBaseDirectory(id.getDatabase(),id.getCollection());
        boolean i1 = new File(dir+File.separator+id.getEntity()).delete();
        boolean i2 = new File(dir+File.separator+id.getEntity()+".json").delete();
        if(LOG.isDebugEnabled())
            LOG.debug("File removed successfully("+(i1&&i2)+") id: "+id);
    }
64180
function(oDD) {
            for (var g in oDD.groups) {
                if (g) {
                    var item = this.ids[g];
                    if (item && item[oDD.id]) {
                        delete item[oDD.id];
                    }
                }
                
            }
            delete this.handleIds[oDD.id];
        }
1008155
@Override
    public void delete(final String id) {
        if (!StringUtils.isEmpty(id)) {
            doDelete(id);
            notifyDeleted(id);
        }
    }
787737
public DrawerView removeItemById(long id) {
        for (DrawerItem item : mAdapter.getItems()) {
            if (item.getId() == id) {
                mAdapter.remove(item);
                updateList();
                return this;
            }
        }
        return this;
    }
614086
public final synchronized void removeId(long id)
	{
		if (tc.isEntryEnabled()) Tr.entry(tc, "removeId", new Long(id));

		_idMap.remove(id);

		if (tc.isEntryEnabled()) Tr.exit(tc, "removeId");
	}
1302021
public
    function destory($id)
    {
        $row = Model::find($id);
        $row->delete();
        flash()->success('Your Item Deleted');
        return redirect()->to("/menus");
    }
1193997
def delete(id)
      return true unless id
      with_redis { |redis| redis.del(redis_key_for(id)) }
      true
    end
398129
def deleteItem(self, itemID):
        
        collections = self.get_data_collections()

        query = {"currentMax": {"$exists": True}}
        currentMax = self.noteDB["IDs"].find_one(query)['currentMax']
        query = {"unusedIDs": {"$exists": True}}
        unusedIDs = self.noteDB['IDs'].find_one(query)['unusedIDs']

        if (itemID > currentMax) or (itemID in unusedIDs):
            raise ValueError("ID {0} does not exist".format(itemID))

        # Find document with ID
        for coll in collections:
            self.noteDB[coll].remove({"ID": itemID})

        if currentMax == itemID:
            self.noteDB['IDs'].update({"currentMax": currentMax},
                                      {"currentMax": currentMax - 1})
        else:
            unusedIDs.append(itemID)
            self.noteDB['IDs'].update({"unusedIDs": {"$exists": True}},
                                      {"unusedIDs": unusedIDs})

        return itemID
482362
def filter_delete(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/filters/{0}'.format(str(id))
        self.__api_request('DELETE', url)
872045
public void deleteById(String id) {
    if (idToVersion.containsKey(id)) {
      String version = idToVersion.remove(id);
      expirationVersion.remove(version);
      versionToItem.remove(version);
      if (collectionCachePath != null
          && !collectionCachePath.resolve(version).toFile().delete()) {
        log.debug("couldn't delete " + version);
      }
    }
  }
13597
function remove(id, store) {
      var data = store.rootData.asObject();
      // Check id coincidence
      if (data[id.toString()]) {
        var deleted = JSON.stringify(data[id.toString()]);
        // Delete item
        delete data[id.toString()];
        // Update store data
        store.rootData = store.data = new Result(data, store, store.data.__sorted);
        // Update store data items length
        store.size = Object.keys(store.data).length;
        // Trigger onSourceChanged event
        vcomet.triggerCallback("onSourceChanged", store);
        return JSON.parse(deleted);
      } else {
        // Item not found warning
        return vcomet.error.log("store", "Item with id " + id + " not found");
      }
    }