underlying<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: underlying<< ( value object -- )

Methods

USING: accessors bit-arrays bit-vectors kernel slots
slots.private ;

M: bit-vector underlying<<
    [ dup bit-array? [ \ bit-array bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors math.blas.matrices slots.private ;

M: blas-matrix-base underlying<< 2 set-slot ; inline


USING: accessors math.blas.vectors slots.private ;

M: blas-vector-base underlying<< 2 set-slot ; inline


USING: accessors kernel slots slots.private
specialized-arrays.instances.gpu.demos.bunny.bunny-vertex-struct
specialized-vectors.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-vector underlying<<
    [
        dup
        bunny-vertex-struct-array?
        [ \ bunny-vertex-struct-array bad-slot-value ]
        unless
    ] dip 2 set-slot ; inline


USING: accessors byte-arrays byte-vectors kernel slots
slots.private ;

M: byte-vector underlying<<
    [ dup byte-array? [ \ byte-array bad-slot-value ] unless ]
    dip 2 set-slot ; inline


USING: accessors io.crlf slots.private ;

M: crlf-stream underlying<< 2 set-slot ; inline


USING: accessors kernel slots slots.private
specialized-arrays.instances.math.vectors.simd.float-4
specialized-vectors.instances.math.vectors.simd.float-4 ;

M: float-4-vector underlying<<
    [
        dup
        float-4-array?
        [ \ float-4-array bad-slot-value ]
        unless
    ] dip 2 set-slot ; inline


USING: accessors kernel slots slots.private
specialized-arrays.instances.game.loop.benchmark.game-loop-benchmark
specialized-vectors.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-vector underlying<<
    [
        dup
        game-loop-benchmark-array?
        [ \ game-loop-benchmark-array bad-slot-value ]
        unless
    ] dip 2 set-slot ; inline


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

M: pile underlying<<
    [ dup c-ptr? [ \ c-ptr bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors kernel sbufs slots slots.private strings ;

M: sbuf underlying<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors arrays.shaped slots.private ;

M: shaped-array underlying<< 2 set-slot ; inline


USING: accessors kernel slots slots.private
specialized-arrays.instances.alien.c-types.short
specialized-vectors.instances.alien.c-types.short ;

M: short-vector underlying<<
    [ dup short-array? [ \ short-array bad-slot-value ] unless ]
    dip 2 set-slot ; inline


USING: accessors kernel slots slots.private
specialized-arrays.instances.alien.c-types.uint
specialized-vectors.instances.alien.c-types.uint ;

M: uint-vector underlying<<
    [ dup uint-array? [ \ uint-array bad-slot-value ] unless ]
    dip 2 set-slot ; inline


USING: accessors kernel slots slots.private
specialized-arrays.instances.alien.c-types.ushort
specialized-vectors.instances.alien.c-types.ushort ;

M: ushort-vector underlying<<
    [
        dup
        ushort-array?
        [ \ ushort-array bad-slot-value ]
        unless
    ] dip 2 set-slot ; inline


USING: accessors arrays kernel slots slots.private vectors ;

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


USING: accessors slots.private zeromq ;

M: zmq-context underlying<< 2 set-slot ; inline


USING: accessors slots.private zeromq ;

M: zmq-message underlying<< 2 set-slot ; inline


USING: accessors slots.private zeromq ;

M: zmq-socket underlying<< 2 set-slot ; inline