Deletes the current instance. Override this in a subclass if you want to
        control the deleting process.
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)
365
def delete(self, **params):
        """"""
        d = self.request('delete', self.instance_url(), params)
        return d.addCallback(self.refresh_from).addCallback(lambda _: self)
184644
def delete_object(self, object_name):
        
        self._client.remove_object(self._instance, self.name, object_name)
762128
public function delete_instance() {
        global $DB;
        $grades = $DB->get_records('assign_grades', array('assignment'=>$this->assignment->get_instance()->id), '', 'id');
        if ($grades) {
            list($gradeids, $params) = $DB->get_in_or_equal(array_keys($grades), SQL_PARAMS_NAMED);
            $DB->delete_records_select('assignfeedback_editpdf_annot', 'gradeid ' . $gradeids, $params);
            $DB->delete_records_select('assignfeedback_editpdf_cmnt', 'gradeid ' . $gradeids, $params);
        }
        return true;
    }
914289
def MI_deleteInstance(self,
                          env,
                          instanceName):
        # pylint: disable=invalid-name
        

        logger = env.get_logger()
        logger.log_debug('CIMProvider MI_deleteInstance called...')
        self.delete_instance(env=env, instance_name=instanceName)
        logger.log_debug('CIMProvider MI_deleteInstance returning')
15219
public function sasDeleteInstance()
	{
		$clazz = $this->getCurrentClass();
		$instance = $this->getCurrentInstance();

		$this->setData('label', $instance->getLabel());

		$this->setData('uri', tao_helpers_Uri::encode($instance->getUri()));
		$this->setData('classUri', tao_helpers_Uri::encode($clazz->getUri()));
		$this->setView('sas/delete.tpl', 'tao');
	}
1170339
public function instance_deleted() {
        // We can't use purge here that acts upon a collection.
        // Instead we must drop the named database.
        if (!$this->is_ready()) {
            return;
        }
        $database = $this->connection->selectDatabase($this->databasename);
        $database->drop();
        $connection = null;
        $database = null;
        // Explicitly unset things to cause a close.
        $this->collection = null;
        $this->database = null;
        $this->connection = null;
    }
845282
def delete(self, instance, session):
        ''''''
        if instance._meta.type == 'structure':
            return self._delete_structure(instance)
        inst = self.pop(instance)
        instance = inst if inst is not None else instance
        if instance is not None:
            state = instance.get_state()
            if state.persistent:
                state.deleted = True
                self._deleted[state.iid] = instance
                instance.session = session
            else:
                instance.session = None
            return instance
814343
def delete(self):
        
        counter, counter_dict = 0, {}
        for obj in self:
            result = obj.delete()
            if result is not None:
                current_counter, current_counter_dict = result
                counter += current_counter
                counter_dict.update(current_counter_dict)
        if counter:
            return counter, counter_dict
817084
def delete(self):
        
        _, r = self.machine.datacenter.request('DELETE', self.path)
        r.raise_for_status()
458465
def delete(self):
        

        directory = self._directory()
        assert isinstance(directory, Directory)

        realPath = self.realPath
        assert (os.path.exists(realPath))
        os.remove(realPath)

        directory._fileDeleted(self)
1011757
public function delete()
    {
        if (!$this->isLoaded()) {
            //Nothing to do, do we need an exception here?
            return;
        }

        $this->dispatch('delete', new DocumentEvent($this));

        //Performing deletion
        $this->odm->collection(static::class)->deleteOne(['_id' => $this->primaryKey()]);
        $this->setField('_id', null, false);
        //Done with deletion

        $this->dispatch('deleted', new DocumentEvent($this));
    }
1054418
def delete(self, *args, **kwargs):
        
        return self.session.delete(*args, **self.get_kwargs(**kwargs))
951599
def delete(self):
        
        table_client = self._instance._client.table_admin_client
        table_client.delete_table(name=self.name)
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()
814599
public void delete() {
		if (tx.isReadOnly() && !isTempTable())
			throw new UnsupportedOperationException();

		if (fhp == null)
			fhp = openHeaderForModification();

		// Log that this logical operation starts
		RecordId deletedRid = currentRecordId();
		tx.recoveryMgr().logLogicalStart();

		// Delete the current record
		rp.delete(fhp.getLastDeletedSlot());
		fhp.setLastDeletedSlot(currentRecordId());

		// Log that this logical operation ends
		tx.recoveryMgr().logRecordFileDeletionEnd(ti.tableName(), deletedRid.block().number(), deletedRid.id());

		// Close the header (release the header lock)
		closeHeader();
	}
732050
def delete(self):
        
        if not self.can_delete():
            self._tcex.handle_error(915, [self.type])

        return self.tc_requests.delete(
            self.api_type, self.api_sub_type, self.unique_id, owner=self.owner
        )