// Delete implements the logical.Storage Delete method.
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)
}
353794
func (s *MysqlStore) Delete(key interface{}) error {
	s.lock.Lock()
	defer s.lock.Unlock()

	delete(s.data, key)
	return nil
}
1018399
func (c *Cache) Delete(keys [][]byte) {
	c.DeleteRange(keys, math.MinInt64, math.MaxInt64)
}
539373
func (db *Storage) Delete(ctxt Context, val interface{}) error {
	ctxt = debugContext(ctxt)
	t, _, err := db.findType(val, "Delete")
	if err != nil {
		return err
	}

	var buf bytes.Buffer
	var args []interface{}
	rval := reflect.ValueOf(val).Elem()

	fmt.Fprintf(&buf, "delete from %q where ", t.name)
	sep := ""
	for _, col := range t.fields {
		if !col.key {
			continue
		}
		args = append(args, rval.FieldByIndex(col.index).Interface())
		fmt.Fprintf(&buf, "%s%q = ?", sep, col.name)
		sep = " and "
	}

	_, err = ctxt.Exec(buf.String(), args...)
	return err
}
126025
func (s *memcachedStorage) Delete(key string) error {
	return s.c.Delete(key)
}
819445
func (c *Cache) Delete(key string) {
	c.db.Delete([]byte(key), nil)
}
392547
func (res *Resource) Delete(storage store.Delete) {
	res.HandleFuncC(
		pat.Delete(patID),
		func(ctx context.Context, w http.ResponseWriter, r *http.Request) {
			res.deleteHandler(ctx, w, r, storage)
		},
	)

	res.addRoute(delete, patID)
}
157500
func (s *RateLimitedStorage) Delete(key interface{}) error {
	s.wait()
	defer s.signal()

	return s.storage.Delete(key)
}
443866
func (b *Bucket) Delete(k string) error {
	return b.Write(k, 0, 0, nil, Raw)
}
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
}
73400
func (ms *manifestStore) Delete(ctx context.Context, dgst digest.Digest) error {
	dcontext.GetLogger(ms.ctx).Debug("(*manifestStore).Delete")
	return ms.blobStore.Delete(ctx, dgst)
}
521207
func (s *Store) Delete(key, dataType interface{}) error {
	return s.Bolt().Update(func(tx *bolt.Tx) error {
		return s.TxDelete(tx, key, dataType)
	})
}
209498
func (d *Datastore) Delete(key ds.Key) (err error) {
	return d.child.Delete(d.ConvertKey(key))
}
286960
func (l *LocalStore) Delete(ctx context.Context, obj string) error {
	fo := path.Join(l.storepath, obj)
	os.Remove(fo)
	mf := fo + ".metadata"
	if cloudstorage.Exists(mf) {
		os.Remove(mf)
	}
	return nil
}
1037850
func (db *Database) Delete(sid string, key string) (deleted bool) {
	return db.redis.Delete(makeKey(sid, key)) == nil
}
367965
func (s *RedisApplicationStore) Delete(appID string) error {
	return s.store.Delete(appID)
}
371205
func (c *Container) Delete(volumes bool) error {
	dc, err := getDockerClient()
	if err != nil {
		return err
	}
	err = dc.RemoveContainer(dockerclient.RemoveContainerOptions{ID: c.ID, RemoveVolumes: volumes})
	if _, ok := err.(*dockerclient.NoSuchContainer); ok {
		return ErrNoSuchContainer
	}
	return err
}