logger.warn("Thumbnail file is empty: id={}", thumbnailId);
                    if (outputFile.delete()) {
                        logger.info("Deleted empty thumbnail file: {}", outputFile.getAbsolutePath());
                    }
                    updateThumbnailField(thumbnailId, StringUtil.EMPTY);
                    return false;
                }

                if (logger.isDebugEnabled()) {

     *
     * @param item the item to update
     */
    public abstract void update(T item);

    /**
     * Deletes a dictionary item.
     *
     * @param item the item to delete
     */
    public abstract void delete(T item);

    /**
     * A paginated list implementation that wraps another list and provides
     * pagination metadata and functionality.
     *

			conds = append(conds, clause.IN{Column: relColumn, Values: relValues})

			association.Error = association.DB.Where(clause.Where{Exprs: conds}).Model(nil).Delete(joinValue).Error
		}

		if association.Error == nil {
			// clean up deleted values' foreign key
			relValuesMap, _ := schema.GetIdentityFieldValuesMapFromValues(association.DB.Statement.Context, values, rel.FieldSchema.PrimaryFields)

	}
	err = st.Results(func(resp *ListDirResult) error {
		entries = resp.Entries
		return nil
	})
	return entries, toStorageErr(err)
}

// DeleteFile - deletes a file.
func (client *storageRESTClient) Delete(ctx context.Context, volume string, path string, deleteOpts DeleteOptions) error {
	if !deleteOpts.Immediate {
		// add deadlines for all non-immediate purges
		var cancel context.CancelFunc

				if g.VersionID == w.VersionID {
					return 0
				}
				return -1
			}) != 0 {
				t.Fatalf("Expected %v but got %v", test.wants, gots)
			}
			// verify the objects to be deleted
			close(workers[0])
			wg.Wait()
			if len(gotExpired) != len(test.wantExpired) {
				t.Fatalf("Expected expiry of %d objects but got %d", len(test.wantExpired), len(gotExpired))
			}

 * <p>When an instance of ContentCache is created with a byte array, the content is cached in memory.
 * When an instance is created with a File object, the content is cached in the specified file.
 *
 * <p>The {@code close()} method deletes the file if the content is cached in a file.
 *
 * <p>The {@code getInputStream()} method provides an InputStream to read the cached content.

        return redirect(getClass());
    }

    /**
     * Deletes a web authentication configuration.
     *
     * @param form the edit form containing the ID of the web authentication to delete
     * @return HTML response redirecting to the list page after deletion
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final EditForm form) {

        });
        return redirect(getClass());
    }

    /**
     * Deletes a related content item.
     *
     * @param form the edit form containing the ID of the item to delete
     * @return HTML response redirecting to the list page after deletion
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse delete(final EditForm form) {

        } else {
            try {
                final File propFile = ComponentUtil.getSystemHelper().createTempFile("thumbnail_", ".properties");
                if (propFile.delete() && logger.isDebugEnabled()) {
                    logger.debug("Deleted temp file: path={}", propFile.getAbsolutePath());
                }
                systemProperties.reload(propFile.getAbsolutePath());
                propFile.deleteOnExit();

func (c *MapClaims) Set(key string, val any) {
	if c == nil {
		return
	}
	c.MapClaims[key] = val
}

// Delete deletes a key named key.
func (c *MapClaims) Delete(key string) {
	if c == nil {
		return
	}
	delete(c.MapClaims, key)
}

// Lookup returns the value and if the key is found.
func (c *MapClaims) Lookup(key string) (value string, ok bool) {
	if c == nil {