dispose ( disposable -- )
Factor handbook » The language » Deterministic resource disposal » Using destructors

Next:

with-disposal ( object quot -- )

Vocabulary
destructors

Inputs

disposable

a disposable object

Outputs
None

Generic word contract
Releases operating system resources associated with a disposable object. Disposable objects include streams, memory mapped files, and so on.

No further operations can be performed on a disposable object after this call.

Disposing an object which has already been disposed should have no effect, and in particular it should not fail with an error. To help implement this pattern, inherit from the disposable class and implement the dispose* method instead.

Notes
You must dispose of disposable objects after you are finished working with them, to avoid leaking operating system resources. A convenient way to automate this is by using the with-disposal word.

The default implementation assumes the object has a disposed slot. If the slot is set to f, it calls dispose* and sets the slot to t.

Definition

IN: destructors

GENERIC: dispose ( disposable -- )

Methods

USING: destructors io.streams.256color.private kernel ;

M: 256color dispose drop ;


USING: destructors io.streams.ansi.private kernel ;

M: ansi dispose drop ;


USING: accessors destructors tools.image.analyzer.utils ;

M: backwards-reader dispose stream>> dispose ;


USING: accessors destructors gpu.buffers kernel opengl ;

M: buffer dispose
    [ [ delete-gl-buffer ] when* f ] change-handle drop ;


USING: accessors bunny.outlined destructors kernel
opengl.shaders ;

M: bunny-outlined dispose
    [ pass1-program>> [ delete-gl-program ] when* ]
    [ pass2-program>> [ delete-gl-program ] when* ]
    [ dispose-framebuffer ] tri ;


USING: destructors io.streams.byte-array kernel ;

M: byte-reader dispose drop ;


USING: accessors cache.private destructors ;

M: cache-entry dispose value>> dispose ;


USING: accessors destructors io.streams.counting ;

M: counting-stream dispose stream>> dispose ;


USING: accessors destructors io.crlf ;

M: crlf-stream dispose underlying>> dispose ;


USING: accessors destructors io.encodings ;

M: decoder dispose stream>> dispose ;


USING: accessors destructors discord ;

M: discord-bot-config dispose discord-bot>> dispose ;


USING: destructors destructors.private generic kernel ;

M: disposable dispose
    [
        [ unregister-disposable ]
        [ M\ disposable dispose (call-next-method) ] bi
    ] unless-disposed ;


USING: alien alien.libraries destructors ;

M: dll dispose dlclose ;


USING: destructors io.streams.duplex kernel ;

M: duplex-stream dispose
    [ >duplex-stream< [ &dispose drop ] bi@ ] with-destructors ;


USING: accessors destructors io.encodings ;

M: encoder dispose stream>> dispose ; inline


USING: accessors combinators destructors destructors.private
io.backend.unix io.timeouts kernel unix ;

M: fd dispose
    [
        {
            [ cancel-operation ]
            [ t >>disposed drop ]
            [ unregister-disposable ]
            [ fd>> close-file ]
        } cleave
    ] unless-disposed ;


USING: accessors destructors io.styles ;

M: filter-writer dispose stream>> dispose ;


USING: accessors destructors gpu.framebuffers kernel
opengl.framebuffers ;

M: framebuffer dispose
    [ [ delete-framebuffer ] when* f ] change-handle drop ;


USING: destructors game.loop ;

M: game-loop dispose stop-loop ;


USING: accessors destructors grid-meshes kernel opengl ;

M: grid-mesh dispose
    [ [ delete-gl-buffer ] when* f ] change-buffer drop ;


USING: destructors growable kernel ;

M: growable dispose drop ;


USING: destructors io.styles kernel ;

M: ignore-close-stream dispose drop ;


USING: destructors kernel ui.tools.listener ;

M: interactor dispose drop ;


USING: accessors alien.libraries destructors kernel ;

M: library dispose dll>> [ dispose ] when* ;


USING: accessors destructors io.streams.limited ;

M: limited-stream dispose stream>> dispose ;


USING: audio.engine.test destructors kernel ;

M: noise-generator dispose drop ;


USING: destructors io.streams.null kernel ;

M: null-stream dispose drop ;


USING: accessors destructors kernel ;

M: object dispose [ t >>disposed dispose* ] unless-disposed ;


USING: accessors destructors kernel ui.gadgets.panes
ui.gadgets.panes.private ;

M: pane-stream dispose
    dup parent>>
    [ [ pane>> smash-pane ] dip write-gadget ] [ drop ] if* ;


USING: accessors destructors io.streams.peek ;

M: peek-stream dispose stream>> dispose ;


USING: accessors destructors kernel libc memory.piles ;

M: pile dispose [ [ free ] when* f ] change-underlying drop ;


USING: accessors destructors io.pipes kernel ;

M: pipe dispose
    [ [ in>> &dispose drop ] [ out>> &dispose drop ] bi ]
    with-destructors ;


USING: accessors destructors gpu.shaders gpu.shaders.private
kernel opengl.gl ;

M: program-instance dispose
    [ dup valid-handle? [ glDeleteProgram ] [ drop ] if f ]
    change-handle [ world>> ] [ program>> instances>> ] [ ] tri
    ?delete-at reset-memos ;


USING: destructors io.streams.random kernel ;

M: random-stream dispose drop ;


USING: accessors destructors gpu.framebuffers kernel
opengl.framebuffers ;

M: renderbuffer dispose
    [ [ delete-renderbuffer ] when* f ] change-handle drop ;


USING: accessors destructors io.pools kernel ;

M: return-connection-state dispose
    [ conn>> ] [ pool>> ] bi return-connection ;


USING: accessors destructors gpu.shaders gpu.shaders.private
kernel opengl.gl ;

M: shader-instance dispose
    [ dup valid-handle? [ glDeleteShader ] [ drop ] if f ]
    change-handle [ world>> ] [ shader>> instances>> ] [ ] tri
    ?delete-at ;


USING: destructors io.streams.string kernel ;

M: string-reader dispose drop ;


USING: destructors io.streams.tee io.streams.tee.private kernel
;

M: tee-stream dispose >tee-stream< [ dispose ] bi@ ;


USING: accessors destructors gpu.framebuffers ;

M: texture-attachment dispose texture>> dispose ;


USING: accessors destructors gpu.textures kernel opengl.textures
;

M: texture dispose
    [ [ delete-texture ] when* f ] change-handle drop ;


USING: accessors destructors io.streams.throwing ;

M: throws-on-eof-stream dispose stream>> dispose ;


USING: accessors destructors random.unix ;

M: unix-random dispose reader>> dispose ;


USING: accessors destructors gpu.shaders kernel opengl ;

M: vertex-array-object dispose
    [ [ delete-vertex-array ] when* f ] change-handle drop ;


USING: destructors io.streams.zeros kernel ;

M: zero-stream dispose drop ;