Delete and return the entry for the given key. Return nil if no matching
 entry exists.
 @param key [Integer or String]
 @return [Object] Deleted entry
541403
def delete(key)
      hashed_key = hash_key(key)
      unless (entry = @btree.get(hashed_key))
        return nil
      end

      if entry.is_a?(PEROBS::Array)
        entry.each_with_index do |ae, i|
          if ae.key == key
            self.entry_counter -= 1
            return entry.delete_at(i).value
          end
        end
      else
        return entry.value if entry.key == key
      end

      nil
    end
614921
function(key){
    
        var current = this.item(key);

		if (current)
        {        
            //special case: removing first item
            if (this._head === current) {
	
                this._head = current.next;
                
                if (!this._head){
                    this._tail = null;
                } else {
                    this._head.prev = null;
                };
       
            //special case: removing last item
            } else if (this._tail === current) {
                this._tail = current.prev;
                this._tail.next = null;
            } else {
				current.prev.next = current.next;
				current.next.prev = current.prev;
            };

			this._length--;
			delete this._hash[key];
			        
            return current;            
        
        } else {
            return null;
        }
               
    }
32099
def remove(key)
      node = self

      while node do
        # Find index of the entry that best fits the key.
        i = node.search_key_index(key)
        if node.is_leaf
          # This is a leaf node. Check if there is an exact match for the
          # given key and return the corresponding value or nil.
          if node.keys[i] == key
            return node.remove_element(i)
          else
            return nil
          end
        end

        # Descend into the right child node to continue the search.
        node = node.children[i]
      end

      PEROBS.log.fatal 'Could not find proper node to remove from'
    end
11965
function del(/* key-1, key-N, req */) {
  var args = slice.call(arguments, 0)
    , req = typeof args[args.length-1] === 'object' ? args.pop() : null;
  var deleted = 0;
  for(var i = 0;i < args.length;i++) {
    if(this.keyExists(args[i])) {
      this.delKey(args[i], req);
      deleted++;
    }
  }
  return deleted;
}
163757
def delete(key)
      deleted = @store.delete(key)
      @on_write_failure.call(key) if !deleted && @on_write_failure
      RecordCache::Base.logger.debug{ "Version Store: deleted #{key}" }
      deleted
    end
1160287
def delete(self, key):
        
        self._dstore.delete(key)
        self.cache.delete(key)
1160178
def delete(key)
      key = key.key if key.respond_to?(:key)

      unless (idx = @indicies[key]).nil?
        @indicies.delete(key)
        @indicies.each { |k,v| @indicies[k] = v -= 1 if v > idx }
        @lines.delete_at(idx)
      end
    end
571106
def __delete(self, key):
        ''' 
        '''
        with self.get_conn() as conn:
            try:
                c = conn.cursor()
                c.execute("DELETE FROM cache_entries WHERE key = ?", (key,))
                conn.commit()
            except:
                getLogger().exception("Cannot delete")
                return None
676089
def delete(self, key):
        
        with self._lmdb.begin(write=True, buffers=True) as txn:
            txn.delete(key.encode())
1157030
function del(key) {
  if (!shouldProcess(key) || !module.exports.client) return bluebird.resolve();

  return module.exports.client.hdelAsync(REDIS_HASH, key);
}
1036606
def kremove(self, key, value=None):
        
        for item in self:
            if value is None:
                # Just pop the key if present,
                # otherwise return None
                # (shortcut to ignore the exception)
                item.pop(key, None)
            else:
                try:
                    # Use the key as a set
                    item[key].remove(value)
                    # If the set contains a single element
                    # just store the latter
                    if len(item[key]) == 1:
                        item[key] = item[key].pop()
                except KeyError:
                    # This happens when the item
                    # does not contain the key
                    pass
                except AttributeError:
                    # This happens when the key is not a set
                    # and shall be removed only if values match
                    if item[key] == value:
                        item.pop(key)
1287747
def delete(key)
      key = key.to_sym
      types.delete(key)
      messages.delete(key)
    end
199529
def remove(self, key):
        '''
        
        '''
        encodedKey = json.dumps(key)
        sql = 'DELETE FROM ' + self.table + ' WHERE name = %s'
        with self.connect() as conn:
            with doTransaction(conn):
                return executeSQL(conn, sql, args=[encodedKey])
1064737
def delete(self, key: bytes) -> Tuple[Hash32]:
        
        validate_is_bytes(key)
        validate_length(key, self._key_size)

        return self.set(key, self._default)
1164326
def delete(entry)
      raise(ArgumentError, 'Must be an Entry') unless entry.is_a?(PoParser::Entry)

      @entries.delete(entry)
    end
48645
def delete(key)
      @monitor.synchronize do
        entry = @stash.delete(key)
        if entry
          @expires_at.delete(entry)
          entry.value
        else
          nil
        end
      end
    end
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)