size<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: size<< ( value object -- )

Methods

USING: accessors compiler.cfg.instructions slots.private ;

M: ##allot size<< 3 set-slot ; inline


USING: accessors compiler.cfg.instructions slots.private ;

M: ##check-nursery-branch size<< 2 set-slot ; inline


USING: accessors compiler.cfg.instructions slots.private ;

M: ##local-allot size<< 3 set-slot ; inline


USING: accessors classes.struct classes.struct.private
core-graphics.types ;

M: CGRect size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 16 }
        { class CGSize }
        { initial S{ CGSize { w 0.0 } { h 0.0 } } }
        { type CGSize }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private glfw.ffi math ;

M: GLFWgammaramp size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 20 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math readline.ffi ;

M: HISTORY_STATE size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 16 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private compression.zstd.ffi math ;

M: ZSTD_inBuffer size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type size_t }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private compression.zstd.ffi math ;

M: ZSTD_outBuffer size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type size_t }
    } write-struct-slot ; inline


USING: accessors alien.c-types kernel math slots slots.private ;

M: abstract-c-type size<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    8 set-slot ; inline


USING: accessors alien.c-types audio.aiff classes.struct
classes.struct.private kernel ;

M: aiff-chunk-header size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 4 }
        { class object }
        { type { char 4 } }
    } write-struct-slot ; inline


USING: accessors audio kernel math slots slots.private ;

M: audio size<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    5 set-slot ; inline


USING: accessors slots.private ui.gadgets.borders ;

M: border size<< 20 set-slot ; inline


USING: accessors bubble-chamber slots.private ;

M: bubble-chamber size<< 22 set-slot ; inline


USING: accessors io.buffers kernel math slots.private ;

M: buffer size<< [ integer>fixnum-strict ] dip 2 set-slot ;
    inline


USING: accessors html.components slots.private ;

M: choice size<< 2 set-slot ; inline


USING: accessors odbc slots.private ;

M: column size<< 4 set-slot ; inline


USING: accessors git slots.private ;

M: copy size<< 3 set-slot ; inline


USING: accessors classes.struct classes.struct.private math vm ;

M: copying-sizes size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


USING: accessors alien.c-types chipmunk.ffi classes.struct
classes.struct.private math ;

M: cpHashSet size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline


USING: accessors cuckoo-filters slots.private ;

M: cuckoo-filter size<< 4 set-slot ; inline


USING: accessors classes.struct classes.struct.private
duckdb.ffi math ;

M: duckdb_blob size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type idx_t }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private
duckdb.ffi math ;

M: duckdb_string size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type idx_t }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private macho math ;

M: fat_arch size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 12 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } write-struct-slot ; inline


USING: accessors html.components slots.private ;

M: field size<< 2 set-slot ; inline


USING: accessors images.bitmap slots.private ;

M: file-header size<< 3 set-slot ; inline


USING: accessors io.files.info slots.private ;

M: file-info-tuple size<< 3 set-slot ; inline


USING: accessors fonts slots.private ;

M: font size<< 3 set-slot ; inline


USING: accessors alien.fortran.private slots.private ;

M: fortran-type size<< 3 set-slot ; inline


USING: accessors id3.private slots.private ;

M: frame size<< 4 set-slot ; inline


USING: accessors graphviz.attributes slots.private ;

M: graph-attributes size<< 81 set-slot ; inline


USING: accessors game-of-life slots.private ;

M: grid-gadget size<< 19 set-slot ; inline


USING: accessors id3.private slots.private ;

M: header size<< 4 set-slot ; inline


USING: accessors compression.huffman.private kernel math
slots.private ;

M: huffman-code size<<
    [ integer>fixnum-strict ] dip 3 set-slot ; inline


USING: accessors openai slots.private ;

M: image-edit size<< 6 set-slot ; inline


USING: accessors openai slots.private ;

M: image-generation size<< 4 set-slot ; inline


USING: accessors openai slots.private ;

M: image-variation size<< 4 set-slot ; inline


USING: accessors git slots.private ;

M: index-entry size<< 9 set-slot ; inline


USING: accessors s3 slots.private ;

M: key size<< 4 set-slot ; inline


USING: accessors slots.private ui.gadgets.layout ;

M: layout size<< 3 set-slot ; inline


USING: accessors classes.struct classes.struct.private math vm ;

M: mark-sweep-sizes size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


USING: accessors kernel math mongodb.driver slots slots.private
;

M: mdb-collection size<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    4 set-slot ; inline


USING: accessors http.client.post-data slots.private ;

M: measured-stream size<< 3 set-slot ; inline


USING: accessors pop3 slots.private ;

M: message size<< 8 set-slot ; inline


USING: accessors multisets slots.private ;

M: multiset size<< 2 set-slot ; inline


USING: accessors html.components slots.private ;

M: password size<< 2 set-slot ; inline


USING: accessors kernel math memory.piles slots slots.private ;

M: pile size<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors ftp.client.listing-parser slots.private ;

M: remote-file size<< 7 set-slot ; inline


USING: accessors alien.c-types audio.wav classes.struct
classes.struct.private kernel ;

M: riff-chunk-header size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 4 }
        { class object }
        { type { char 4 } }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private macho math ;

M: section size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 36 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private macho math ;

M: section_64 size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 40 }
        { class integer }
        { initial 0 }
        { type ulonglong }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private math vm ;

M: segment size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


USING: accessors kernel math.vectors.simd papier.map slots
slots.private ;

M: slab size<<
    [ dup float-4? [ \ float-4 bad-slot-value ] unless ] dip
    6 set-slot ; inline


USING: accessors io.backend.unix slots.private ;

M: stdin size<< 5 set-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private macho math ;

M: symseg_command size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 12 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } write-struct-slot ; inline


USING: accessors slots.private tar ;

M: tar-header size<< 6 set-slot ; inline


USING: accessors classes.struct classes.struct.private math
tools.image.analyzer.vm vm ;

M: tuple-layout size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 24 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math yaml.ffi ;

M: yaml_emitter_output_string size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type size_t }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private math vm ;

M: zone size<<
    T{ struct-slot-spec
        { name "size" }
        { offset 24 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline