Vocabulary
destructors

Inputs and outputs

disposable

a disposable object

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: accessors destructors generalizations libc ;

M: (free)-destructor dispose alien>> (free) 0 ndrop ;

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

M: 256color dispose drop ;

USING: accessors destructors ecdsa.private generalizations
openssl.libcrypto ;

M: BN_clear_free-destructor dispose
alien>> BN_clear_free 0 ndrop ;

USING: accessors destructors ecdsa.private generalizations
openssl.libcrypto ;

M: EC_POINT_clear_free-destructor dispose
alien>> EC_POINT_clear_free 0 ndrop ;

USING: accessors destructors generalizations graphviz.ffi ;

M: agclose-destructor dispose alien>> agclose 0 ndrop ;

USING: accessors destructors generalizations openal ;

M: alcCloseDevice*-destructor dispose
alien>> alcCloseDevice* 0 ndrop ;

USING: accessors destructors generalizations openal ;

M: alcDestroyContext-destructor dispose
alien>> alcDestroyContext 0 ndrop ;

USING: accessors destructors gpu.buffers kernel opengl ;

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

USING: accessors bunny.model destructors kernel opengl ;

M: bunny-buffers dispose
[ array>> ] [ element-array>> ] bi delete-gl-buffer
delete-gl-buffer ;

USING: accessors bunny.cel-shaded destructors opengl.shaders ;

M: bunny-cel-shaded dispose program>> delete-gl-program ;

USING: accessors bunny.model destructors opengl ;

M: bunny-dlist dispose list>> delete-dlist ;

USING: bunny.fixed-pipeline destructors kernel ;

M: bunny-fixed-pipeline dispose 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 cairo.ffi destructors generalizations ;

M: cairo_destroy-destructor dispose
alien>> cairo_destroy 0 ndrop ;

USING: accessors cairo.ffi destructors generalizations ;

M: cairo_surface_destroy-destructor dispose
alien>> cairo_surface_destroy 0 ndrop ;

USING: accessors cuda.contexts destructors generalizations ;

M: clean-up-context-destructor dispose
alien>> clean-up-context 0 ndrop ;

USING: accessors cuda.gl destructors kernel ;

M: cuda-buffer dispose
[ [ free-resource ] when* f ] change-resource
buffer>> dispose ; inline

USING: accessors cuda.memory destructors generalizations ;

M: cuda-free-destructor dispose alien>> cuda-free 0 ndrop ;

USING: accessors db destructors kernel namespaces ;

M: db-connection dispose
dup db-connection [
[ dispose-statements H{ } clone ]
change-insert-statements
[ dispose-statements H{ } clone ]
change-update-statements
[ dispose-statements H{ } clone ]
change-delete-statements [ db-close f ] change-handle
drop
] with-variable ;

USING: accessors destructors io.encodings ;

M: decoder dispose stream>> dispose ;

USING: accessors cuda.contexts destructors generalizations ;

M: destroy-context-destructor dispose
alien>> destroy-context 0 ndrop ;

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 ecdsa.private kernel
openssl.libcrypto ;

M: ec-key dispose [ EC_KEY_free f ] change-handle drop ;

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: accessors destructors generalizations libc ;

M: free-destructor dispose alien>> free 0 ndrop ;

USING: accessors cuda.gl destructors generalizations ;

M: free-resource-destructor dispose
alien>> free-resource 0 ndrop ;

USING: accessors destructors generalizations glib.ffi ;

M: g_free-destructor dispose alien>> g_free 0 ndrop ;

USING: accessors destructors generalizations gobject.ffi ;

M: g_object_unref-destructor dispose
alien>> g_object_unref 0 ndrop ;

USING: accessors destructors generalizations glib.ffi ;

M: g_source_unref-destructor dispose
alien>> g_source_unref 0 ndrop ;

USING: destructors game.loop ;

M: game-loop dispose stop-loop ;

USING: accessors destructors gdbm.ffi gdbm.private
generalizations ;

M: gdbm-close-destructor dispose alien>> gdbm-close 0 ndrop ;

USING: accessors destructors gdk.ffi generalizations ;

M: gdk_cursor_unref-destructor dispose
alien>> gdk_cursor_unref 0 ndrop ;

USING: accessors destructors generalizations opengl.glu ;

M: gluDeleteNurbsRenderer-destructor dispose
alien>> gluDeleteNurbsRenderer 0 ndrop ;

USING: accessors destructors generalizations opengl.glu ;

M: gluDeleteQuadric-destructor dispose
alien>> gluDeleteQuadric 0 ndrop ;

USING: accessors destructors generalizations opengl.glu ;

M: gluDeleteTess-destructor dispose
alien>> gluDeleteTess 0 ndrop ;

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: accessors destructors generalizations gtk.ffi ;

M: gtk_widget_destroy-destructor dispose
alien>> gtk_widget_destroy 0 ndrop ;

USING: accessors destructors generalizations graphviz.ffi ;

M: gvFreeContext-destructor dispose
alien>> gvFreeContext 0 ndrop ;

USING: destructors html.streams.private ;

M: html-block-stream dispose end-sub-stream format-html-div ;

USING: destructors html.streams.private ;

M: html-span-stream dispose end-sub-stream format-html-span ;

USING: destructors html.streams kernel ;

M: html-writer 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: destructors mongodb.connection ;

M: mdb-connection dispose mdb-close ;

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: destructors kernel ui.gadgets.packs ;

M: pack dispose drop ;

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

M: pane-block-stream dispose unnest-pane-stream write-gadget ;

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

M: pane-cell-stream dispose drop ;

USING: destructors kernel ui.gadgets.panes ;

M: pane-stream dispose drop ;

USING: accessors destructors generalizations pango.ffi ;

M: pango_font_description_free-destructor dispose
alien>> pango_font_description_free 0 ndrop ;

USING: accessors destructors generalizations pango.ffi ;

M: pango_layout_iter_free-destructor dispose
alien>> pango_layout_iter_free 0 ndrop ;

USING: destructors kernel ui.gadgets.paragraphs ;

M: paragraph dispose drop ;

USING: accessors destructors io kernel pdf.streams sequences ;

M: pdf-block-stream dispose
[ data>> ] [ parent>> ] bi
[ data>> push-all ] [ stream-nl ] bi ;

USING: accessors destructors kernel pdf.streams sequences ;

M: pdf-span-stream dispose
[ data>> ] [ parent>> data>> ] bi push-all ;

USING: destructors kernel pdf.streams ;

M: pdf-writer dispose drop ;

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 ] [ out>> dispose ] bi ;

USING: accessors db.postgresql.ffi db.postgresql.lib
destructors ;

M: postgresql-malloc-destructor dispose alien>> PQfreemem ;

USING: accessors db.postgresql db.postgresql.ffi destructors
kernel ;

M: postgresql-result-set dispose
[ handle>> PQclear ] [ 0 >>n 0 >>max f >>handle drop ] bi ;

USING: accessors db.postgresql db.postgresql.ffi destructors
kernel ;

M: postgresql-statement dispose
dup handle>> PQclear f >>handle drop ;

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

M: program-instance dispose
[
dup valid-handle?
[ delete-gl-program-only ] [ 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 alien.handles destructors generalizations ;

M: release-alien-handle-destructor dispose
alien>> release-alien-handle 0 ndrop ;

USING: accessors alien.handles destructors generalizations ;

M: release-alien-handle-ptr-destructor dispose
alien>> release-alien-handle-ptr 0 ndrop ;

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 db.tuples destructors furnace.cache
furnace.scopes kernel ;

M: scope-saver dispose
[ manager>> ] [ scope>> ] bi dup changed?>>
[ [ swap touch-state ] [ update-tuple ] bi ] [ 2drop ] if ;

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

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

USING: accessors db.sqlite destructors kernel ;

M: sqlite-result-set dispose f >>handle drop ;

USING: accessors db.sqlite db.sqlite.ffi db.sqlite.lib
destructors kernel ;

M: sqlite-statement dispose
handle>>
[ [ sqlite3_reset drop ] keep sqlite-finalize ] when* ;

USING: destructors io.streams.string kernel ;

M: string-reader dispose drop ;

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 cuda.gl destructors generalizations ;

M: unmap-resource-destructor dispose
alien>> unmap-resource 0 ndrop ;

USING: accessors destructors furnace.auth
furnace.auth.providers kernel ;

M: user-saver dispose
user>> dup changed?>> [ users update-user ] [ drop ] if ;

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 ;