APIMethod: destroy
321075
function() {

        //clear out layers info and unregister their events
        this.clearLayersArray("base");
        this.clearLayersArray("data");

        this.map.events.un({
            buttonclick: this.onButtonClick,
            addlayer: this.redraw,
            changelayer: this.redraw,
            removelayer: this.redraw,
            changebaselayer: this.redraw,
            scope: this
        });
        this.events.unregister("buttonclick", this, this.onButtonClick);

        OpenLayers.Control.prototype.destroy.apply(this, arguments);
    }
666599
function destroyAll(callback) {
        targetClass.all(this._scope, function (err, data) {
            if (err) {
                callback(err);
            } else {
                (function loopOfDestruction(data) {
                    if (data.length > 0) {
                        data.shift().destroy(function (err) {
                            if (err && callback)
                                callback(err);
                            loopOfDestruction(data);
                        });
                    } else {
                        if (callback)
                            callback();
                    }
                }(data));
            }
        });
    }
88256
public void destroy() {
        if (mApplicationDepot != null) {
            mLog.info("Destroying ApplicationDepot");
            mApplicationDepot.destroy();
        }
        for (Iterator i = getPlugins().values().iterator(); i.hasNext(); )
            ((Plugin) i.next()).destroy();
    }
451696
function destroy() {
         me.pool.push(this.fillStyle);
         me.pool.push(this.strokeStyle);
         this.fillStyle = this.strokeStyle = undefined;

         this._super(me.Renderable, "destroy");
       }
1023087
public void destroy() {
		// Synchronize, in case multiCadiFilters are used.
		synchronized(CadiHTTPManip.noAdditional) {
			if(--count<=0 && httpChecker!=null) {
				httpChecker.destroy();
				httpChecker=null;
				access=null;
				pathExceptions=null;
			}
		}
	}
704843
function() {
        if(this.options && !this.options.format) {
            this.format.destroy();
        }
        this.format = null;
        OpenLayers.Protocol.prototype.destroy.apply(this);
    }
452716
public void destroy() {
        WaylandClientCore.INSTANCE()
                         .wl_proxy_destroy(this.pointer);
        ObjectCache.remove(this.pointer);
        this.jObjectPointer.close();
    }
1262525
function destroy(self, connections, options, callback) {
  let connectionCount = connections.length;
  function connectionDestroyed() {
    connectionCount--;
    if (connectionCount > 0) {
      return;
    }

    // Zero out all connections
    self.inUseConnections = [];
    self.availableConnections = [];
    self.connectingConnections = 0;

    // Set state to destroyed
    stateTransition(self, DESTROYED);
    if (typeof callback === 'function') {
      callback(null, null);
    }
  }

  if (connectionCount === 0) {
    connectionDestroyed();
    return;
  }

  // Destroy all connections
  connections.forEach(conn => {
    for (var i = 0; i < events.length; i++) {
      conn.removeAllListeners(events[i]);
    }

    conn.destroy(options, connectionDestroyed);
  });
}
74161
public void destroy() {
        for (Entry<String, Runnable> entry : destructionCallbacks.entrySet()) {
            try {
                entry.getValue().run();
            } catch (Throwable t) {
                log.error("Error during destruction callback for bean " + entry.getKey(), t);
            }
        }
        
        beans.clear();
        destructionCallbacks.clear();
    }
74179
public void destroy() {

        final String methodName = "destroy";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        RELOADING_MESSAGING_ENGINES.remove(_messagingEngine.getUuid()
                .toString());

        synchronized (MESSAGING_ENGINES) {

            // Get the set of MEs for this ME's bus
            Set messagingEngines = (Set) MESSAGING_ENGINES.get(_messagingEngine
                    .getBusName());

            // Set should always exist if the engine initialized but
            // just in case...

            if (messagingEngines != null) {

                // Remove the destroyed ME
                messagingEngines.remove(_messagingEngine);

                // If the set is now empty, take it out of the map
                if (messagingEngines.isEmpty()) {

                    MESSAGING_ENGINES.remove(_messagingEngine.getBusName());

                }

            } else {

                if (TRACE.isDebugEnabled()) {
                    SibTr.debug(this, TRACE,
                            "Received destroy for unknown ME:",
                            _messagingEngine);
                }

            }

        }

        // Get listeners to notify
        final Set listeners = getListeners(_messagingEngine.getBusName());

        // Notify listeners
        for (final Iterator iterator = listeners.iterator(); iterator.hasNext();) {

            final SibRaMessagingEngineListener listener = (SibRaMessagingEngineListener) iterator
                    .next();
            listener.messagingEngineDestroyed(_messagingEngine);

        }

        _messagingEngine = null;

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
1009563
function destroy () {
    if (this.connection.destroy) {
      this.connection.destroy()
    } else if (this.connected) {
      this.connection.disconnect('destroy')
    }
    for (var i = 0; i < this.unbind.length; i++) {
      this.unbind[i]()
    }
    clearTimeout(this.pingTimeout)
    this.endTimeout()
  }
181411
async def destroy(self):
        
        app_facade = client.ApplicationFacade.from_connection(self.connection)

        log.debug(
            'Destroying %s', self.name)

        return await app_facade.Destroy(self.name)
754750
function destroy() {
    if (!this.socket) return false;

    this.emit('destroy');

    this.socket.abort();
    this.removeAllListeners();

    this.headers = {};
    this.socket = null;
    this.body = null;

    delete Requests.active[this.id];

    return true;
  }
944661
public void destroy() {

        CmsXmlContentUgcApi.SERVICE.destroySession(m_content.getSessionId(), new AsyncCallback<Void>() {

            public void onFailure(Throwable caught) {

                throw new RuntimeException(caught);

            }

            public void onSuccess(Void result) {

                // do nothing

            }
        });

    }
678717
@SuppressWarnings("rawtypes")
    @Override
    public void destroy() {
        for (List<Handler> handlers : this.handlersMap.values()) {
            for (Handler handler : handlers) {
                try {
                    clientMetaData.getModuleMetaData().getJaxWsInstanceManager().destroyInstance(handler);
                } catch (InterceptException e) {
                    throw new WebServiceException(e);
                }
            }
        }
    }
675706
function destroy() {
         me.pool.push(this.offset);
         this.offset = undefined;
         me.pool.push(this.ratio);
         this.ratio = undefined;

         this._super(me.Renderable, "destroy");
       }
573046
static synchronized void destroy() {
        if (debuggable()) {
            hasInit = false;
            LogisticsCenter.suspend();
            logger.info(Consts.TAG, "ARouter destroy success!");
        } else {
            logger.error(Consts.TAG, "Destroy can be used in debug mode only!");
        }
    }