header<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: header<< ( value object -- )

Methods

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

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


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

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


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

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


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

M: boxed-float header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


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

M: boxed-float header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


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

M: byte-array header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


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

M: byte-array header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


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

M: cairo_path_data_t header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class cairo_path_data_t-header }
        { initial
            S{ cairo_path_data_t-header
                { type CAIRO_PATH_MOVE_TO }
                { length 0 }
            }
        }
        { type cairo_path_data_t-header }
    } write-struct-slot ; inline


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

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


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

M: code-block header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


USING: accessors audio.aiff classes.struct
classes.struct.private
specialized-arrays.instances.alien.c-types.char ;

M: common-chunk header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class aiff-chunk-header }
        { initial
            S{ aiff-chunk-header
                { id char-array{ 0 0 0 0 } }
                { size char-array{ 0 0 0 0 } }
            }
        }
        { type aiff-chunk-header }
    } write-struct-slot ; inline


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

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


USING: accessors audio.aiff classes.struct
classes.struct.private
specialized-arrays.instances.alien.c-types.char ;

M: form-chunk header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class aiff-chunk-header }
        { initial
            S{ aiff-chunk-header
                { id char-array{ 0 0 0 0 } }
                { size char-array{ 0 0 0 0 } }
            }
        }
        { type aiff-chunk-header }
    } write-struct-slot ; inline


USING: accessors id3.private slots.private ;

M: id3 header<< 2 set-slot ; inline


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

M: image header<< 2 set-slot ; inline


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

M: image header<<
    [
        dup
        image-header?
        [ \ image-header bad-slot-value ]
        unless
    ] dip 4 set-slot ; inline


USING: accessors images.bitmap slots.private ;

M: loading-bitmap header<< 3 set-slot ; inline


USING: accessors midi slots.private ;

M: midi header<< 2 set-slot ; inline


USING: accessors mime.multipart slots.private ;

M: multipart header<< 5 set-slot ; inline


USING: accessors compiler.cfg.loop-detection slots.private ;

M: natural-loop header<< 2 set-slot ; inline


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

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


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

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


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

M: ogg-stream-state header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 80 }
        { class object }
        { type { uchar 282 } }
    } write-struct-slot ; inline


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

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


USING: accessors http slots.private ;

M: request header<< 6 set-slot ; inline


USING: accessors http slots.private ;

M: response header<< 5 set-slot ; inline


USING: accessors audio.wav classes.struct classes.struct.private
specialized-arrays.instances.alien.c-types.char ;

M: riff-chunk header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class riff-chunk-header }
        { initial
            S{ riff-chunk-header
                { id char-array{ 0 0 0 0 } }
                { size char-array{ 0 0 0 0 } }
            }
        }
        { type riff-chunk-header }
    } write-struct-slot ; inline


USING: accessors audio.aiff classes.struct
classes.struct.private
specialized-arrays.instances.alien.c-types.char ;

M: sound-data-chunk header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class aiff-chunk-header }
        { initial
            S{ aiff-chunk-header
                { id char-array{ 0 0 0 0 } }
                { size char-array{ 0 0 0 0 } }
            }
        }
        { type aiff-chunk-header }
    } write-struct-slot ; inline


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

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


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

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


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

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


USING: accessors slots.private tzinfo.private ;

M: tzfile header<< 2 set-slot ; inline


USING: accessors audio.wav classes.struct classes.struct.private
specialized-arrays.instances.alien.c-types.char ;

M: wav-data-chunk header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class riff-chunk-header }
        { initial
            S{ riff-chunk-header
                { id char-array{ 0 0 0 0 } }
                { size char-array{ 0 0 0 0 } }
            }
        }
        { type riff-chunk-header }
    } write-struct-slot ; inline


USING: accessors audio.wav classes.struct classes.struct.private
specialized-arrays.instances.alien.c-types.char ;

M: wav-fmt-chunk header<<
    T{ struct-slot-spec
        { name "header" }
        { offset 0 }
        { class riff-chunk-header }
        { initial
            S{ riff-chunk-header
                { id char-array{ 0 0 0 0 } }
                { size char-array{ 0 0 0 0 } }
            }
        }
        { type riff-chunk-header }
    } write-struct-slot ; inline


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

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


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

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


USING: accessors slots.private zim ;

M: zim header<< 6 set-slot ; inline