Remove the data associated with a resource in a scenario.
        The 'quiet' parameter indicates whether an non-existent RS should throw
        an error.
498952
def delete_resourcedata(scenario_id, resource_scenario, quiet = False, **kwargs):
    

    _check_can_edit_scenario(scenario_id, kwargs['user_id'])

    _delete_resourcescenario(scenario_id, resource_scenario.resource_attr_id, suppress_error=quiet)
371522
def delete(self, data, *args):
        
        path = self.get_resource_name()
        result = self.perform_api_call(self.REST_DELETE, path, data=data)
        return result
601948
def delete_rsrc(rsrc, xml = nil)
      validate_connected
      raise MissingDataError, 'Missing :rsrc' if rsrc.nil?

      # payload?
      return delete_with_payload rsrc, xml if xml

      # delete the resource
      @last_http_response = @cnx[rsrc].delete
    rescue RestClient::ExceptionWithResponse => e
      handle_http_error e
    end
447196
def sanitize_resource_schema(r):
    
    if 'schema' in r.descriptor:
        r.descriptor['schema'] = _sanitize_schema(r.descriptor['schema'])

    return r
1344958
function (data) {
      this.model.unset({silent: true});
      this.model.set(data, {silent: true});
    }
68734
private function cleanUp()
    {
        if ($this->quiet) {
            $errors = explode(PHP_EOL, ob_get_clean());
            $shown = [];

            foreach ($errors as $error) {
                if ($error && !in_array($error, $shown)) {
                    out($error, 'error');
                    $shown[] = $error;
                }
            }
        }

        if (file_exists($this->tmpPharPath)) {
            @unlink($this->tmpPharPath);
        }
        if (file_exists($this->tmpPubkeyPath)) {
            @unlink($this->tmpPharPath);
        }
    }
636354
def delete_if_error(path):
    ''''''
    try:
        yield
    except Exception:
        if os.path.exists(path):
            os.remove(path)
        raise
61575
private void removeRequestUnprotected(ResourceRequest req) {
    Integer requestId = req.getId();
    removeGrantedResourceUnprotected(requestId);
    requestMap.remove(requestId);
  }
227484
def remove(self, safe=None):
        
        self._session.remove(self, safe=None)
        self._session.flush()
811966
public void remove(CmsResource res) {

        remove(res.getStructureId(), res.getRootPath(), res.getTypeId());
    }
917942
def do_rm(self, params):
        
        for path in params.paths:
            try:
                self.client_context.delete(path)
            except NotEmptyError:
                self.show_output("%s is not empty.", path)
            except NoNodeError:
                self.show_output("%s doesn't exist.", path)
101007
def _resource_deletion(resource):
    
    if resource.__class__ not in CostTrackingRegister.registered_resources:
        return
    new_configuration = {}
    price_estimate = models.PriceEstimate.update_resource_estimate(resource, new_configuration)
    price_estimate.init_details()
437749
def destroy(*args)
      resource = find(*args)
      if enclosing_resource
        service.destroy(*args)
        resource
      else
        resource.destroy
      end
    end
639351
async def delete(self, request, resource=None, **kwargs):
        """"""
        if resource is None:
            raise RESTNotFound(reason='Resource not found')
        self.collection.remove(resource)
762945
def _cleanup(self, kill, verbose):
        
        if kill:
            removed_indices = self.g.prune()

            self.nout -= len(removed_indices)

            if verbose and removed_indices:
                print('Removing %s' % removed_indices)

            for j in removed_indices:
                self.inv_map.pop(j[0])
663288
def cleanup_environment():
    
    SERV.terminate()
    shutil.rmtree(TMP_PATH)
    if os.path.exists(TMP_PATH):
        os.rmdir(TMP_PATH)

    global TMP_PATH
    TMP_PATH = None
1217047
function (index, silent) {
		var info = this._ordered_values[index];
		_destroy_info(this._ordered_values.splice(index, 1), silent);
		if(silent !== true) {
			this.$size.invalidate();
		}
	}