header>> ( object -- value )

Vocabulary

accessors

Inputs

object

an object

Outputs

value

an object

Definition

IN: accessors

GENERIC: header>> ( object -- value )

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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors images.png slots.private ;

M: bad-png-header header>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors slots.private tar ;

M: checksum-error header>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors id3.private slots.private ;

M: id3 header>> 2 slot ; inline


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

M: image header>> 4 slot { image-header } declare ; inline


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

M: image header>> 2 slot ; inline


USING: accessors images.bitmap slots.private ;

M: loading-bitmap header>> 3 slot ; inline


USING: accessors midi slots.private ;

M: midi header>> 2 slot ; inline


USING: accessors mime.multipart slots.private ;

M: multipart header>> 5 slot ; inline


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

M: natural-loop header>> 2 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 }
    } read-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 }
    } read-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 } }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors http slots.private ;

M: request header>> 6 slot ; inline


USING: accessors http slots.private ;

M: response header>> 5 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors slots.private tzinfo.private ;

M: tzfile header>> 2 slot ; inline


USING: accessors crypto.jwt slots.private ;

M: unsupported-jwt header>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors slots.private zim ;

M: zim header>> 6 slot ; inline