Cleans up the TCCL instance. Once called, this TCCL is effectively disabled.
It's associated gateway bundle will have been removed.
14010
private void cleanup() {
        final String methodName = "cleanup(): ";
        try {
            final Bundle b = bundle.getAndSet(null);
            if (b != null) {
                if (tc.isDebugEnabled()) {
                    Tr.debug(tc, methodName + "Uninstalling bundle location: " + b.getLocation() + ", bundle id: " + b.getBundleId());
                }
                SecurityManager sm = System.getSecurityManager();
                if (sm != null) {
                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
                        @Override
                        public Void run() {
                            try {
                                b.uninstall();
                                return null;
                            } catch (BundleException ignored) {
                                return null;
                            }
                        }
                    });
                } else {
                    b.uninstall();
                }
            }
        } catch (BundleException ignored) {
        } catch (IllegalStateException ignored) {

        }
    }
1231680
public void cleanUpState(VirtualConnection vc) {
        // if discrimination returned MAYBE, then we stored a link object that
        // now needs to be cleaned up
        HttpInboundLink link = (HttpInboundLink) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPICL);
        if (null != link) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Performing cleanup after discrim MAYBE");
            }
            link.destroy(null);
        }
    }
1164743
public function cleanSession()
    {
        // remove checkout session parameters
        $this->session->remove('select-delivery');
        $this->session->remove('delivery-id');
        $this->session->remove('existing-delivery-address');
        $this->session->remove('transaction-id');

        // abandon cart
        $this->cartProvider->abandonCart();
    }
74872
public function cleanup() {
		foreach ( $this->_factories as $factory ) {
			if ( $factory instanceof \WPCC\Component\Factory ) {
				$factory->deleteAll();
			}
		}
	}
1292604
public void cleanup() {
        cleanupLock.lock();
        try {
            // Clean up the write interface.
            if (null != writeInterface) {
                this.writeInterface.close();
                this.writeInterface = null;
            }
            // Clean up the read interface.
            if (null != readInterface) {
                this.readInterface.close();
                this.readInterface = null;
            }
            // Clean up the SSL engine.
            if (null != getSSLEngine()) {
                //If the channel has already processed the stop signal, it is too late to try and send the write handshake
                if (this.sslChannel.getstop0Called() == true) {
                    this.connected = false;
                }

                SSLUtils.shutDownSSLEngine(this, isInbound, this.connected);

                this.sslEngine = null;
            }
            // mark that we have disconnected
            this.connected = false;
        } finally {
            cleanupLock.unlock();
        }
    }
822064
public void removeAllTopicAcls()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "removeAllTopicAcls");

    ArrayList topicAclList = null;

    try
    {
      // Remove from the HashMap, with synch, there may be other accessors
      synchronized(_targets)
      {
        // Build a list of the existing ACLs
        topicAclList = new ArrayList(_targets.size());

        Iterator itr = _targets.keySet().iterator();

        while (itr.hasNext())
        {
          Object key = itr.next();
          if (key instanceof TopicAcl)
          {
            topicAclList.add(key);
          }
        }

        // Now remove the ACLs from the targets Map
        Iterator aclIter = topicAclList.iterator();

        while (aclIter.hasNext())
        {
          Object key = aclIter.next();
          removeTarget(key);
        }
      }
    }
    catch (MatchingException e)
     {
       FFDCFilter.processException(
         e,
         "com.ibm.ws.sib.processor.matching.MessageProcessorMatching.removeAllTopicAcls",
         "1:2188:1.117.1.11",
         this);

       SibTr.exception(tc, e);

       if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
         SibTr.exit(tc, "removeAllTopicAcls", "SICoreException");

       SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
         new Object[] {
           "com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
           "1:2199:1.117.1.11",
           e });

       throw new SIErrorException(
         nls.getFormattedMessage(
           "INTERNAL_MESSAGING_ERROR_CWSIP0002",
           new Object[] {
             "com.ibm.ws.sib.processor.matching.MessageProcessorMatching",
             "1:2207:1.117.1.11",
             e },
           null),
         e);
     }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeAllTopicAcls");

  }
1229632
@Override
    @Trivial
    public void cleanUpState(VirtualConnection vc) {
        vc.getStateMap().remove(HttpDispatcherLink.LINK_ID);
    }
1226052
public function clear()
    {
        unset($this->cc);
        unset($this->bcc);
        unset($this->receivers);
        unset($this->attachments);
        unset($this->contentHTML);
        unset($this->contentPlain);
    }
227484
def remove(self, safe=None):
        
        self._session.remove(self, safe=None)
        self._session.flush()
171727
def remove(self, component):
        # type: (str) -> None
        
        with self.__lock:
            # Find its factory
            factory = self.__names.pop(component)
            components = self.__queue[factory]

            # Clear the queue
            del components[component]
            if not components:
                # No more component for this factory
                del self.__queue[factory]

            # Kill the component
            try:
                with use_ipopo(self.__context) as ipopo:
                    # Try to instantiate the component right now
                    ipopo.kill(component)
            except (BundleException, ValueError):
                # iPOPO not yet started or component not instantiated
                pass
1242009
def _cleanup(self):
        
        for channel in self._open_channels:
            try:
                self.disconnect_channel(channel)
            except Exception:  # pylint: disable=broad-except
                pass

        for handler in self._handlers.values():
            try:
                handler.tear_down()
            except Exception:  # pylint: disable=broad-except
                pass

        try:
            self.socket.close()
        except Exception:  # pylint: disable=broad-except
            self.logger.exception(
                "[%s:%s] _cleanup", self.fn or self.host, self.port)
        self._report_connection_status(
            ConnectionStatus(CONNECTION_STATUS_DISCONNECTED,
                             NetworkAddress(self.host, self.port)))
        self.connecting = True
573367
void handleStop(Bundle bundle) {
        if (bundle == null) {
            throw new IllegalArgumentException("Method argument bundle must not be null.");
        }

        this.logger.info("Removing infrastructure for bundle: " + bundle + "...");
            this.modelRegistrar.unregister(bundle);
            this.dispatcherServlet.disableMvc(bundle);

        this.logger.info("Infrastructure for {} removed.", bundle);
    }
1129613
public void destroy() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "destroy");
        }

        // Go through the hashtable and destroy all long-lived, single instance,
        // resources related to a given TCP Channel type (NIO, AIO, etc...)
        for (ChannelTermination ct : this.terminationList.values()) {
            ct.terminate();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "destroy");
        }
    }
449018
public void removeComponent (BaseComponent comp)
    {
        if (_initers != null && comp instanceof InitComponent) {
            _initers.remove((InitComponent)comp);
        }
        if (_downers != null  && comp instanceof ShutdownComponent) {
            _downers.remove((ShutdownComponent)comp);
        }
    }
1228788
public void disable() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "disable chain " + this);
        }
        enabled = false;
    }
789471
def clean_system(self):
        
        self.run('systemctl disable NetworkManager', success_status=(0, 1))
        self.run('systemctl stop NetworkManager', success_status=(0, 5))
        self.run('pkill -9 dhclient', success_status=(0, 1))
        self.yum_remove(['cloud-init', 'NetworkManager'])
        self.run('systemctl enable network')
        self.run('systemctl restart network')
1260127
def _cleanup(self):
        '''
        
        '''
        self._declare_cb = None
        self._bind_cb = None
        self._unbind_cb = None
        self._delete_cb = None
        self._purge_cb = None
        super(QueueClass, self)._cleanup()