// Del is used to delete the specified entry from the set.
552715
func (s *IPSet) Del(entry string) error {
	out, err := exec.Command(ipsetPath, "del", s.Name, entry, "-exist").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error deleting entry %s: %v (%s)", entry, err, out)
	}
	return nil
}
728390
func (m MultiLevel) Del(path string) {
	for _, level := range m {
		level.Del(path)
	}
}
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)
}
575335
func (s *DeleteObjectsInput) SetDelete(v *Delete) *DeleteObjectsInput {
	s.Delete = v
	return s
}
1218182
func (s Int32) Delete(items ...int32) {
	for _, item := range items {
		delete(s, item)
	}
}
545821
func (c *MemoryCache) Delete(key string) {
	c.mu.Lock()
	delete(c.items, key)
	c.mu.Unlock()
}
948585
func (immutable *Immutable) Delete(entries ...Entry) (*Immutable, Entries) {
	if len(entries) == 0 {
		return immutable, Entries{}
	}

	deleted := make(Entries, 0, len(entries))
	cp := immutable.copy()
	for _, e := range entries {
		deleted = append(deleted, cp.delete(e))
	}

	return cp, deleted
}
62033
func (a *segment) Del(key []byte) error {
	return a.mutate(OperationDel, key, nil)
}
320333
func (s IntSet) Delete(items ...int) {
	for _, item := range items {
		delete(s, item)
	}
}
812288
func (s Set) Delete(els ...string) Set {
	if s == nil {
		return s
	}

	for _, el := range els {
		delete(s, el)
	}

	return s
}
329607
func (m *Map) Delete(k bpf.MapKey) error {
	_, err := m.delete(k, true)
	return err
}
145741
func (h *HashMap) Del(elementid string) error {
	if h.name == nil {
		return ErrDoesNotExist
	}
	// Remove the keys starting with elementid + ":"
	return (*bbolt.DB)(h.db).Update(func(tx *bbolt.Tx) error {
		bucket := tx.Bucket(h.name)
		if bucket == nil {
			return ErrBucketNotFound
		}
		return bucket.ForEach(func(byteKey, byteValue []byte) error {
			combinedKey := string(byteKey)
			if strings.Contains(combinedKey, ":") {
				fields := strings.SplitN(combinedKey, ":", 2)
				if fields[0] == elementid {
					return bucket.Delete([]byte(combinedKey))
				}
			}
			return nil // Continue ForEach
		})
	})
}
1149726
func (p *Imports) Del(path string) {
	p.Lock()
	defer p.Unlock()

	delete(p.m, path)
}
416724
func (s *storeImpl) Delete(key string) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	delete(s.objects, key)
}
581982
func (r *Redis) Delete(key string) error {
	return r.Client.Del(key).Err()
}
180791
func (hm *SyncedHashMap) Del(key Hashable) {
	hm.Lock()
	defer hm.Unlock()
	delete((*hm).keys, key.Hash())
	delete((*hm).values, key.Hash())
}
613526
func (s *RedisStore) Delete(key string) error {
	if !strings.HasPrefix(key, s.prefix) {
		key = s.prefix + key
	}
	return s.client.Del(key).Err()
}