lispdoc - results for stream

stream
Undocumented
Example:
(defun read-type-code (stream) (read-byte stream))
Mentioned in:
CLtL2 - 19.5. Defstruct Options
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.3. Operations on Streams
CLtL2 - 22.1.6. What the Print Function Produces
CLtL2 - 25.1.4. Similarity of Constants
HyperSpec - 21.1 Stream Concepts
HyperSpec - 21.1.1.3 Other Subclasses of Stream
HyperSpec - 21.1.2 Stream Variables
HyperSpec - 21.1.3 Stream Arguments to Standardized Functions
HyperSpec - System Class STREAM
On Lisp - Macro Characters
Successful Lisp - chapter09
(streamp stream)
Undocumented
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
CLtL2 - 6.2.2. Specific Data Type Predicates
HyperSpec - Function STREAMP
streams
 
 Mentioned in:
HyperSpec - 20.1.1 Coercion of Streams to Pathnames
HyperSpec - 20.1.2 File Operations on Open and Closed Streams
HyperSpec - 21.1.1 Introduction to Streams
HyperSpec - 21.1.1.1 Abstract Classifications of Streams
HyperSpec - 21.1.1.1.1 Input, Output, and Bidirectional Streams
HyperSpec - 21.1.1.1.2 Open and Closed Streams
HyperSpec - 21.1.1.1.3 Interactive Streams
HyperSpec - 21.1.1.2 Abstract Classifications of Streams
HyperSpec - 21.1.1.2.1 File Streams
HyperSpec - 21.1.4 Restrictions on Composite Streams
HyperSpec - 21.2 The Streams Dictionary
file-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
CLtL2 - 23.2. Opening and Closing Files
HyperSpec - System Class FILE-STREAM
Successful Lisp - chapter19
echo-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - System Class ECHO-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
stream-error
Undocumented
 Mentioned in:
CLtL2 - 29.5. Predefined Condition Types
HyperSpec - Condition Type STREAM-ERROR
(trivial-gray-streams:stream-listen stream)
Function: This is used by LISTEN. It returns true or false. The default method uses STREAM-READ-CHAR-NO-HANG and STREAM-UNREAD-CHAR. Most streams should define their own method since it will usually be trivial and will always be more efficient than the default method.
  
(trivial-gray-streams:stream-terpri stream)
Function: Writes an end of line, as for TERPRI. Returns NIL. The default method does (STREAM-WRITE-CHAR stream #NEWLINE).
  
string-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
HyperSpec - System Class STRING-STREAM
PCL - other kinds of io
PCL - strings in binary files
synonym-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - System Class SYNONYM-STREAM
Successful Lisp - chapter19
(cl+ssl:stream-fd stream)
Undocumented
  
broadcast-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - System Class BROADCAST-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(open-stream-p stream)
Function: Return true if STREAM is not closed. A default method is provided by class FUNDAMENTAL-STREAM which returns true if CLOSE has not been called on the stream.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function OPEN-STREAM-P
(md5:md5sum-stream)
Function: Calculate an MD5 message-digest of the contents of stream. Its element-type has to be either (unsigned-byte 8) or character.
  
fundamental-stream
Type: the base class for all Gray streams
  
two-way-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - System Class TWO-WAY-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(input-stream-p stream)
Function: Can STREAM perform input operations?
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function INPUT-STREAM-P, OUTPUT-STREAM-P
flexi-streams:octet
Type: A shortcut for (UNSIGNED-BYTE 8).
  
concatenated-stream
Undocumented
 Mentioned in:
CLtL2 - 2.10. Streams
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - System Class CONCATENATED-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(output-stream-p stream)
Function: Can STREAM perform output operations?
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function INPUT-STREAM-P, OUTPUT-STREAM-P
chunga:chunked-stream
Type: Every chunked stream returned by MAKE-CHUNKED-STREAM is of this type which is a subtype of STREAM.
  
(trivial-gray-streams:stream-read-char stream)
Function: Read one character from the stream. Return either a character object, or the symbol :EOF if the stream is at end-of-file. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.
  
(trivial-gray-streams:stream-peek-char stream)
Function: This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. It returns either a character or :EOF. The default method calls STREAM-READ-CHAR and STREAM-UNREAD-CHAR.
  
(trivial-gray-streams:stream-read-line stream)
Function: This is used by READ-LINE. A string is returned as the first value. The second value is true if the string was terminated by end-of-file instead of the end of a line. The default method uses repeated calls to STREAM-READ-CHAR.
  
(trivial-gray-streams:stream-read-byte stream)
Function: Used by READ-BYTE; returns either an integer, or the symbol :EOF if the stream is at end-of-file.
  
(usocket:socket-stream object)
Undocumented
  
(with-open-stream (var stream) &body forms-decls)
Undocumented
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 9.1. Declaration Syntax
HyperSpec - Macro WITH-OPEN-STREAM
Successful Lisp - chapter19
(make-echo-stream input-stream output-stream)
Function: Return a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM. In addition, all input is echoed to the output stream.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 22.2.1. Input from Character Streams
HyperSpec - Function MAKE-ECHO-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
usocket:stream-usocket
Type: Stream socket class. ' Contrary to other sockets, these sockets may be closed either with the `socket-close' method or by closing the associated stream (which can be retrieved with the `socket-stream' accessor).
  
(trivial-gray-streams:stream-write-char stream character)
Function: Write CHARACTER to STREAM and return CHARACTER. Every subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method defined for this function.
  
(trivial-gray-streams:stream-fresh-line stream)
Function: Outputs a new line to the Stream if it is not positioned at the begining of a line. Returns T if it output a new line, nil otherwise. Used by FRESH-LINE. The default method uses STREAM-START-LINE-P and STREAM-TERPRI.
  
(trivial-gray-streams:stream-write-byte stream integer)
Function: Implements WRITE-BYTE; writes the integer to the stream and returns the integer as the result.
  
(cl-fad:copy-stream from to &optional (checkp t))
Function: Copies into TO (a stream) from FROM (also a stream) until the end of FROM is reached, in blocks of *stream-buffer-size*. The streams should have the same element type. If CHECKP is true, the streams are checked for compatibility of their types.
  
(trivial-gray-streams:stream-line-column stream)
Function: Return the column number where the next character will be written, or NIL if that is not meaningful for this stream. The first column on a line is numbered 0. This function is used in the implementation of PPRINT and the FORMAT ~T directive. For every character output stream class that is defined, a method must be defined for this function, although it is permissible for it to always return NIL.
  
(trivial-gray-streams:stream-unread-char stream character)
Function: Un-do the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.
  
(trivial-gray-streams:stream-clear-input stream)
Function: This is like CL:CLEAR-INPUT, but for Gray streams, returning NIL. The default method does nothing.
  
(trivial-gray-streams:stream-write-string stream string &optional start end)
Function: This is used by WRITE-STRING. It writes the string to the stream, optionally delimited by start and end, which default to 0 and NIL. The string argument is returned. The default method provided by FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses repeated calls to STREAM-WRITE-CHAR.
  
(trivial-gray-streams:stream-clear-output stream)
Function: This is like CL:CLEAR-OUTPUT, but for Gray streams: clear the given output STREAM. The default method does nothing.
  
(trivial-gray-streams:stream-force-output stream)
Function: Attempts to force any buffered output to be sent. Implements FORCE-OUTPUT. The default method does nothing.
  
(stream-error-stream condition)
Function: Return the offending thread that the THREAD-ERROR pertains to.
 Mentioned in:
CLtL2 - 29.5. Predefined Condition Types
HyperSpec - Function STREAM-ERROR-STREAM
(stream-element-type stream)
Function: Return a type specifier for the kind of object returned by the STREAM. The class FUNDAMENTAL-CHARACTER-STREAM provides a default method which returns CHARACTER.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
CLtL2 - 23.2. Opening and Closing Files
HyperSpec - Function STREAM-ELEMENT-TYPE
(make-synonym-stream symbol)
Undocumented
 Mentioned in:
CLtL2 - 21.1. Standard Streams
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function MAKE-SYNONYM-STREAM
Successful Lisp - chapter19
hunchentoot:*header-stream*
Variable: If this variable is not NIL, it should be bound to a stream to which incoming and outgoing headers will be written for debugging purposes.
  
(trivial-gray-streams:stream-finish-output stream)
Function: Attempts to ensure that all output sent to the Stream has reached its destination, and only then returns false. Implements FINISH-OUTPUT. The default method does nothing.
  
(interactive-stream-p stream)
Function: Is STREAM an interactive stream?
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function INTERACTIVE-STREAM-P
(alexandria.0.dev:copy-stream input output &key
 (element-type (stream-element-type input)) (buffer-size 4096)
 (buffer (make-array buffer-size element-type element-type)) finish-output)
Function: Reads data from INPUT and writes it to OUTPUT. Both INPUT and OUTPUT must be streams, they will be passed to READ-SEQUENCE and WRITE-SEQUENCE and must have compatible element-types.
  
(make-broadcast-stream &rest streams)
Undocumented
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function MAKE-BROADCAST-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(synonym-stream-symbol instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function SYNONYM-STREAM-SYMBOL
(stream-external-format stream)
Undocumented
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
CLtL2 - 23.2. Opening and Closing Files
HyperSpec - Function STREAM-EXTERNAL-FORMAT
(flexi-streams:peek-byte flexi-input-stream &optional peek-type (eof-error-p)
 eof-value)
Undocumented
  
(trivial-gray-streams:stream-start-line-p stream)
Function: Is STREAM known to be positioned at the beginning of a line? It is permissible for an implementation to always return NIL. This is used in the implementation of FRESH-LINE. Note that while a value of 0 from STREAM-LINE-COLUMN also indicates the beginning of a line, there are cases where STREAM-START-LINE-P can be meaningfully implemented although STREAM-LINE-COLUMN can't be. For example, for a window using variable-width characters, the column number isn't very meaningful, but the beginning of the line does have a clear meaning. The default method for STREAM-START-LINE-P on class FUNDAMENTAL-CHARACTER-OUTPUT-STREAM uses STREAM-LINE-COLUMN, so if that is defined to return NIL, then a method should be provided for either STREAM-START-LINE-P or STREAM-FRESH-LINE.
  
(make-two-way-stream input-stream output-stream)
Function: Return a bidirectional stream which gets its input from INPUT-STREAM and sends its output to OUTPUT-STREAM.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function MAKE-TWO-WAY-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
chunga:chunked-io-stream
Type: A chunked stream is of this type if it is both a CHUNKED-INPUT-STREAM as well as a CHUNKED-OUTPUT-STREAM.
  
fundamental-input-stream
Type: a superclass of all Gray input streams
  
(make-concatenated-stream &rest streams)
Function: Return a stream which takes its input from each of the streams in turn, going on to the next at EOF.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function MAKE-CONCATENATED-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(broadcast-stream-streams instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function BROADCAST-STREAM-STREAMS
(flexi-streams:char-length sequence &key (external-format latin1) (start 0)
 (end (length sequence)))
Function: Kind of the inverse of OCTET-LENGTH. Returns the length of the subsequence (of octets) of SEQUENCE from START to END in characters if decoded using the external format EXTERNAL-FORMAT. Note that this function doesn't check for the validity of the data in SEQUENCE. This function is optimized for the case of SEQUENCE being a vector. Don't use lists if you're in a hurry.
  
(flexi-streams:unread-byte byte flexi-input-stream)
Undocumented
  
flexi-streams:list-stream
Type: A LIST-STREAM is a mixin for IN-MEMORY streams where the underlying sequence is a list.
  
fundamental-output-stream
Type: a superclass of all Gray output streams
  
fundamental-binary-stream
Type: a superclass of all Gray streams whose element-type is a subtype of unsigned-byte or signed-byte
  
(flexi-streams:octet-length string &key (external-format latin1) (start 0)
 (end (length string)))
Function: Returns the length of the substring of STRING from START to END in octets if encoded using the external format EXTERNAL-FORMAT. In spite of the name, STRING can be any sequence of characters, but the function is optimized for strings.
  
(chunga:make-chunked-stream stream)
Function: Creates and returns a chunked stream (a stream of type CHUNKED-STREAM) which wraps STREAM. STREAM must be an open binary stream.
  
flexi-streams:flexi-stream
Type: A FLEXI-STREAM object is a stream that's `layered' atop an existing binary/bivalent stream in order to allow for multi-octet external formats. FLEXI-STREAM itself is a mixin and should not be instantiated.
  
chunga:chunked-input-stream
Type: A chunked stream is of this type if its underlying stream is an input stream. This is a subtype of CHUNKED-STREAM.
  
flexi-streams:vector-stream
Type: A VECTOR-STREAM is a mixin for IN-MEMORY streams where the underlying sequence is a vector.
  
(concatenated-stream-streams instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function CONCATENATED-STREAM-STREAMS
chunga:chunked-output-stream
Type: A chunked stream is of this type if its underlying stream is an output stream. This is a subtype of CHUNKED-STREAM.
  
(chunga:chunked-stream-stream object)
Undocumented
  
fundamental-character-stream
Type: a superclass of all Gray streams whose element-type is a subtype of character
  
(ql-cmucl:make-fd-stream &rest args)
Undocumented
  
usocket:stream-server-usocket
Type: Socket which listens for stream connections to be initiated from remote sockets.
  
(trivial-gray-streams:stream-advance-to-column stream column)
Function: Write enough blank space so that the next character will be written at the specified column. Returns true if the operation is successful, or NIL if it is not supported for this stream. This is intended for use by by PPRINT and FORMAT ~T. The default method uses STREAM-LINE-COLUMN and repeated calls to STREAM-WRITE-CHAR with a #SPACE character; it returns NIL if STREAM-LINE-COLUMN returns NIL.
  
(echo-stream-input-stream instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function ECHO-STREAM-INPUT-STREAM, ECHO-STREAM-OUTPUT-STREAM
(get-output-stream-string stream)
Undocumented
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function GET-OUTPUT-STREAM-STRING
PCL - other kinds of io
(make-string-input-stream string &optional (start 0) end)
Function: Return an input stream which will supply the characters of STRING between START and END in order.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 7.9. Structure Traversal and Side Effects
HyperSpec - Function MAKE-STRING-INPUT-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(ql-ecl:socket-make-stream &rest args)
Undocumented
  
(echo-stream-output-stream instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function ECHO-STREAM-INPUT-STREAM, ECHO-STREAM-OUTPUT-STREAM
(make-string-output-stream &key (element-type 'character) &aux
 (buffer (make-string *string-output-stream-buffer-initial-size*)))
Function: Return an output stream which will accumulate all output given it for the benefit of the function GET-OUTPUT-STREAM-STRING.
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function MAKE-STRING-OUTPUT-STREAM
PCL - other kinds of io
Successful Lisp - chapter19
(qlb-abcl:get-socket-stream &rest args)
Undocumented
  
flexi-streams:*substitution-char*
Variable: If this value is not NIL, it should be a character which is used (as if by a USE-VALUE restart) whenever during reading an error of type FLEXI-STREAM-ENCODING-ERROR would have been signalled otherwise.
  
(hunchentoot:reset-connection-stream acceptor stream)
Function: Resets the stream which is used to communicate between client and server after one request has been served so that it can be used to process the next request. This generic function is called after a request has been processed and must return the stream.
  
(ql-lispworks:open-tcp-stream &rest args)
Undocumented
  
(trivial-gray-streams:stream-read-char-no-hang stream)
Function: This is used to implement READ-CHAR-NO-HANG. It returns either a character, or NIL if no input is currently available, or :EOF if end-of-file is reached. The default method provided by FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this is sufficient for file streams, but interactive streams should define their own method.
  
(cl+ssl:make-ssl-server-stream)
Function: Returns an SSL stream for the server socket descriptor SOCKET. CERTIFICATE is the path to a file containing the PEM-encoded certificate for your server. KEY is the path to the PEM-encoded key for the server, which may be associated with the passphrase PASSWORD.
  
(cl+ssl:make-ssl-client-stream)
Function: Returns an SSL stream for the client socket descriptor SOCKET. CERTIFICATE is the path to a file containing the PEM-encoded certificate for your client. KEY is the path to the PEM-encoded key for the client, which may be associated with the passphrase PASSWORD.
  
flexi-streams:flexi-io-stream
Type: A FLEXI-IO-STREAM is a FLEXI-STREAM that can actually be instatiated and used for input and output. Don't use MAKE-INSTANCE to create a new FLEXI-IO-STREAM but use MAKE-FLEXI-STREAM instead.
  
(flexi-streams:octets-to-string sequence &key (external-format latin1)
 (start 0) (end (length sequence)))
Function: Converts the Lisp sequence SEQUENCE of octets from START to END to a string using the external format designated by EXTERNAL-FORMAT. This function is optimized for the case of SEQUENCE being a vector. Don't use lists if you're in a hurry.
  
(flexi-streams:string-to-octets string &key (external-format latin1) (start 0)
 (end (length string)))
Function: Converts the Lisp string STRING from START to END to an array of octets corresponding to the external format designated by EXTERNAL-FORMAT. In spite of the name, STRING can be any sequence of characters, but the function is optimized for strings.
  
flexi-streams:in-memory-stream
Type: An IN-MEMORY-STREAM is a binary stream that reads octets from or writes octets to a sequence in RAM.
  
(flexi-streams:make-flexi-stream stream &rest args &key
 (external-format (make-external-format iso-8859-1)) element-type column
 position bound)
Function: Creates and returns a new flexi stream. STREAM must be an open binary or `bivalent' stream, i.e. it must be capable of reading/writing octets with READ-SEQUENCE and/or WRITE-SEQUENCE. The resulting flexi stream is an input stream if and only if STREAM is an input stream. Likewise, it's an output stream if and only if STREAM is an output stream. The default for ELEMENT-TYPE is LW:SIMPLE-CHAR on LispWorks and CHARACTER on other Lisps. EXTERNAL-FORMAT must be an EXTERNAL-FORMAT object or a symbol or a list denoting such an object. COLUMN is the initial column of the stream which is either a non-negative integer or NIL. The COLUMN argument must only be used for output streams. POSITION (only used for input streams) should be an integer and it denotes the position the stream is in - it will be increased by one for each octet read. BOUND (only used for input streams) should be NIL or an integer. If BOUND is not NIL and POSITION has gone beyond BOUND, then the stream will behave as if no more input is available.
  
fundamental-binary-input-stream
Type: a superclass of all Gray input streams whose element-type is a subtype of unsigned-byte or signed-byte
  
(hunchentoot:initialize-connection-stream acceptor stream)
Function: Can be used to modify the stream which is used to communicate between client and server before the request is read. The default method of ACCEPTOR does nothing, but see for example the method defined for SSL-ACCEPTOR. All methods of this generic function must return the stream to use.
  
(flexi-streams:external-format-id object)
Undocumented
  
flexi-streams:flexi-stream-error
Type: Superclass for all errors related to flexi streams.
Structure: Superclass for all errors related to flexi streams.
  
(flexi-streams:flexi-stream-bound object)
Undocumented
  
flexi-streams:flexi-input-stream
Type: A FLEXI-INPUT-STREAM is a FLEXI-STREAM that can actually be instatiated and used for input. Don't use MAKE-INSTANCE to create a new FLEXI-INPUT-STREAM but use MAKE-FLEXI-STREAM instead.
  
fundamental-binary-output-stream
Type: a superclass of all Gray output streams whose element-type is a subtype of unsigned-byte or signed-byte
  
(two-way-stream-input-stream instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function TWO-WAY-STREAM-INPUT-STREAM, TWO-WAY-STREAM-OUTPUT-STREAM
flexi-streams:*default-eol-style*
Variable: The end-of-line style used by external formats if none is explicitly given. Depends on the OS the code is compiled on.
  
(flexi-streams:flexi-stream-stream object)
Undocumented
  
flexi-streams:flexi-output-stream
Type: A FLEXI-OUTPUT-STREAM is a FLEXI-STREAM that can actually be instatiated and used for output. Don't use MAKE-INSTANCE to create a new FLEXI-OUTPUT-STREAM but use MAKE-FLEXI-STREAM instead.
  
(flexi-streams:flexi-stream-column object)
Undocumented
  
(two-way-stream-output-stream instance)
Function: Return whether debug-block represents elsewhere code.
 Mentioned in:
CLtL2 - 21.3. Operations on Streams
HyperSpec - Function TWO-WAY-STREAM-INPUT-STREAM, TWO-WAY-STREAM-OUTPUT-STREAM
(flexi-streams:make-external-format name &rest args &key
 (little-endian *default-little-endian*) id eol-style)
Function: Creates and returns an external format object as specified. NAME is a keyword like :LATIN1 or :UTF-8, LITTLE-ENDIAN specifies the `endianess' of the external format and is ignored for 8-bit encodings, EOL-STYLE is one of the keywords :CR, :LF, or :CRLF which denote the end-of-line character (sequence), ID is the ID of a Windows code page (and ignored for other encodings).
  
(flexi-streams:external-format-name object)
Undocumented
  
fundamental-character-input-stream
Type: a superclass of all Gray input streams whose element-type is a subtype of character
  
(s-xml:xml-parser-error-stream condition)
Function: Get the stream from an XML parser error
  
flexi-streams:external-format-error
Type: Superclass for all errors related to external formats.
Structure: Superclass for all errors related to external formats.
  
(flexi-streams:external-format-equal ef1 ef2)
Function: Checks whether two EXTERNAL-FORMAT objects denote the same encoding.
  
(flexi-streams:flexi-stream-position object)
Undocumented
  
fundamental-character-output-stream
Type: a superclass of all Gray output streams whose element-type is a subtype of character
  
usocket:invalid-socket-stream-error
Undocumented
  
(chunga:chunked-input-stream-trailers object)
Undocumented
  
flexi-streams:*default-little-endian*
Variable: Whether external formats are little-endian by default (i.e. unless explicitly specified). Depends on the platform the code is compiled on.
  
flexi-streams:accept-overlong-sequence
Undocumented
  
(chunga:chunked-input-stream-extensions object)
Undocumented
  
(chunga:with-character-stream-semantics &body body)
Function: Binds *CHAR-BUFFER* around BODY so that within BODY we can use READ-CHAR* and friends (see above) to simulate a character stream although we're reading from a binary stream.
  
flexi-streams:external-format-condition
Type: Superclass for all conditions related to external formats.
Structure: Superclass for all conditions related to external formats.
  
cl-base64:base64-stream-to-stream
Undocumented
  
(cl-base64:base64-string-to-stream input &key (uri nil) stream)
Function: Decode base64 string to stream
  
cl-base64:stream-to-base64-stream
Undocumented
  
(cl-base64:string-to-base64-stream input output &key (uri nil) (columns 0))
Function: Encode a string array to base64. If columns is > 0, designates maximum number of columns in a line and the string will be terminated with a #Newline.
  
cl-base64:stream-to-base64-string
Undocumented
  
cl-base64:base64-stream-to-string
Undocumented
  
(ql-sbcl:socket-make-stream socket &key input output element-type
 external-format buffering timeout (element-type 'character) (buffering full)
 (external-format default) auto-close (serve-events t))
Function: Find or create a STREAM that can be used for IO on SOCKET (which must be connected). Specify whether the stream is for INPUT, OUTPUT, or both (it is an error to specify neither). ELEMENT-TYPE and EXTERNAL-FORMAT are as per OPEN. TIMEOUT specifies a read timeout for the stream.
Example:
(defun listener-accept-stream (listener)
  (let ((socket
         (sb-bsd-sockets:socket-accept
          (http-listener-socket listener))))
    (sb-bsd-sockets:socket-make-stream socket
                                       :element-type
                                       'character
                                       :external-format
                                       :utf8
                                       :name
                                       "socket"
                                       :input t
                                       :output t
                                       :buffering
                                       :full)))
 
(cl-base64:integer-to-base64-stream input stream &key (uri nil) (columns 0))
Function: Encode an integer to base64 format.
  
(cl-base64:base64-stream-to-integer stream &key (uri nil))
Function: Decodes a base64 string to an integer
  
flexi-streams:in-memory-stream-error
Type: Superclass for all errors related to IN-MEMORY streams.
Structure: Superclass for all errors related to IN-MEMORY streams.
  
flexi-streams:in-memory-input-stream
Type: An IN-MEMORY-INPUT-STREAM is a binary stream that reads octets from a sequence in RAM.
  
(flexi-streams:with-output-to-sequence
 (var &key as-list (element-type ''octet) transformer) &body body)
Function: Creates an IN-MEMORY output stream, binds VAR to this stream and then executes the code in BODY. The stream stores data of type ELEMENT-TYPE (a subtype of OCTET) which is (optionally) transformed by the function TRANSFORMER prior to storage. The stream is automatically closed on exit from WITH-OUTPUT-TO-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is a vector (or a list if AS-LIST is true) containing the octets that were sent to the stream within BODY.
  
flexi-streams:in-memory-output-stream
Type: An IN-MEMORY-OUTPUT-STREAM is a binary stream that writes octets to a sequence in RAM.
  
(flexi-streams:with-input-from-sequence
 (var sequence &key start end transformer) &body body)
Function: Creates an IN-MEMORY input stream from SEQUENCE using the parameters START and END, binds VAR to this stream and then executes the code in BODY. A function TRANSFORMER may optionally be specified to transform the returned octets. The stream is automatically closed on exit from WITH-INPUT-FROM-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is the return value of BODY.
  
(chunga:chunked-stream-input-chunking-p object)
Undocumented
  
(flexi-streams:external-format-eol-style object)
Undocumented
  
(chunga:chunked-stream-output-chunking-p object)
Undocumented
  
(flexi-streams:flexi-stream-element-type object)
Undocumented
  
(flexi-streams:get-output-stream-sequence stream &key as-list)
Undocumented
  
(trivial-gray-streams:stream-read-sequence stream sequence start end
 &allow-other-keys)
Undocumented
  
(trivial-gray-streams:stream-file-position stream)
Undocumented
  
(flexi-streams:flexi-stream-external-format object)
Undocumented
  
(trivial-gray-streams:stream-write-sequence stream sequence start end
 &allow-other-keys)
Undocumented
  
(flexi-streams:external-format-little-endian object)
Undocumented
  
(flexi-streams:output-stream-sequence-length stream)
Undocumented
  
(trivial-backtrace:print-backtrace-to-stream stream)
Function: Send a backtrace of the current error to stream. Stream is assumed to be an open writable file stream or a string-output-stream. Note that `print-backtrace-to-stream` will print a backtrace for whatever the Lisp deems to be the *current* error.
  
(cl-base64:usb8-array-to-base64-stream input output &key (uri nil) (columns 0))
Function: Encode a string array to base64. If columns is > 0, designates maximum number of columns in a line and the string will be terminated with a #Newline.
  
cl-base64:base64-stream-to-usb8-array
Undocumented
  
flexi-streams:external-format-encoding-error
Type: Errors of this type are signalled if there is an encoding problem.
Structure: Errors of this type are signalled if there is an encoding problem.
  
(flexi-streams:make-in-memory-input-stream vector &key transformer
 (end (length vector)) (start 0))
Undocumented
  
(flexi-streams:make-in-memory-output-stream &key (element-type 'octet)
 transformer)
Function: Returns a binary output stream which accepts objects of type ELEMENT-TYPE (a subtype of OCTET) and makes available a sequence that contains the octes that were actually output. The octets stored will each be transformed by the optional TRANSFORMER function.
  
flexi-streams:in-memory-stream-closed-error
Type: An error that is signalled when someone is trying to read from or write to a closed IN-MEMORY stream.
Structure: An error that is signalled when someone is trying to read from or write to a closed IN-MEMORY stream.
  
flexi-streams:flexi-stream-element-type-error
Type: Errors of this type are signalled if the flexi stream has a wrong element type.
Structure: Errors of this type are signalled if the flexi stream has a wrong element type.
  
trivial-gray-streams:trivial-gray-stream-mixin
Undocumented
  
flexi-streams:flexi-stream-out-of-sync-error
Type: This can happen if you're trying to write to an IO stream which had prior to that `looked ahead' while reading and now can't `rewind' to the octet where you /should/ be.
Structure: This can happen if you're trying to write to an IO stream which had prior to that `looked ahead' while reading and now can't `rewind' to the octet where you /should/ be.
  
(flexi-streams:external-format-condition-external-format condition)
Undocumented
  
flexi-streams:in-memory-stream-position-spec-error
Type: Errors of this type are signalled if an erroneous position spec is used in conjunction with FILE-POSITION.
Structure: Errors of this type are signalled if an erroneous position spec is used in conjunction with FILE-POSITION.
  
(flexi-streams:flexi-stream-element-type-error-element-type condition)
Undocumented
  
(flexi-streams:in-memory-stream-position-spec-error-position-spec condition)
Undocumented