stream-read-unsafe ( n buf stream -- count )
Factor handbook » Input and output » Streams » Stream protocol

Prev:	stream-read1 ( stream -- elt )
Next:	stream-read-until ( seps stream -- seq sep/f )

Vocabulary
io

Inputs

n	a non-negative integer
buf	a c-ptr or a string
stream	an input stream

Outputs

count

an integer

Generic word contract
Reads up to n elements from the stream. The data is stored directly into the buffer provided by buf, which must be a string (in the case of a character stream) or a byte array, specialized array, or other pointer to memory (in the case of a byte stream). There must be space in the buffer for at least n elements. Returns the number of elements read from the stream, which will be equal to n unless the end of the stream is reached. If the stream is exhausted, returns zero.

Warning
This word does not perform bounds checking on buf. Most code should use stream-read or stream-read-into instead.

Errors
Throws an error if the I/O operation fails.

Definition

IN: io

GENERIC: stream-read-unsafe ( n buf stream -- count )

Methods

USING: accessors io math namespaces tools.image.analyzer.utils ;

M:: backwards-reader stream-read-unsafe
    ( n buf stream -- count )
    stream stream>> [
        tell-input n + :> pos-after pos-after neg backwards-seek
        n buf input-stream get stream-read-unsafe
        pos-after backwards-seek
    ] with-input-stream* ;


USING: io io.streams.byte-array io.streams.sequence ;

M: byte-reader stream-read-unsafe sequence-read-unsafe ;


USING: accessors destructors io io.streams.c ;

M: c-reader stream-read-unsafe
    check-disposed handle>> fread-unsafe ;


USING: accessors io io.streams.counting kernel math ;

M:: counting-stream stream-read-unsafe
    ( n buf stream -- count )
    n buf stream stream>> stream-read-unsafe :> count stream
    [ count + ] change-in-count drop count ;


USING: io io.encodings io.encodings.private kernel ;

M: decoder stream-read-unsafe
    pick 0 =
    [ 3drop 0 ] [
        decode-first
        [ 0 store-decode 1 decode-rest ] [ 4drop 0 ] if*
    ] if ; inline


USING: accessors io io.streams.duplex kernel ;

M: duplex-stream stream-read-unsafe
    [ in>> ] call \ stream-read-unsafe execute ;


USING: io kernel ;

M: f stream-read-unsafe 3drop 0 ; inline


USING: alien classes io io.ports io.ports.private kernel ;

M: input-port stream-read-unsafe
    [ c-ptr check-instance swap ] dip prepare-read 0 read-loop ;


USING: io io.private kernel ;

M: input-stream stream-read-unsafe rot 0 read-loop ; inline


USING: io kernel math sequences splitting ui.tools.listener ;

M:: interactor stream-read-unsafe
    ( n buf interactor -- count )
    n
    [ 0 ] [
        drop interactor interactor-read dup [ join-lines ] when
        n index-or-length [ head-slice 0 buf copy ] keep
    ] if-zero ;


USING: io io.streams.limited io.streams.limited.private ;

M: limited-stream stream-read-unsafe
    [ stream-read-unsafe ] maybe-read-unsafe ;


USING: accessors alien io io.streams.memory libc ;

M:: memory-stream stream-read-unsafe
    ( n buf stream -- count )
    stream alien>> :> src buf src n memcpy
    n src <displaced-alien> stream alien<< n ; inline


USING: io io.streams.null kernel ;

M: null-reader stream-read-unsafe 3drop 0 ;


USING: accessors alien io io.ports io.streams.peek kernel math
sequences ;

M:: peek-stream stream-read-unsafe ( n buf stream -- count )
    stream peeked>> :> peeked peeked length :> #peeked #peeked 0
    =
    [ n buf stream stream>> stream-read-unsafe ] [
        #peeked n >= [
            peeked <reversed> n head-slice 0 buf copy peeked
            [ length n - ] keep shorten n
        ] [
            peeked <reversed> 0 buf copy 0 peeked shorten
            n #peeked - :> n' stream stream>> input-port?
            [ #peeked buf <displaced-alien> ]
            [ buf #peeked tail-slice ] if
            :> buf' n' buf' stream stream-read-unsafe #peeked +
        ] if
    ] if ;


USING: io io.streams.random kernel random sequences.private ;

M: random-stream stream-read-unsafe
    drop [ dup random-bytes ] [ 0 swap copy-unsafe ] bi* ;


USING: io io.streams.sequence io.streams.string ;

M: string-reader stream-read-unsafe sequence-read-unsafe ;


USING: io io.streams.tee io.streams.tee.private kernel math
sequences ;

M:: tee-stream stream-read-unsafe ( n buf stream -- count )
    n buf stream
    [ stream-read-unsafe ] [
        [ [ buf swap head ] ] dip [ stream-write ] curry compose
        unless-zero
    ] tee1 ;


USING: accessors io io.streams.throwing kernel ;

M:: throws-on-eof-stream stream-read-unsafe
    ( n buf stream -- count )
    n buf stream stream>> stream-read-unsafe dup n =
    [ n stream \ stream-read-unsafe stream-exhausted ] unless ;


USING: io io.streams.zeros kernel sequences ;

M: zero-stream stream-read-unsafe
    drop over head-slice [ drop 0 ] map! drop ;