Destroy the image and release any native resources.
Calls on a destroyed image have undefined results
424900
public void destroy() throws SlickException {
		for (int tx=0;tx<xcount;tx++) {
			for (int ty=0;ty<ycount;ty++) {
				Image image = images[tx][ty];
				image.destroy();
			}
		}
	}
1220570
def destroy(self):
        
        try:
            self.lock()
            _logger.debug("Unlocked connection %r to close.", self.container_id)
            self._close()
        finally:
            self.release()
        uamqp._Platform.deinitialize()
194426
function () {
		var wrapper = this;

		if (wrapper.destroyClip) {
			wrapper.destroyClip();
		}

		return SVGElement.prototype.destroy.apply(wrapper);
	}
530944
def image_delete(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.delete_image(**kwargs)
1110969
def destroy(options={}, &block)
      object = resource
      options[:location] ||= smart_collection_url

      destroy_resource(object)
      respond_with_dual_blocks(object, options, &block)
    end
1311027
@Override
    public final void destroy()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "destroy", new Object[] { _resource, _xid });

        if (!_completed)
        {
            // If we created an XAResource by reconnectRM we need to destroy it
            if (_recoveredRM != null)
            {
                _recoveredRM.closeConnection();
                _recoveredRM = null;
                if (_recovery)
                {
                    if (_recoveryData != null)
                        _recoveryData.decrementCount();
                }
            }
            _completed = true;
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "destroy");
    }
1017105
def destroy
      self.resource = destroy_resource
      respond_to do |format|
        format.html { redirect_to resources_url, notice: "#{resource_name.humanize} was successfully destroyed." }
        format.js
        format.json { head :no_content }
      end
    end
451696
function destroy() {
         me.pool.push(this.fillStyle);
         me.pool.push(this.strokeStyle);
         this.fillStyle = this.strokeStyle = undefined;

         this._super(me.Renderable, "destroy");
       }
674008
function destroy() {
         me.pool.push(this.fontScale);
         this.fontScale = undefined;
         me.pool.push(this.fontData);
         this.fontData = undefined;

         this._super(me.Renderable, "destroy");
       }
417645
def destroy(options = {}, &block)
      object = get_resource_ivar || find_resource

      object.destroy
      options[:location] = collection_path

      respond_with(object, options, &block)
    end
992347
function() {

		var name;

		this._fire('destroy');

		Lava.view_manager.unregisterView(this);

		if (this._container) this._container.destroy();

		for (name in this._property_bindings_by_property) {

			this._property_bindings_by_property[name].destroy();

		}

		for (name in this._data_segments) {

			this._data_segments[name].destroy();

		}

		this._is_inDOM = false; // to prevent refresh

	}
1220754
def remove_image(self, image, **kwargs):
        
        self.push_log("Removing image '{0}'.".format(image))
        set_raise_on_error(kwargs)
        super(DockerFabricClient, self).remove_image(image, **kwargs)
798194
public void destroy() {
        if (inputStream != null)
        {
            try
            {
                inputStream.close();
            } catch (Throwable t)
            {
                LOG.warn("Error closing input stream", t);
            }
            inputStream = null;
        }
        if (outputStream != null)
        {
            try
            {
                outputStream.close();
            } catch (Throwable t)
            {
                LOG.warn("Error closing output stream", t);
            }
            outputStream = null;
        }
        if (errorStream != null)
        {
            try
            {
                errorStream.close();
            } catch (Throwable t)
            {
                LOG.warn("Error closing error stream", t);
            }
            errorStream = null;
        }
        if (ffmpeg != null)
        {
            ffmpeg.destroy();
            ffmpeg = null;
        }
        if (ffmpegKiller != null)
        {
            Runtime runtime = Runtime.getRuntime();
            runtime.removeShutdownHook(ffmpegKiller);
            ffmpegKiller = null;
        }
    }
91003
def destroy(self):
        
        if not self.id:
            return
        client.delete('/classes/{0}/{1}'.format(self._class_name, self.id), self._flags)
346353
def delete(self):
        
        if self.resource_uri is None:
            raise ValueError("{0} object cannot be deleted because resource_uri attribute cannot be None".format(self._meta.resource_name))

        self._meta.api.http_resource("DELETE", self.resource_uri)
342757
public function destroyAll()
    {
        if ($this->newImage)
        {
            $this->destroy($this->newImage);
        }

        if ($this->sourceImage)
        {
            $this->destroy($this->sourceImage);
        }
    }
59274
def destroy(self, request, pk=None):
        ''''''
        org = self.get_object()
        org.archived = True
        org.save()
        return Response(status=status.HTTP_204_NO_CONTENT)