Deactivates the MDB
763979
@Override
    void deactivate()
    {
        final String methodName = "deactivate";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
            SibTr.entry(this, TRACE, methodName);
        }

        clearTimer();

        super.deactivate();

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
            SibTr.exit(this, TRACE, methodName);
        }
    }
1331363
protected void deactivate(ComponentContext context) {
        appListener.unregister(this);

        // shut down instances that were created
        if (!clients.isEmpty())
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    Method shutdown = null;
                    for (Object client : clients.values())
                        try {
                            if (shutdown == null)
                                shutdown = client.getClass().getMethod("shutdown");
                            shutdown.invoke(client);
                        } catch (Throwable x) {
                            // FFDC will be logged, otherwise ignore
                        }
                    return null;
                }
            });

        containerAuthDataRef.deactivate(context);
        sslConfig.deactivate(context);
    }
955538
public void free()
    {
        this.setPDatabaseParent(null); // Remove from database
        
        Object[] keys = m_htTableList.keySet().toArray();
        for (int i = 0; i < keys.length; i++)
        { 
            Object key = keys[i];
            PTable pTable = m_htTableList.get(key);
            if (pTable != null)
                pTable.free();      // This can be dangerous if the PhysicalTables still have references to the PTables
        } 
        m_htTableList.clear();
        m_htTableList = null;
        this.close();
    }
941507
public synchronized void deactivate() {
        // Allow garbage collection of all slots reserved by this component.
        // Clean up all the metadata used by the slots.
        for (MetaDataSlotImpl slot : slots) {
            MetaDataManager<?, ?> manager = (MetaDataManager<?, ?>) slot.getManager();
            manager.destroyMetaDataSlot(slot);
        }
        slots = null;
    }
868187
synchronized void deactivate() throws Exception {
        this.proxyActivator.deactivate();
        this.instrumentation.removeTransformer(this.classAvailableTransformer);
        this.instrumentation.removeTransformer(this.transformer);
        this.shuttingDown = true;

        // Save the classes that have listeners so we can retransform
        Collection<Class<?>> probedClasses = processRemovedListeners(allRegisteredListeners);

        // Clear all data structures
        listenersLock.writeLock().lock();
        try {
            listenersForMonitor.clear();
            allRegisteredListeners.clear();
        } finally {
            listenersLock.writeLock().unlock();
        }
        activeProbesById.clear();
        listenersByProbe.clear();
        listenersByClass.clear();
        probesByKey.clear();
        probesByListener.clear();

        this.proxyActivator = null;
        this.transformer = null;
        this.componentContext = null;

        // Retransform the probed classes without our transformers in play
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "deactivate: probedClasses.size() = " + probedClasses.size());
        }
        for (Class<?> clazz : probedClasses) {
            instrumentation.retransformClasses(clazz);
        }
        this.instrumentation = null;
    }
116844
def deactivate(self, request, queryset):
        
        selected_cats = self.model.objects.filter(
            pk__in=[int(x) for x in request.POST.getlist('_selected_action')])

        for item in selected_cats:
            if item.active:
                item.active = False
                item.save()
                item.children.all().update(active=False)
635745
protected void deactivate(ComponentContext context) throws Exception {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "MongoService deactivate");
        }

        try {
            closeMongoClient();
            if (sslHelper != null) {
                sslHelper.removeChangeListener(this);
            }
        } finally {
            libraryRef.deactivate(context);
            sslConfigurationRef.deactivate(context);
            keyStoreServiceRef.deactivate(context);
        }
    }
537652
public void free()
    {
        int iOldEditMode = 0;
        if (m_record != null) // First, release the record for this table
        {
            iOldEditMode = this.getRecord().getEditMode();
            this.getRecord().setEditMode(iOldEditMode | DBConstants.EDIT_CLOSE_IN_FREE);    // This is a cludge... signals tables that this is the last close()!
        }
        this.close();
        if (m_record != null) // First, release the record for this table
            this.getRecord().setEditMode(iOldEditMode);   // This is a cludge... signals tables that this is the last close()!

        super.free(); // Set the record's table reference to null.

        if (m_database != null)
            m_database.removeTable(this);
        m_database = null;
        m_dataSource = null;
        m_objectID = null;
    }
877025
protected void deactivate(ComponentContext context) {
        deactivated = true;
        if (mbean != null)
            mbean.unregister();
        if (taskStore != null)
            DatabaseTaskStore.unget(persistentStore);
        appTrackerRef.deactivate(context);
        contextSvcRef.deactivate(context);
        controllerRef.deactivate(context);
        localTranCurrentRef.deactivate(context);
        serializationSvcRef.deactivate(context);
        tranMgrRef.deactivate(context);

    }
196873
def drop(self):
        
        api = self._instance._client.database_admin_api
        metadata = _metadata_with_prefix(self.name)
        api.drop_database(self.name, metadata=metadata)
66797
@Deactivate
    protected void deactivate(ComponentContext context, Map<String, Object> props) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "MongoDBService deactivate: jndiName=" + props.get(JNDI_NAME) + ", database=" + props.get(DATABASE_NAME));

        mongo.unregisterChangeListener(this);
        cctx.set(null);
    }
331360
@Deactivate
    protected void deactivate(int reason) {
        final String methodName = "deactivate";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, "Entry Count: " + ++JDBCMBeanRuntime.counterDeactivate);
        if (trace && tc.isEventEnabled())
            Tr.event(tc, className + methodName + ", reason=" + reason);
        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, "Normal Exit");
    }
1116490
public void deactivated()
	{
		// remove EOF submissions
		IPageSite site = fPage.getSite();
		IHandlerService handlerService = (IHandlerService) site.getService(IHandlerService.class);
		IContextService contextService = (IContextService) site.getService(IContextService.class);
		handlerService.deactivateHandler(fActivatedHandler);
		contextService.deactivateContext(fActivatedContext);
		fActivatedContext = null;
		fActivatedHandler = null;
	}
9624
def deactivate(self):
        

        raise foundations.exceptions.ProgrammingError(
            "{0} | '{1}' Component cannot be deactivated!".format(self.__class__.__name__, self.__name))
132928
def deactivate(self):
        
        self.ide.project.sigProjectChanged.disconnect(self.__collectGarbage)
        self.ide.editorsManager.sigTabClosed.disconnect(self.__collectGarbage)

        WizardInterface.deactivate(self)
1228788
public void disable() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "disable chain " + this);
        }
        enabled = false;
    }
88655
public void free()
    {
        super.free(); // Do any inherited
        if (m_pDatabase != null)
        {
            this.close();
            m_pDatabase.removePDatabaseOwner(this, true);
        }
        m_pDatabase = null;
    }