// del returns a slice where all ocurences of s are filtered out. This modifies
// the original slice.
19971
func del(strs []string, s string) []string {
	for i := 0; i < len(strs); i++ {
		if strs[i] != s {
			continue
		}
		strs[i] = strs[len(strs)-1]
		strs = strs[:len(strs)-1]
		i--
	}
	return strs
}
62033
func (a *segment) Del(key []byte) error {
	return a.mutate(OperationDel, key, nil)
}
440420
func (c *Cursor) Del(flags uint) error {
	ret := C.mdb_cursor_del(c._c, C.uint(flags))
	return operrno("mdb_cursor_del", ret)
}
665350
func (m *RouteMux) Del(pattern string, handler http.HandlerFunc) {
	m.AddRoute(DELETE, pattern, handler)
}
422755
func (d *DiskStorer) Del(key string) error {
	if !validKey(key) {
		return errNoSession{}
	}

	filePath := path.Join(d.folderPath, key)

	d.mut.Lock()
	defer d.mut.Unlock()

	_, err := os.Stat(filePath)
	if os.IsNotExist(err) {
		return nil
	} else if err != nil {
		return errors.Wrapf(err, "unable to stat session file: %s", filePath)
	}

	return os.Remove(filePath)
}
87173
func (ll *ListLogHandler) Del(h LogHandler) {
	if h != nil {
		for i, handler := range ll.handlers {
			if handler == h {
				ll.handlers = append(ll.handlers[:i], ll.handlers[i+1:]...)
			}
		}
	}
}
928831
func (n *node) del(key []byte) {
	// Find index of key.
	index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, key) != -1 })

	// Exit if the key isn't found.
	if index >= len(n.inodes) || !bytes.Equal(n.inodes[index].key, key) {
		return
	}

	// Delete inode from the node.
	n.inodes = append(n.inodes[:index], n.inodes[index+1:]...)

	// Mark the node as needing rebalancing.
	n.unbalanced = true
}
884797
func (c SplitSize) Del(path string) {
	for _, child := range c {
		child.Cache.Del(path)
	}
}
372790
func Del(id string, params *stripe.SKUParams) (*stripe.SKU, error) {
	return getC().Del(id, params)
}
894250
func (d *DiskCache) Del(pathStr string) {
	pathStr = path.Join(d.baseDir, pathStr)
	matches, err := filepath.Glob(pathStr)
	if err != nil {
		return
	}

	// When recursively deleting directories from the cache, it's possible
	// that d.fileList will become out of sync with reality. But that's ok
	// since it just exists to prevent disk access on cache misses, so will
	// just result in a bit of extra disk access.

	d.lock.Lock()
	if pathStr == "*" {
		// Due to the above comment, special case when wiping out the entire
		// cache.
		d.fileList = make(map[string]int)
	}

	for _, match := range matches {
		delete(d.fileList, match)
		err = os.RemoveAll(match)
		if err != nil {
			// log removal failure
		}
	}
	d.lock.Unlock()

}
220336
func (s Store) Del(key string) {
	s.Lock()
	delete(s.m, key)
	s.Unlock()
}
229207
func (b *Bucket) Del(ctx context.Context, path string) error {
	req := &request{
		method: "DELETE",
		bucket: b.Name,
		path:   path,
	}
	return b.S3.query(ctx, req, nil)
}
280138
func (args Args) Del(key, value string) {
	if _, ok := args.fields[key]; ok {
		delete(args.fields[key], value)
		if len(args.fields[key]) == 0 {
			delete(args.fields, key)
		}
	}
}
622906
func (filters Args) Del(name, value string) {
	if _, ok := filters.fields[name]; ok {
		delete(filters.fields[name], value)
	}
}
1313348
func (s *SyncedSet) Del(datas ...interface{}) {
	s.Lock()
	defer s.Unlock()
	for _, data := range datas {
		delete(s.set, data)
	}
}
404448
func Del(customerID string, params *stripe.DiscountParams) (*stripe.Discount, error) {
	return getC().Del(customerID, params)
}
1121992
func (s *Set) Del(value string) error {
	if s.name == nil {
		return ErrDoesNotExist
	}
	return (*bbolt.DB)(s.db).Update(func(tx *bbolt.Tx) error {
		bucket := tx.Bucket(s.name)
		if bucket == nil {
			return ErrBucketNotFound
		}
		var foundKey []byte
		bucket.ForEach(func(byteKey, byteValue []byte) error {
			if value == string(byteValue) {
				foundKey = byteKey
				return ErrFoundIt // break the ForEach by returning an error
			}
			return nil // Continue ForEach
		})
		return bucket.Delete([]byte(foundKey))
	})
}