Remove resource.
		
		:param resort.engine.execution.Context context:
		   Current execution context.
962286
def delete(self, context):
	
		
		
		encoded_name = urllib.parse.quote_plus(self.__name)
		status_code, msg = self.__endpoint.delete(
			"/resources/custom-resource/{}".format(encoded_name)
		)
		self.__available = False
902231
def delete(context, resource, id, **kwargs):
    """"""

    etag = kwargs.pop('etag', None)
    id = id
    subresource = kwargs.pop('subresource', None)
    subresource_id = kwargs.pop('subresource_id', None)

    uri = '%s/%s/%s' % (context.dci_cs_api, resource, id)
    if subresource:
        uri = '%s/%s/%s' % (uri, subresource, subresource_id)

    r = context.session.delete(uri, timeout=HTTP_TIMEOUT,
                               headers={'If-match': etag})
    return r
806826
protected void deactivate(ComponentContext context) {
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(this, tc, "deactivate");

        lock.writeLock().lock();
        try {
            if (isInitialized) {
                if (classloader != null) {
                    if (isDerbyEmbedded.get())
                        shutdownDerbyEmbedded();
                    classloader = null;
                }
                for (Iterator<Class<? extends CommonDataSource>> it = introspectedClasses.iterator(); it.hasNext(); it.remove())
                    Introspector.flushFromCaches(it.next());
                isInitialized = false;
            }
        } finally {
            lock.writeLock().unlock();
        }

        if (trace && tc.isEntryEnabled())
            Tr.exit(this, tc, "deactivate");
    }
491878
public void unsetResourceAdaptorContext() {
		this.raContext = null;
		this.tracer = null;
		this.sleeEndpoint = null;
		this.eventLookupFacility = null;
		this.sbbInterface = null;		
	}
1285120
def purge(context, resource, **kwargs):
    """"""
    uri = '%s/%s/purge' % (context.dci_cs_api, resource)
    if 'force' in kwargs and kwargs['force']:
        r = context.session.post(uri, timeout=HTTP_TIMEOUT)
    else:
        r = context.session.get(uri, timeout=HTTP_TIMEOUT)
    return r
50554
public static void remove(String key) {
        if (setContext()) {
            m_context.remove(key);
        } else {
            m_defaultContext.remove(key);
        }
    }
986754
public void contextDestroyed(ServletContextEvent sce)
    {
        synchronized (Publisher.class)
        {
            if (Publisher.worker != null)
            {
                Publisher.worker.interrupt();
            }
        }
    }
1277744
private synchronized void removeContext(final EvaluatorContext context) {
    this.contextStack.remove(context);
    this.contextIds.remove(context.getId());
  }
415505
@Override
    public void remove(Resource subject, URI predicate, Value object, Resource... contexts) throws RepositoryException {
        getClient().sendRemove(null, subject, predicate, object, contexts);
    }
1197406
private static void cleanup(ContextFromVertx context) {
        // Release all resources, especially uploaded file.
        if (context != null) {
            context.cleanup();
        }
        Context.CONTEXT.remove();
    }
1350715
@Deactivate
    protected void deactivate(ComponentContext context) {
        SibTr.entry(tc, CLASS_NAME + "deactivate", context);

        runtimeSecurityService.modifyMessagingServices(null);
        queuePermissions = null;
        topicPermissions = null;
        temporaryDestinationPermissions = null;
        sibAuthenticationService = null;
        sibAuthorizationService = null;
        this.bundleLocation = null;
        
        SibTr.exit(tc, CLASS_NAME + "deactivate");
    }
78402
def clear(self, context=None):
        
        context = URIRef(context).n3() if context is not None else '?g'
        query = """
            DELETE { GRAPH %s { ?s ?p ?o } } WHERE { GRAPH %s { ?s ?p ?o } }
        """ % (context, context)
        self.parent.graph.update(query)
171918
@Override
    public void stop(StopContext context) {
        Runnable asyncStop = () -> {
            synchronized (stopLock) {
                controlledProcessStateServiceSupplier.get().removePropertyChangeListener(propertyChangeListener);
                SuspendController controller = suspendControllerSupplier != null ? suspendControllerSupplier.get() : null;
                if (controller != null) {
                    controller.removeListener(operationListener);
                }
                runningState = null;
                try {
                    listener.cleanup();
                } catch (RuntimeException t) {
                    CoreManagementLogger.ROOT_LOGGER.processStateCleanupError(t, name);
                } finally {
                    context.complete();
                }
            }
        };
        final ExecutorService executorService = executorServiceSupplier.get();
        try {
            try {
                executorService.execute(asyncStop);
            } catch (RejectedExecutionException e) {
                asyncStop.run();
            }
        } finally {
            context.asynchronous();
        }
    }
1143508
def delete(self, **params):
        
        self.clear()
        self._context = None
        self._set_value(self._default_value())
        self.bucket._client.delete(self, **params)
        return self
725529
@Deactivate
    protected void deactivate(ComponentContext context) {
        lock.writeLock().lock();
        try {
            componentContext = null;
            properties = null;
            threadContextConfigurations = null;
        } finally {
            lock.writeLock().unlock();
        }
    }
206527
private void removeResource(FacesContext context, UIComponent resource, UIViewRoot view) {
        view.removeComponentResource(context, resource, HEAD);
        view.removeComponentResource(context, resource, TARGET);
    }
200682
public static void clearContextPath ()
  {
    if (s_sServletContextPath != null)
    {
      if (LOGGER.isInfoEnabled () && !isSilentMode ())
        LOGGER.info ("The servlet context path '" + s_sServletContextPath + "' was cleared!");
      s_sServletContextPath = null;
    }
    if (s_sCustomContextPath != null)
    {
      if (LOGGER.isInfoEnabled () && !isSilentMode ())
        LOGGER.info ("The custom servlet context path '" + s_sCustomContextPath + "' was cleared!");
      s_sCustomContextPath = null;
    }
  }