package multistream

Import Path
	github.com/multiformats/go-multistream (on go.dev)

Dependency Relation
	imports 9 packages, and imported by 5 packages

Involved Source Files

	    client.go
	    lazyClient.go
	  d multistream.go
		Package multistream implements a simple stream router for the
		multistream-select protocoli. The protocol is defined at
		https://github.com/multiformats/multistream-select
Package-Level Type Names (total 7)

	/* sort by: alphabet | popularity */
	 type ErrNotSupported[T] (struct)

		Type Parameters:
			T: StringLike

		ErrNotSupported is the error returned when the muxer doesn't support
		the protocols tried for the handshake.

		Fields (only one)
			Protos []T
				Slice of protocols that were not supported by the muxer

		Methods (total 2)
			( ErrNotSupported[T]) Error() string
			( ErrNotSupported[T]) Is(target error) bool
		Implements (at least one exported)
			 ErrNotSupported : error

	 type ErrUnrecognizedResponse[T] (struct)

		Type Parameters:
			T: StringLike

		Fields (total 2)
			Actual T
			Expected T
		Methods (only one)
			( ErrUnrecognizedResponse[T]) Error() string
		Implements (at least one exported)
			 ErrUnrecognizedResponse : error

	 type Handler[T] (struct)

		Type Parameters:
			T: StringLike

		Handler is a wrapper to HandlerFunc which attaches a name (protocol) and a
		match function which can optionally be used to select a handler by other
		means than the name.

		Fields (total 3)
			AddName T
			Handle HandlerFunc[T]
			MatchFunc func(T) bool

	 type HandlerFunc[T] (func)

		Type Parameters:
			T: StringLike

		HandlerFunc is a user-provided function used by the MultistreamMuxer to
		handle a protocol/stream.

		As Outputs Of (at least one exported)
			func (*MultistreamMuxer)[T].Negotiate(rwc io.ReadWriteCloser) (proto T, handler HandlerFunc[T], err error)
		As Inputs Of (at least 2)
			func (*MultistreamMuxer)[T].AddHandler(protocol T, handler HandlerFunc[T])
			func (*MultistreamMuxer)[T].AddHandlerWithFunc(protocol T, match func(T) bool, handler HandlerFunc[T])

	 type LazyConn (interface)
		LazyConn is the connection type returned by the lazy negotiation functions.

		Methods (total 4)
			( LazyConn) Close() error
			( LazyConn) Flush() error
				Flush flushes the lazy negotiation, if any.

			( LazyConn) Read(p []byte) (n int, err error)
			( LazyConn) Write([]byte) (int, error)
		Implements (at least 13)
			 LazyConn : github.com/apache/thrift/lib/go/thrift.Flusher
			 LazyConn : github.com/miekg/dns.Writer
			 LazyConn : github.com/pion/stun.Connection
			 LazyConn : github.com/pion/stun/v3.Connection
			 LazyConn : github.com/prometheus/common/expfmt.Closer
			 LazyConn : internal/bisect.Writer
			 LazyConn : io.Closer
			 LazyConn : io.ReadCloser
			 LazyConn : io.Reader
			 LazyConn : io.ReadWriteCloser
			 LazyConn : io.ReadWriter
			 LazyConn : io.WriteCloser
			 LazyConn : io.Writer
		As Outputs Of (at least 2)
			func NewMSSelect[T](c io.ReadWriteCloser, proto T) LazyConn
			func NewMultistream[T](c io.ReadWriteCloser, proto T) LazyConn

	 type MultistreamMuxer[T] (struct)

		Type Parameters:
			T: StringLike

		MultistreamMuxer is a muxer for multistream. Depending on the stream
		protocol tag it will select the right handler and hand the stream off to it.

		Methods (total 6)
			(*MultistreamMuxer[T]) AddHandler(protocol T, handler HandlerFunc[T])
				AddHandler attaches a new protocol handler to the muxer.

			(*MultistreamMuxer[T]) AddHandlerWithFunc(protocol T, match func(T) bool, handler HandlerFunc[T])
				AddHandlerWithFunc attaches a new protocol handler to the muxer with a match.
				If the match function returns true for a given protocol tag, the protocol
				will be selected even if the handler name and protocol tags are different.

			(*MultistreamMuxer[T]) Handle(rwc io.ReadWriteCloser) error
				Handle performs protocol negotiation on a ReadWriteCloser
				(i.e. a connection). It will find a matching handler for the
				incoming protocol and pass the ReadWriteCloser to it.

			(*MultistreamMuxer[T]) Negotiate(rwc io.ReadWriteCloser) (proto T, handler HandlerFunc[T], err error)
				Negotiate performs protocol selection and returns the protocol name and
				the matching handler function for it (or an error).

			(*MultistreamMuxer[T]) Protocols() []T
				Protocols returns the list of handler-names added to this this muxer.

			(*MultistreamMuxer[T]) RemoveHandler(protocol T)
				RemoveHandler removes the handler with the given name from the muxer.

		As Outputs Of (at least one exported)
			func NewMultistreamMuxer[T]() *MultistreamMuxer[T]

	 type StringLike (interface)
		StringLike is an interface that supports all types with underlying type
		string


Package-Level Functions (total 7)

	 func NewMSSelect[T](c io.ReadWriteCloser, proto T) LazyConn

		Type Parameters:
			T: StringLike

		NewMSSelect returns a new Multistream which is able to perform
		protocol selection with a MultistreamMuxer.

	 func NewMultistream[T](c io.ReadWriteCloser, proto T) LazyConn

		Type Parameters:
			T: StringLike

		NewMultistream returns a multistream for the given protocol. This will not
		perform any protocol selection. If you are using a MultistreamMuxer, use
		NewMSSelect.

	 func NewMultistreamMuxer[T]() *MultistreamMuxer[T]

		Type Parameters:
			T: StringLike

		NewMultistreamMuxer creates a muxer.

	 func ReadNextToken[T](r io.Reader) (T, error)

		Type Parameters:
			T: StringLike

		ReadNextToken extracts a token from a Reader. It is used during
		protocol negotiation and returns a string.

	 func ReadNextTokenBytes(r io.Reader) ([]byte, error)
		ReadNextTokenBytes extracts a token from a Reader. It is used
		during protocol negotiation and returns a byte slice.

	 func SelectOneOf[T](protos []T, rwc io.ReadWriteCloser) (proto T, err error)

		Type Parameters:
			T: StringLike

		SelectOneOf will perform handshakes with the protocols on the given slice
		until it finds one which is supported by the muxer.

	 func SelectProtoOrFail[T](proto T, rwc io.ReadWriteCloser) (err error)

		Type Parameters:
			T: StringLike

		SelectProtoOrFail performs the initial multistream handshake
		to inform the muxer of the protocol that will be used to communicate
		on this ReadWriteCloser. It returns an error if, for example,
		the muxer does not know how to handle this protocol.


Package-Level Variables (total 3)

	  var ErrIncorrectVersion error
		ErrIncorrectVersion is an error reported when the muxer protocol negotiation
		fails because of a ProtocolID mismatch.

	  var ErrNoProtocols error
		ErrNoProtocols is the error returned when the no protocols have been
		specified.

	  var ErrTooLarge error
		ErrTooLarge is an error to signal that an incoming message was too large


Package-Level Constants (only one)

	const ProtocolID = "/multistream/1.0.0"
		ProtocolID identifies the multistream protocol itself and makes sure
		the multistream muxers on both sides of a channel can work with each other.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.