APIMethod: destroy
487185
function() {
        if (this.map) {
            this.map.events.unregister("buttonclick", this, this.onButtonClick);
        }
        OpenLayers.Control.prototype.destroy.apply(this, arguments);
        for (var ctl, i = this.controls.length - 1; i >= 0; i--) {
            ctl = this.controls[i];
            if (ctl.events) {
                ctl.events.un({
                    activate: this.iconOn,
                    deactivate: this.iconOff
                });
            }
            ctl.panel_div = null;
        }
        this.activeState = null;
    }
1212526
@Override
    public void destroy() {
        //call predestroy
        try {
            webapp.performPreDestroy(wrappedHandler);
        } catch (InjectionException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "destroy  injectionException during preDestroy: ", e);
            }
        }
        wrappedHandler.destroy();
    }
1131483
function destroy(req, res, next) {
  db.posts.del(req.params.post, function(err) {
    if(err) { return next(err); }
    res.json(null);
    signals.emit('post:destroy', req.params.post);
  });
}
1090340
function () {
            // free some property objects
            if (this.renderable) {
                this.renderable.destroy.apply(this.renderable, arguments);
                this.children.splice(0, 1);
            }

            // call the parent destroy method
            this._super(me.Renderable, "destroy", arguments);
        }
100805
@Override
    public void destroy() {

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Destroying ISC: " + this);
        }
        // 291714 - clean up the statemap
        getVC().getStateMap().remove(CallbackIDs.CALLBACK_HTTPISC);
        getVC().getStateMap().remove(HTTP_ERROR_IDENTIFIER);
        this.myLink = null;

        super.destroy();
    }
393059
function destroy(){
    
    // Destroy reactive functions.
    reactiveFunctions.forEach(invoke("destroy"));
    if(configurationReactiveFunction){
      configurationReactiveFunction.destroy();
    }
    
    // Destroy properties (removes listeners).
    Object.keys(model).forEach(function (propertyName){
      var property = model[propertyName];
      if(property.destroy){
        property.destroy();
      }
    });

    // Release references.
    reactiveFunctions = undefined;
    configurationReactiveFunction = undefined;
  }
773976
function() {
        this.url = null;
        this.params = null;
        OpenLayers.Layer.prototype.destroy.apply(this, arguments); 
    }
588305
public synchronized void destroy()
    {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) 
            logger.logp(Level.FINE, CLASS_NAME,"destroy", "entry");

        /*destroying=true;
        
        if (nServicing>0){
        	try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				
			}
        }*/
    	
        super.destroy();

        //parent.removeSubContainer(name);    	//PK37449
    	this.requestMapper = null;
    	this.config = null;
    	this.webApp = null;  // PK25527
        
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled()&&logger.isLoggable (Level.FINE)) 
        	logger.exiting(CLASS_NAME, "destroy");													//569469
    }
102929
function () {
        this.components.length = 0;
        this.components = null;
        OpenLayers.Geometry.prototype.destroy.apply(this, arguments);
    }
91003
def destroy(self):
        
        if not self.id:
            return
        client.delete('/classes/{0}/{1}'.format(self._class_name, self.id), self._flags)
1021401
def destroy(self, request, *args, **kwargs):
        
        obj = self.get_object()
        user = request.user

        if strtobool(request.query_params.get('delete_content', 'false')):
            for data in obj.data.all():
                if user.has_perm('edit_data', data):
                    data.delete()

            # If all data objects in an entity are removed, the entity may
            # have already been removed, so there is no need to call destroy.
            if not Entity.objects.filter(pk=obj.pk).exists():
                return Response(status=status.HTTP_204_NO_CONTENT)

        # NOTE: Collection's ``destroy`` method should be skiped, so we
        # intentionaly call it's parent.
        return super(CollectionViewSet, self).destroy(  # pylint: disable=no-member,bad-super-call
            request, *args, **kwargs
        )
1293535
public void destroy() {
		// Unregister from Hazelcast layer.
		synchronized (getSpaceIDsMutex()) {
			if (this.internalListener != null) {
				this.spaceIDs.removeDMapListener(this.internalListener);
			}
			// Delete the spaces. If this function is called, it
			// means that the spaces seems to have no more participant.
			// The process cannot be done through hazelcast.
			final List<SpaceID> ids = new ArrayList<>(this.spaceIDs.keySet());
			this.spaceIDs.clear();
			for (final SpaceID spaceId : ids) {
				removeLocalSpaceDefinition(spaceId, true);
			}
		}
	}
1314621
public void destroy()
    {
        if (isStarted())
            throw new IllegalStateException("Started");

        if (_components!=null && _eventListeners!=null)
        {
            for (int c=0;c<LazyList.size(_components);c++)
            {
                Object o=LazyList.get(_components,c);
                if (o instanceof HttpContext )
                    ((HttpContext)o).destroy();
                
                ComponentEvent event = new ComponentEvent(this,o);
                for(int i=0;i<LazyList.size(_eventListeners);i++)
                {
                    EventListener listener=(EventListener)LazyList.get(_eventListeners,i);
                    if (listener instanceof ComponentListener)
                        ((ComponentListener)listener).removeComponent(event);
                }
            }
        }
        
        _components=null;
        _eventListeners=null;
    }
169610
public final void destroyRemotely() {
        ClientMessage clientMessage = ClientDestroyProxyCodec.encodeRequest(getDistributedObjectName(), getServiceName());
        try {
            new ClientInvocation(getClient(), clientMessage, getName()).invoke().get();
        } catch (Exception e) {
            throw rethrow(e);
        }
    }
780687
@Override
  public void destroy()
  {
    try {
      close();
    } catch (IOException e) {
    } finally {
      TempBuffer ptr = _head;
    
      _head = null;
      _tail = null;

      TempBuffer.freeAll(ptr);
    }
  }
1299021
protected void destroy() {
        this.nextSequence = null;
        this.prevSequence = null;
        this.bValue = null;
        this.sValue = null;
        this.buffIndex = -1;
        this.offset = 0;
        this.valueLength = 0;
        this.myHashCode = -1;
        this.lastCRLFBufferIndex = -1;
        this.lastCRLFisCR = false;
        this.lastCRLFPosition = -1;
        this.status = ELEM_ADDED;
        this.myOwner.freeElement(this);
    }
1228211
function destroy(publicAPI, model = {}) {
  const previousDestroy = publicAPI.destroy;

  if (!model.subscriptions) {
    model.subscriptions = [];
  }

  publicAPI.destroy = () => {
    if (previousDestroy) {
      previousDestroy();
    }
    while (model.subscriptions && model.subscriptions.length) {
      model.subscriptions.pop().unsubscribe();
    }
    Object.keys(model).forEach((field) => {
      delete model[field];
    });

    // Flag the instance beeing deleted
    model.deleted = true;
  };
}