Delete the bytecode

@param tc The template class
545459
public void deleteCache(TemplateClass tc) {
        if (!writeEnabled()) return;
        try {
            File f = getCacheFile(tc);
            if (f.exists() && !f.delete()) {
                f.deleteOnExit();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
1194573
final public void delete(Transaction t) {
		t.delete(Utils.getTableName(getClass()), Utils.getWhereStatement(this));
        t.addOnTransactionCommittedListener(new OnTransactionCommittedListener() {

            @Override
            public void onTransactionCommitted() {
                Sprinkles.sInstance.mContext.getContentResolver().notifyChange(
                        Utils.getNotificationUri(Model.this.getClass()), null);
            }
        });
		afterDelete();
	}
1165031
public static void dump(TraceComponent tc, String msg) {
    if(isTracing()) SibTr.dump(tc, msg);
  }
637710
@Override
    public void destroy() {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "destroy", this);

        // check the TSR is active - otherwise we can trigger exceptions when we
        // try to get data out of it.
        if (tsr.getTransactionKey() != null) {
            final Map<String, InstanceAndContext<?>> storage = getStorage(false);

            if (storage != null) {
                try {
                    for (InstanceAndContext<?> entry : storage.values()) {
                        final String id = getContextualId(entry.context);
                        destroyItem(id, entry);
                    }
                } finally {
                    tsr.putResource(TXC_STORAGE_ID, null);
                }
            }
        } else {
            if (tc.isDebugEnabled())
                Tr.debug(tc, "Tran synchronization registry not available, skipping destroy");
        }

        //Fire any observers
        beanManager.fireEvent("Destroying transaction context", destroyedQualifier);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "destroy");
    }
272400
private void generateDelete(SQLiteDatabaseSchema schema) {
		MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("delete").addModifiers(Modifier.PUBLIC).addAnnotation(Override.class).returns(Integer.TYPE);
		methodBuilder.addParameter(Uri.class, "uri");
		methodBuilder.addParameter(String.class, "selection");
		methodBuilder.addParameter(ParameterSpec.builder(TypeUtility.arrayTypeName(String.class), "selectionArgs").build());

		boolean hasOperation = hasOperationOfType(schema, methodBuilder, JQLType.DELETE);

		if (!hasOperation) {
			methodBuilder.addStatement("throw new $T(\"Unknown URI for $L operation: \" + uri)", IllegalArgumentException.class, JQLType.DELETE);
			classBuilder.addMethod(methodBuilder.build());
			return;
		}

		methodBuilder.addStatement("int returnRowDeleted=-1");
		methodBuilder.beginControlFlow("switch (sURIMatcher.match(uri))");

		defineJavadocHeaderForContentOperation(methodBuilder, "delete");

		for (Entry<String, ContentEntry> item : uriSet.entrySet()) {
			if (item.getValue().delete == null)
				continue;

			defineJavadocForContentUri(methodBuilder, item.getValue().delete);

			// methodBuilder.addJavadoc("uri $L\n", item.getKey());

			methodBuilder.beginControlFlow("case $L:", item.getValue().pathIndex);
			methodBuilder.addCode("// URI: $L\n", item.getValue().delete.contentProviderUri());
			methodBuilder.addStatement("returnRowDeleted=dataSource.get$L().$L(uri, selection, selectionArgs)", item.getValue().delete.getParent().getName(),
					item.getValue().delete.contentProviderMethodName);
			methodBuilder.addStatement("break");
			methodBuilder.endControlFlow();
		}

		defineJavadocFooterForContentOperation(methodBuilder);

		methodBuilder.beginControlFlow("default:");
		methodBuilder.addStatement("throw new $T(\"Unknown URI for $L operation: \" + uri)", IllegalArgumentException.class, JQLType.DELETE);
		methodBuilder.endControlFlow();

		methodBuilder.endControlFlow();

		if (hasOperation) {
			if (schema.generateLog) {
				// generate log section - BEGIN
				methodBuilder.addComment("log section for content provider delete BEGIN");
				methodBuilder.beginControlFlow("if (dataSource.isLogEnabled())");

				methodBuilder.addStatement("$T.info(\"Changes are notified for URI %s\", uri)", Logger.class);

				// generate log section - END
				methodBuilder.endControlFlow();
				methodBuilder.addComment("log section for content provider delete END");
			}
			methodBuilder.addStatement("getContext().getContentResolver().notifyChange(uri, null)");
		}
		methodBuilder.addCode("return returnRowDeleted;\n");

		classBuilder.addMethod(methodBuilder.build());
	}
965589
public void deleteMetadata(String templateName) {
        String scope = Metadata.scopeBasedOnType(templateName);
        this.deleteMetadata(templateName, scope);
    }
858978
public <C extends AbstractComponentController<?, ?, ?>> void removeFromCache(C controller) {
    ControllerFactory.get()
                     .removeFromCache(controller);
    controller.setCached(false);
  }
416068
public static void exception(TraceComponent tc, Throwable t) {
    if(isTracing()) SibTr.exception(tc, t);

  }
1197375
function (template) {
	if (template.attachments) {
		this.attachments = getCompiledArr( template.attachments );
	} else {
		this.attachments = [];
	}
	delete template.attachments;
	delete template.attachment;
	this.src = template;
	this.compiled = getCompiledObj( this.src );
}
648531
public void templateModem_name_DELETE(String name) throws IOException {
		String qPath = "/xdsl/templateModem/{name}";
		StringBuilder sb = path(qPath, name);
		exec(qPath, "DELETE", sb.toString(), null);
	}
762265
public static void removeByC_C_T_ST(long classNameId, long classPK,
		int type, int status) {
		getPersistence().removeByC_C_T_ST(classNameId, classPK, type, status);
	}
1251805
public void removeTaggedComponent(final WComponent component) {
		TemplateModel model = getOrCreateComponentModel();
		if (model.taggedComponents != null) {
			// Find tag
			String tag = null;
			for (Map.Entry<String, WComponent> entry : model.taggedComponents.entrySet()) {
				if (entry.getValue().equals(component)) {
					tag = entry.getKey();
					break;
				}
			}
			if (tag != null) {
				removeTaggedComponent(tag);
			}
		}
	}
1350611
public void remove(Class<?> clazz) {
		ClassMetadata metadata = get(clazz);
		metadataByClass.remove(clazz);
		metadataByKind.remove(metadata.getKind());
	}
1159504
@Override
    public void destroy(Exception e) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "destroy, vc=" + getVCHash());
        }

        // Clean up the read and write interfaces as well as the SSL engine.
        this.connected = false;
        cleanup();
        getVirtualConnection().getStateMap().remove(LINKCONFIG);
        if (this.syncConnectFailure) {
            // sync connect failure needs cleanup below us but not above
            // us on the connlink chain
            super.destroy();
        } else {
            // otherwise use the destroy that goes up the chain
            super.destroy(e);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "destroy");
        }
    }
128552
public void deleteMetadata(String templateName, String scope) {
        URL url = METADATA_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID(), scope, templateName);
        BoxAPIRequest request = new BoxAPIRequest(this.getAPI(), url, "DELETE");
        BoxAPIResponse response = request.send();
        response.disconnect();
    }
524079
@Override
	public CPDefinitionVirtualSetting removeByC_C(long classNameId, long classPK)
		throws NoSuchCPDefinitionVirtualSettingException {
		CPDefinitionVirtualSetting cpDefinitionVirtualSetting = findByC_C(classNameId,
				classPK);

		return remove(cpDefinitionVirtualSetting);
	}
1265552
@Override
    public void delete(ZooPC obj) {
    	if (obj.getClass() == GenericObject.class) {
    		throw new IllegalArgumentException();
//    		deleteGeneric((GenericObject) obj);
//    		return;
    	}
    	
        if (!isStarted) {
            this.sie = node.getSchemaIE(cls);
            isStarted = true;
        }

        //updated index
        //This is buffered to reduce look-ups to find field indices.
        buffer[bufferCnt++] = obj;
        if (bufferCnt == BUFFER_SIZE) {
            flushBuffer();
        }
    }