// Delete recursively deletes all objects stored at "path" and its subpaths.
187980
func (d *driver) Delete(ctx context.Context, path string) error {
	blobRef := d.client.GetContainerReference(d.container).GetBlobReference(path)
	ok, err := blobRef.DeleteIfExists(nil)
	if err != nil {
		return err
	}
	if ok {
		return nil // was a blob and deleted, return
	}

	// Not a blob, see if path is a virtual container with blobs
	blobs, err := d.listBlobs(d.container, path)
	if err != nil {
		return err
	}

	for _, b := range blobs {
		blobRef = d.client.GetContainerReference(d.container).GetBlobReference(b)
		if err = blobRef.Delete(nil); err != nil {
			return err
		}
	}

	if len(blobs) == 0 {
		return storagedriver.PathNotFoundError{Path: path}
	}
	return nil
}
33708
func (h *Heap) Delete(obj interface{}) error {
	key, err := h.data.keyFunc(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	h.lock.Lock()
	defer h.lock.Unlock()
	if item, ok := h.data.items[key]; ok {
		heap.Remove(h.data, item.index)
		return nil
	}
	return fmt.Errorf("object not found")
}
229532
func (p *PathStruct) Delete(ctx context.Context, s logical.Storage) error {
	return s.Delete(ctx, fmt.Sprintf("struct/%s", p.Name))
}
1173943
func (m *dirsMap) Delete(key string) {
	m.data.Delete(m.normalizeKey(key))
}
728390
func (m MultiLevel) Del(path string) {
	for _, level := range m {
		level.Del(path)
	}
}
267636
func (m *methods) Delete(path string, fn handler) *Route {
	return m.add(path, fn, DELETE)
}
438249
func (z *ZkPlus) Delete(path string, version int32) error {
	z.forPath(path).Log(logkey.ZkMethod, "Delete")
	return z.blockOnConn().Delete(z.realPath(path), version)
}
204348
func (g *Mutable) Delete(v, w int) {
	delete(g.edges[v], w)
}
1278500
func (d *driver) Delete(ctx context.Context, path string) error {
	d.mutex.Lock()
	defer d.mutex.Unlock()

	normalized := normalize(path)

	err := d.root.delete(normalized)
	switch err {
	case errNotExists:
		return storagedriver.PathNotFoundError{Path: path}
	default:
		return err
	}
}
1275419
func (_m *Client) Delete(path string, opts *pebbleclient.RequestOptions, result interface{}) error {
	ret := _m.Called(path, opts, result)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, *pebbleclient.RequestOptions, interface{}) error); ok {
		r0 = rf(path, opts, result)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
1015573
func (f *FileStore) Delete(keys [][]byte) error {
	return f.DeleteRange(keys, math.MinInt64, math.MaxInt64)
}
695591
func (s String) Delete(items ...string) {
	for _, item := range items {
		delete(s, item)
	}
}
481338
func (session *Session) Delete(path string, params Params) (Result, error) {
	return session.Api(path, DELETE, params)
}
747274
func (r *Router) Delete(path string, fn http.HandlerFunc) *Router {
	return r.Method(http.MethodDelete, path, fn)
}
828717
func (t *Templater) Del(path string) {
	t.m.Lock()
	defer t.m.Unlock()
	delete(t.templates, path)
}
145394
func (s *Server) Delete(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodDelete, path, h, opts...)
}
158428
func (f *fileStorage) Delete(key string) error {
	return os.Remove(f.filePathToFile(key))
}