package netchan

Import Path
	go.pact.im/x/netchan (on go.dev)

Dependency Relation
	imports 4 packages, and imported by 0 packages

Involved Source Files

	  d netchan.go
		Package netchan provides an in-memory implementation of the [net.Listener]
		interface, allowing programs to simulate network connections using channels
		and pipes instead of real network sockets.
Package-Level Type Names (total 2, in which 1 is exported)

	/* sort exporteds by: alphabet | popularity */
	 type Listener (struct)
		Listener implements the [net.Listener] interface using channels for
		accepting connections. Incoming connections are sent on an internal
		channel and accepted by Accept calls. The Listener can be closed to
		unblock Accept calls and signal shutdown.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			addr net.Addr
			conn chan net.Conn
			done chan struct{}
			once sync.Once
		Methods (total 6, all are exported)
			(*Listener) Accept() (net.Conn, error)
				Accept waits for and returns the next connection sent to the listener’s
				connection channel. If the listener is closed, Accept returns [ErrClosed].

			(*Listener) Addr() net.Addr
				Addr implements the [net.Listener] interface.

			(*Listener) C() chan net.Conn
				C returns the internal channel used to send [net.Conn] connections to the
				Accept callers. The returned channel should not be closed; use Close method
				to unblock Accept instead.
				
				Sending a nil connection on this channel is allowed and can be used
				to wait for the Accept caller to be ready.

			(*Listener) Close() error
				Close closes the listener and unblocks all Accept calls.

			(*Listener) Dial(ctx context.Context) (net.Conn, error)
				Dial creates a new in-memory connection pair using net.Pipe and sends the
				server side connection to the Listener’s internal connection channel.
				
				It returns the client side connection, which can be used to communicate
				with the accepted connection on the Listener side.
				
				Dial blocks until the server side connection is accepted by a call to Accept,
				or until the Listener is closed or the provided context is canceled.

			(*Listener) Done() <-chan struct{}
				Done returns a channel that is closed when the Listener is closed.

		Implements (at least 2, both are exported)
			*Listener : io.Closer
			*Listener : net.Listener
		As Outputs Of (at least 2, both are exported)
			func NewListener() *Listener
			func NewListenerAddr(addr net.Addr) *Listener

	/* one unexported ... *//* one unexported: */
	 type chanAddr (struct)
		chanAddr implements the [net.chanAddr] interface representing the network
		address of an in-memory [Listener]. Since connections are in-memory, chanAddr
		returns constant values indicating the connection uses channels.

		Methods (total 2, both are exported)
			( chanAddr) Network() string
				Network returns the name of the network, which is always "chan".

			( chanAddr) String() string
				String returns a string representation of the Addr, which is always "chan".

		Implements (at least 5, in which 3 are exported)
			 chanAddr : expvar.Var
			 chanAddr : fmt.Stringer
			 chanAddr : net.Addr
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 chanAddr : context.stringer
			 chanAddr : runtime.stringer


Package-Level Functions (total 2, both are exported)

	 func NewListener() *Listener
		NewListener returns a new Listener with the default address.

	 func NewListenerAddr(addr net.Addr) *Listener
		NewListenerAddr returns a new Listener instance with the specified network
		address.


Package-Level Variables (only one, which is exported)

	  var ErrClosed error
		ErrClosed indicates that the [Listener] has been closed and no further
		operations can be performed.

The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64)