Remove an instance of this resource definition.
760636
def remove(self, **kwargs):
        
        self.helper.remove(self.inner(), **kwargs)
        self._inner = None
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
155905
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            adapter = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        cpc = adapter.manager.parent
        assert cpc.dpm_enabled
        adapter.manager.remove(adapter.oid)
1065931
def remove(self):
        

        directory = self._directory()
        assert isinstance(directory, Directory)
        directory._fileDeleted(self)
1165594
public void removeInstanceId() {

        Map<String, String> newSettings = new HashMap<String, String>(m_individualSettings);
        newSettings.remove(CmsContainerElement.ELEMENT_INSTANCE_ID);
        m_individualSettings = Collections.unmodifiableMap(newSettings);
        m_editorHash = m_elementId.toString() + getSettingsHash();
    }
1188642
def delete_instance(self, credentials, name, **kwargs):
        """"""
        op_name = delete_instance(
            credentials, self.project, self.zone, name, **kwargs)

        return op_name
529637
public static void removeResource(String pResourceName) throws TTException, ResourceNotExistingException {
        ISession session = getSession(pResourceName);
        session.truncate();
    }
241267
def DeleteInstance(self, si, logger, session, vcenter_data_model, vm_uuid, vm_name):
        
        # find vm
        vm = self.pv_service.find_by_uuid(si, vm_uuid)
        if vm is not None:
            # destroy vm
            result = self.pv_service.destroy_vm(vm=vm, logger=logger)
        else:
            resource___format = "Could not find the VM {0},will remove the resource.".format(vm_name)
            logger.info(resource___format)
            result = resource___format

        return result
227373
private void removeInstance() {
        // unregister client
        ClientRegistry ref = registry.get();
        if (ref != null) {
            ref.removeClient(this);
        } else {
            log.warn("Client registry reference was not accessable, removal failed");
            // TODO: attempt to lookup the registry via the global.clientRegistry
        }
    }
930061
@Override
	public CPDefinitionInventory removeByCPDefinitionId(long CPDefinitionId)
		throws NoSuchCPDefinitionInventoryException {
		CPDefinitionInventory cpDefinitionInventory = findByCPDefinitionId(CPDefinitionId);

		return remove(cpDefinitionInventory);
	}
11131
public static void deleteInstanceResources( Instance instance )	throws IOException {
		File dir = InstanceHelpers.findInstanceDirectoryOnAgent( instance );
		Utils.deleteFilesRecursively( dir );
	}
634545
def remove(id, resource_ids)
      params = {
        id: id,
        resource_ids: resource_ids
      }
      requires params
      DataSift.request(:PUT, 'source/resource/remove', @config, params)
    end
346353
def delete(self):
        
        if self.resource_uri is None:
            raise ValueError("{0} object cannot be deleted because resource_uri attribute cannot be None".format(self._meta.resource_name))

        self._meta.api.http_resource("DELETE", self.resource_uri)
940756
def destroySingleton(cls):
        
        singleton_key = '_{0}__singleton'.format(cls.__name__)
        singleton = getattr(cls, singleton_key, None)
        
        if singleton is not None:
            setattr(cls, singleton_key, None)

            singleton.close()
            singleton.deleteLater()
496683
function destroyInstance() {
  const {
    selection, datum, destroy, index,
  } = getInstance(this);
  selection.selectAll('*').each(destroyDescendant);
  const transition = destroy(selection, datum, index);
  (transition || selection).remove();
}
503746
def remove(cls, resource_id, parent_id=None, grandparent_id=None,
               wait=True, timeout=None):
        """"""
        raise exception.NotSupported(feature="DELETE",
                                     context="VirtualSwitchManager")
931899
def remove_tag(self, resource_type, resource_id, tag, **_params):
        """"""
        return self.delete(self.tag_path % (resource_type, resource_id, tag))