// Delete removes content and metadata files associated with the digest.
170958
func (s *fs) Delete(dgst digest.Digest) error {
	s.Lock()
	defer s.Unlock()

	if err := os.RemoveAll(s.metadataDir(dgst)); err != nil {
		return err
	}
	return os.Remove(s.contentFile(dgst))
}
882527
func (s *Store) Delete(ctx context.Context, path string) error {
	_, err := s.api.Logical().Delete(path)
	return err
}
826158
func (c *CloudStorage) Delete(ctx context.Context, path string) error {
	bh, err := c.bucketHandle(ctx, storage.ScopeReadWrite)
	if err != nil {
		return err
	}
	return bh.Object(path).Delete(ctx)
}
1249716
func (k *KV) Delete(key string, w *WriteOptions) (*WriteMeta, error) {
	return k.deleteInternal(key, nil, w)
}
670972
func (s *Service) Delete(ctx context.Context, v interface{}, path string) error {
	return s.Do(ctx, v, "DELETE", path, nil, nil, nil)
}
531677
func (mem *Memory) Delete(key string) (*rspb.Release, error) {
	defer unlock(mem.wlock())

	elems := strings.Split(key, ".v")

	if len(elems) != 2 {
		return nil, storageerrors.ErrInvalidKey(key)
	}

	name, ver := elems[0], elems[1]
	if _, err := strconv.Atoi(ver); err != nil {
		return nil, storageerrors.ErrInvalidKey(key)
	}
	if recs, ok := mem.cache[name]; ok {
		if r := recs.Remove(key); r != nil {
			// recs.Remove changes the slice reference, so we have to re-assign it.
			mem.cache[name] = recs
			return r.rls, nil
		}
	}
	return nil, storageerrors.ErrReleaseNotFound(key)
}
194562
func (c *Cache) Delete(_ context.Context, key dataloader.Key) bool {
	if _, found := c.c.Get(key.String()); found {
		c.c.Delete(key.String())
		return true
	}
	return false
}
952243
func (s *s3ManifestService) Delete(ctx context.Context, dgst godigest.Digest) error {
	return fmt.Errorf("unimplemented")
}
1068531
func (f *FileStore) Delete(key string) error {
	if err := ValidateKey(key); err != nil {
		return err
	}
	return removePath(f.filesystem, f.getPathByKey(key))
}
341257
func (s *encryptedKeyStorage) Delete(ctx context.Context, path string) error {
	encPath, err := s.encryptPath(path)
	if err != nil {
		return err
	}

	return s.s.Delete(ctx, encPath)
}
294434
func (c *Client) Delete(path string) error {
	pconn, err := c.getIdleConn()
	if err != nil {
		return err
	}

	defer c.returnConn(pconn)

	return pconn.sendCommandExpected(replyFileActionOkay, "DELE %s", path)
}
604548
func (mem *Memcache) Delete(key string) error {
	return mem.conn.Delete(key)
}
326528
func (l Local) Delete(_ context.Context, path string) error {
	return os.RemoveAll(l.fullPath(path))
}
528046
func (g *Group) DELETE(path string, handler HandlerFunc) {
	g.Handle("DELETE", path, handler)
}
585619
func (e *Echo) Delete(path string, h interface{}, m ...interface{}) {
	e.add(DELETE, "", path, h, m...)
}
229532
func (p *PathStruct) Delete(ctx context.Context, s logical.Storage) error {
	return s.Delete(ctx, fmt.Sprintf("struct/%s", p.Name))
}
41585
func (m *mem) Delete(_ context.Context, path string) error {
	m.Lock()
	delete(m.data, path)
	m.Unlock()
	return nil
}