data<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: data<< ( value object -- )

Methods

USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private openssl.libssl ;

M: ASN1_STRING data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class c-ptr }
        { type pointer: uchar }
    } write-struct-slot ; inline


USING: accessors alien.c-types alien.syntax classes.struct
classes.struct.private kernel libclang.ffi ;

M: CXCursor data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class object }
        { type { pointer: void 3 } }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private kernel libclang.ffi ;

M: CXFileUniqueID data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class object }
        { type { ulonglong 3 } }
    } write-struct-slot ; inline


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

M: CXSourceLocation data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private kernel libclang.ffi ;

M: CXString data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


USING: accessors alien.c-types alien.syntax classes.struct
classes.struct.private kernel libclang.ffi ;

M: CXType data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class object }
        { type { pointer: void 2 } }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private
gobject-introspection.standard-types gobject.ffi kernel ;

M: GValue data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class object }
        { type { gpointer 2 } }
    } write-struct-slot ; inline


USING: accessors alien classes.struct classes.struct.private
readline.ffi ;

M: HIST_ENTRY data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class c-ptr }
        { type histdata_t }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private raylib ;

M: Image data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class c-ptr }
        { type pointer: void }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private raylib ;

M: Wave data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class c-ptr }
        { type pointer: void }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private x11.xlib ;

M: XGenericEventCookie data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 48 }
        { class c-ptr }
        { type pointer: void }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private x11.xlib ;

M: XImage data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class c-ptr }
        { type pointer: uchar }
    } write-struct-slot ; inline


USING: accessors furnace.asides slots.private ;

M: aside data<< 7 set-slot ; inline


USING: accessors alien audio kernel slots slots.private ;

M: audio data<<
    [ dup c-ptr? [ \ c-ptr bad-slot-value ] unless ] dip
    6 set-slot ; inline


USING: accessors binhex slots.private ;

M: binhex data<< 6 set-slot ; inline


USING: accessors alien alien.syntax cairo.ffi classes.struct
classes.struct.private ;

M: cairo_path_t data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class c-ptr }
        { type pointer: cairo_path_data_t }
    } write-struct-slot ; inline


USING: accessors google.charts slots.private ;

M: chart data<< 6 set-slot ; inline


USING: accessors continuations slots.private ;

M: continuation data<< 2 set-slot ; inline


USING: accessors assocs couchdb kernel slots slots.private ;

M: couchdb-error data<<
    [ dup assoc? [ \ assoc bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors alien chipmunk.ffi classes.struct
classes.struct.private ;

M: cpBody data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 136 }
        { class c-ptr }
        { type cpDataPointer }
    } write-struct-slot ; inline


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

M: cpCollisionHandler data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 40 }
        { class c-ptr }
        { type pointer: void }
    } write-struct-slot ; inline


USING: accessors alien chipmunk.ffi classes.struct
classes.struct.private ;

M: cpConstraint data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 48 }
        { class c-ptr }
        { type cpDataPointer }
    } write-struct-slot ; inline


USING: accessors alien chipmunk.ffi classes.struct
classes.struct.private ;

M: cpShape data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 88 }
        { class c-ptr }
        { type cpDataPointer }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private duckdb.ffi ;

M: duckdb_blob data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class c-ptr }
        { type pointer: void }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private duckdb.ffi ;

M: duckdb_string data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class c-ptr }
        { type pointer: char }
    } write-struct-slot ; inline


USING: accessors ping.private slots.private ;

M: echo data<< 5 set-slot ; inline


USING: accessors slots.private yaml.private ;

M: factor_yaml_event_t data<< 3 set-slot ; inline


USING: accessors macho slots.private ;

M: fat-binary-member data<< 4 set-slot ; inline


USING: accessors id3.private slots.private ;

M: frame data<< 5 set-slot ; inline


USING: accessors heaps.private kernel slots slots.private
vectors ;

M: heap data<<
    [ dup vector? [ \ vector bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors html.streams slots.private ;

M: html-writer data<< 4 set-slot ; inline


USING: accessors images.png slots.private ;

M: icc-profile data<< 3 set-slot ; inline


USING: accessors kernel slots slots.private tools.image ;

M: image data<<
    [ dup bytes? [ \ bytes bad-slot-value ] unless ] dip
    5 set-slot ; inline


USING: accessors images.jpeg.private slots.private ;

M: jpeg-chunk data<< 4 set-slot ; inline


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

M: kevent data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class integer }
        { initial 0 }
        { type long }
    } write-struct-slot ; inline


USING: accessors slots.private ui.gadgets.charts.lines ;

M: line data<< 19 set-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private gobject-introspection.standard-types
kernel ;

M: longdouble data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class object }
        { type { char 10 } }
    } write-struct-slot ; inline


USING: accessors concurrency.mailboxes dlists kernel slots
slots.private ;

M: mailbox data<<
    [ dup dlist? [ \ dlist bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors slots.private synth.buffers ;

M: mono-buffer data<< 5 set-slot ; inline


USING: accessors arrays kernel slots slots.private
unrolled-lists.private ;

M: node data<<
    [ dup array? [ \ array bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private ogg ;

M: ogg-sync-state data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 0 }
        { class c-ptr }
        { type pointer: uchar }
    } write-struct-slot ; inline


USING: accessors reddit.private slots.private ;

M: page data<< 3 set-slot ; inline


USING: accessors pdf.streams slots.private ;

M: pdf-writer data<< 4 set-slot ; inline


USING: accessors images.png slots.private ;

M: png-chunk data<< 3 set-slot ; inline


USING: accessors http slots.private ;

M: post-data data<< 2 set-slot ; inline


USING: accessors concurrency.messaging slots.private ;

M: reply data<< 2 set-slot ; inline


USING: accessors http slots.private ;

M: request data<< 7 set-slot ; inline


USING: accessors s3.private slots.private ;

M: s3-request data<< 8 set-slot ; inline


USING: accessors elf slots.private ;

M: section data<< 5 set-slot ; inline


USING: accessors elf slots.private ;

M: segment data<< 4 set-slot ; inline


USING: accessors game.models.collada.private slots.private ;

M: source data<< 4 set-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private openssl.libssl ;

M: stack_st data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class c-ptr }
        { type pointer: pointer: char }
    } write-struct-slot ; inline


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

M: stdin data<< 6 set-slot ; inline


USING: accessors elf slots.private ;

M: symbol data<< 5 set-slot ; inline


USING: accessors concurrency.messaging slots.private ;

M: synchronous data<< 2 set-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private ogg.theora ;

M: th-img-plane data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class c-ptr }
        { type pointer: uchar }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private yaml.ffi
;

M: yaml_event_t data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class event_data }
        { initial
            S{ event_data
                { stream_start
                    S{ stream_start_event_data
                        { encoding YAML_ANY_ENCODING }
                    }
                }
                { document_start
                    S{ document_start_event_data
                        { version_directive f }
                        { tag_directives
                            ~tag_directives_document_start_event_data~
                        }
                        { implicit 0 }
                    }
                }
                { document_end
                    S{ document_end_event_data { implicit 0 } }
                }
                { alias S{ alias_event_data { anchor f } } }
                { scalar
                    S{ scalar_event_data
                        { anchor f }
                        { tag f }
                        { value f }
                        { length 0 }
                        { plain_implicit 0 }
                        { quoted_implicit 0 }
                        { style YAML_ANY_SCALAR_STYLE }
                    }
                }
                { sequence_start
                    S{ sequence_start_event_data
                        { anchor f }
                        { tag f }
                        { implicit 0 }
                        { style YAML_ANY_SEQUENCE_STYLE }
                    }
                }
                { mapping_start
                    S{ mapping_start_event_data
                        { anchor f }
                        { tag f }
                        { implicit 0 }
                        { style YAML_ANY_MAPPING_STYLE }
                    }
                }
            }
        }
        { type event_data }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private yaml.ffi
;

M: yaml_node_t data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 16 }
        { class node_data }
        { initial
            S{ node_data
                { scalar
                    S{ scalar_node_data
                        { value f }
                        { length 0 }
                        { style YAML_ANY_SCALAR_STYLE }
                    }
                }
                { sequence
                    S{ sequence_node_data
                        { items ~sequence_node_data_items~ }
                        { style YAML_ANY_SEQUENCE_STYLE }
                    }
                }
                { mapping
                    S{ mapping_node_data
                        { pairs ~mapping_node_data_pairs~ }
                        { style YAML_ANY_MAPPING_STYLE }
                    }
                }
            }
        }
        { type node_data }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private yaml.ffi
;

M: yaml_token_t data<<
    T{ struct-slot-spec
        { name "data" }
        { offset 8 }
        { class token_data }
        { initial
            S{ token_data
                { stream_start
                    S{ stream_start_token_data
                        { encoding YAML_ANY_ENCODING }
                    }
                }
                { alias S{ alias_token_data { value f } } }
                { anchor S{ anchor_token_data { value f } } }
                { tag
                    S{ tag_token_data
                        { handle f }
                        { suffix f }
                    }
                }
                { scalar
                    S{ scalar_token_data
                        { value f }
                        { length 0 }
                        { style YAML_ANY_SCALAR_STYLE }
                    }
                }
                { version_directive
                    S{ version_directive_token_data
                        { major 0 }
                        { minor 0 }
                    }
                }
            }
        }
        { type token_data }
    } write-struct-slot ; inline