stream-read-until ( seps stream -- seq sep/f )
Factor handbook » Input and output » Streams » Stream protocol

Prev:	stream-read-unsafe ( n buf stream -- count )
Next:	stream-read-partial-unsafe ( n buf stream -- count )

Vocabulary
io

Inputs

seps	a string
stream	an input stream

Outputs

seq	a byte-array, a string, or f
sep/f	a character or f

Generic word contract
Reads elements from the stream, until the first occurrence of a separator character, or stream exhaustion. In the former case, the separator is pushed on the stack, and is not part of the output string. In the latter case, the entire stream contents are output, along with f.

Notes
Most code only works on one stream at a time and should instead use read-until; see Default input and output streams.

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

Definition

IN: io

GENERIC: stream-read-until ( seps stream -- seq sep/f )

Methods

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

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


USING: accessors byte-vectors destructors io io.streams.c kernel
sequences ;

M: c-reader stream-read-until
    check-disposed handle>> swap 32 <byte-vector>
    read-until-loop [ B{ } like ] dip over empty? over not and
    [ 2drop f f ] when ;


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

M:: counting-stream stream-read-until
    ( seps stream -- seq sep/f )
    seps stream stream>> stream-read-until :> ( seq sep ) sep
    [ stream [ seq length + ] change-in-count drop ] when
    seq sep ;


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

M: decoder stream-read-until
    dup cr>> [
        dup cr- 2dup >decoder< decode-until over
        [ dup 10 = [ 2drop stream-read-until ] [ 2nipd ] if ]
        [ first-unsafe 10 = [ [ rest ] dip ] when 2nipd ]
        if-empty
    ] [ >decoder< decode-until ] if ;


USING: accessors io io.streams.duplex kernel ;

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


USING: io kernel ;

M: f stream-read-until 2drop f f ; inline


USING: io io.ports io.ports.private kernel sequences ;

M: input-port stream-read-until
    2dup read-until-step dup
    [ 2nipd ] [
        over [
            drop BV{ } like [ read-until-loop ] keep B{ } like
            swap
        ] [ 2nipd ] if
    ] if ;


USING: io io.private ;

M: input-stream stream-read-until read-until-loop ; inline


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

M: interactor stream-read-until
    swap [ member? ] curry [ [ join-lines 10 suffix ] ] dip
    [ dupd find [ [ head ] when* ] dip dup not ] curry compose
    [ [ interactor-read ] curry ] dip [ [ f f f ] if* ] curry
    compose [ drop ] produce swap [ concat "" prepend-as ] dip ;


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

M: limited-stream stream-read-until
    swap BV{ } clone (read-until) [ 2nip B{ } like ] dip ;


USING: io io.streams.null kernel ;

M: null-reader stream-read-until 2drop f f ;


USING: io io.streams.peek kernel ;

M: peek-stream stream-read-until
    swap 64 pick stream-new-resizable peek-stream-read-until
    [ nip swap stream-like ] dip ;


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

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


USING: accessors io io.streams.throwing kernel sequences ;

M: throws-on-eof-stream stream-read-until
    [ stream>> stream-read-until ] [
        [ [ length ] ] dip
        [ \ read-until stream-exhausted ] curry compose unless*
    ] bi ;