EventUpdate

	// EventDelete is sent when an object is deleted
	// Captures the object at the last known state
	EventDelete
)

func (event EventType) String() string {
	out := "unknown"
	switch event {
	case EventAdd:
		out = "add"
	case EventUpdate:
		out = "update"
	case EventDelete:
		out = "delete"
	}
	return out
}

type Event struct {
	Old   Object

	// Delete should return previously inserted value

	deleted := index.Delete(wi1)
	assert.Equal(t, wi1, deleted)

	// GetByIP should return 1 workload instance

	verifyGetByIP("2.2.2.2", []*model.WorkloadInstance{wi3})

	// Delete should return nil since there is no such element in the index

	deleted = index.Delete(wi1)
	assert.Equal(t, nil, deleted)

	Location string   `xml:"LocationConstraint"`
}

// DeleteObjectsRequest - xml carrying the object key names which needs to be deleted.
type DeleteObjectsRequest struct {
	// Element to enable quiet mode for the request
	Quiet bool
	// List of objects to be deleted
	Objects []ObjectToDelete `xml:"Object"`

//
// Implementation is thread-compatible.
type GC interface {
	// Garbage collect containers.
	GarbageCollect(ctx context.Context) error
	// Deletes all unused containers, including containers belonging to pods that are terminated but not deleted
	DeleteAllUnusedContainers(ctx context.Context) error
	// IsContainerFsSeparateFromImageFs tells if writeable layer and read-only layer are separate.

    DeleterStruct* deleter = reinterpret_cast<DeleterStruct*>(deleter_struct);
    deleter->deleter(memory, len);
    delete deleter;
  }

  struct TFTensorDeleter {
    void operator()(TF_Tensor* p) const { TF_DeleteTensor(p); }
  };
  std::unique_ptr<TF_Tensor, TFTensorDeleter> tensor_;
};

inline void* Tensor::data() const { return TF_TensorData(tensor_.get()); }

					delete(cache.iamUsersMap, k)
				}
			}
			for k, u := range cache.iamSTSAccountsMap {
				if u.Credentials.ParentUser == accessKey {
					delete(cache.iamSTSAccountsMap, k)
				}
			}
		}

		// 3. Delete any mapped policy
		cache.iamUserPolicyMap.Delete(accessKey)

		return nil
	}

	if err != nil {

import org.apache.commons.io.FileUtils;
import org.gradle.internal.file.Deleter;
import org.gradle.internal.file.TreeType;

import java.io.File;
import java.io.IOException;

public class DefaultTarPackerFileSystemSupport implements TarPackerFileSystemSupport {
    private final Deleter deleter;

    public DefaultTarPackerFileSystemSupport(Deleter deleter) {
        this.deleter = deleter;
    }

    @Override

	if err := h.DeleteChart(helmtest.BaseReleaseName, helmtest.IstioNamespace); err != nil {
		return fmt.Errorf("failed to delete %s release", helmtest.BaseReleaseName)
	}
	if err := cs.Kube().CoreV1().Namespaces().Delete(context.TODO(), helmtest.IstioNamespace, metav1.DeleteOptions{}); err != nil {
		return fmt.Errorf("failed to delete istio namespace: %v", err)
	}

func (tc *Controller) processJob(ctx context.Context, key string) error {
	namespace, name, err := cache.SplitMetaNamespaceKey(key)
	if err != nil {
		return err
	}

	// Ignore the Jobs that are already deleted or being deleted, or the ones that don't need clean up.
	job, err := tc.jLister.Jobs(namespace).Get(name)

	logger := klog.FromContext(ctx)
	logger.V(4).Info("Checking if Job is ready for cleanup", "job", klog.KRef(namespace, name))

    }

    CompileTransaction newCompileTransaction(PatternSet classesToDelete) {
        return new CompileTransaction(spec, classesToDelete, Collections.emptyMap(), TestFiles.fileOperations(temporaryFolder), TestFiles.deleter())
    }