<p>
Clears current context store.
</p>
<p>
<p>
This method can't be called only when context was previously set by calling {@link #set(WarpContext)} and that call
wasn't followed by another call to {@link #reset()}.
492538
static void reset() {
        WarpContext context = reference.get();
        Validate.notNull(context, "WarpContext in store can't be null when resetting");
        reference.compareAndSet(context, null);
    }
1015542
@Override
    public void clear() {
        this.root = null;
        this.first = null;
        this.last = null;
        this.size = 0;
        this.modCount++;
    }
320083
public void clear() {
        synchronized (extensions) {    // we synchronize just to guard unnamedMerged
            transformerRegistry = TransformerRegistry.Factory.create();
            extensions.clear();
            reverseMap.clear();
            subsystemsInfo.clear();
        }
    }
192708
protected synchronized void deactivate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Unregistering JNDIEntry " + serviceRegistration);
        }
        if (this.serviceRegistration != null) {
            this.serviceRegistration.unregister();
        }
    }
293241
protected void clear() {
        resource = null;
        resourceResolver = null;
        context = null;
        out = null;
        request = null;
        expressionUtil = null;
    }
82879
def clear_context(self, app=None):
        
        if (app is None and self._context is _CONTEXT_MISSING
                and not in_app_context()):
            raise RuntimeError("Attempted to clear component context without"
                               " a bound app context or eager app set! Please"
                               " pass the related app you want to update the"
                               " context for!")

        if self._context is not _CONTEXT_MISSING:
            self._context = DEFAULT_DICT
        else:
            key = self._get_context_name(app=app)
            setattr(_CONTEXT_LOCALS, key, DEFAULT_DICT)
714132
static void releaseContext(SeaGlassContext context) {
        synchronized (contextMap) {
            List instances = (List) contextMap.get(context.getClass());

            if (instances == null) {
                instances = new ArrayList(5);
                contextMap.put(context.getClass(), instances);
            }

            instances.add(context);
        }
    }
303712
private void clearReset(final OperationContext context) {

        context.getCoordinator().clearStatement(context.getUnit().getId(), "selected.entity");

        Scheduler.get().scheduleDeferred(new Scheduler.ScheduledCommand() {
            @Override
            public void execute() {
                context.getCoordinator().reset();
            }
        });
    }
1058035
synchronized void reset() {

        schemaMap.clear();
        sqlLookup.clear();
        csidMap.clear();
        sessionUseMap.clear();
        useMap.clear();

        next_cs_id = 0;
    }
837514
@Override
    public void destroy(Contextual<?> contextual) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "destroy(Contextual)", new Object[] { contextual, this });

        final Map<String, InstanceAndContext<?>> storage = getStorage(false);

        if (storage != null) {
            final String contextId = getContextualId(contextual);

            InstanceAndContext<?> data = this.getByContextual(storage, contextual);

            if (data != null) {
                storage.remove(contextId);
                destroyItem(contextId, data);
            }
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "destroy(Contextual)");
    }
663817
protected synchronized void deactivate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "Deactivating");
        }

        // Unregister all services that we registered.
        while (!sslOptions.isEmpty()) {
            Iterator<Map.Entry<String, SSLChannelOptions>> i = sslOptions.entrySet().iterator();
            while (i.hasNext()) {
                Map.Entry<String, SSLChannelOptions> entry = i.next();
                entry.getValue().unregister();
                i.remove();
            }
        }
        sslConfigs.deactivate(context);

        cfwBundle.getFramework().deregisterFactories(this);

        bContext = null;

        // clear the instance if we haven't been replaced.
        instance.compareAndSet(this, null);
    }
387969
@Override
    public final void clear() {
        int mc = this.modCount;
        Segment<K, V> segment;
        for (long segmentIndex = 0; segmentIndex >= 0;
             segmentIndex = nextSegmentIndex(segmentIndex, segment)) {
            if (!(segment = segment(segmentIndex)).isEmpty()) {
                segment.clear(this);
                mc++;
                modCount++;
            }
        }
        if (mc != modCount)
            throw new ConcurrentModificationException();
    }
599850
public void clear()
    {
        super.clear();

        if (_jsMap != null)
            _jsMap.clear();

        id = null;
        style = null;
        styleClass = null;
    }
1247655
public void clear() {
    if (cache == null) {
      return;
    }
    synchronized (cache) {
      inFlushAll = true;
      cache.invalidateAll();
      out.clear();
      inFlushAll = false;
    }
  }
933474
@Override
    public void clear() {
        if (emulateIsAbsent)
            lock.writeLock().lock();

        compressedEntries.clear();

        if (emulateIsAbsent)
            lock.writeLock().unlock();
    }
39625
public void clear() {

        if (m_handlerRegistration != null) {
            m_handlerRegistration.removeHandler();
            m_handlerRegistration = null;
        }
        m_validationContext = null;
        m_paused = false;
        m_validating = false;
        if (m_validationTimer != null) {
            m_validationTimer.cancel();
            m_validationTimer = null;
        }
    }
734783
public void resetThreadContextLoader() {
        if (LoaderUtils.isContextLoaderAvailable() && isContextLoaderSaved) {
            LoaderUtils.setContextClassLoader(savedContextLoader);
            savedContextLoader = null;
            isContextLoaderSaved = false;
        }
    }