111 lines
3.3 KiB
Go
111 lines
3.3 KiB
Go
package memconn
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
)
|
|
|
|
const (
|
|
// networkMemb is a buffered network connection. Write operations
|
|
// do not block as they are are buffered instead of waiting on a
|
|
// matching Read operation.
|
|
networkMemb = "memb"
|
|
|
|
// networkMemu is an unbuffered network connection. Write operations
|
|
// block until they are matched by a Read operation on the other side
|
|
// of the connected pipe.
|
|
networkMemu = "memu"
|
|
|
|
// addrLocalhost is a reserved address name. It is used when a
|
|
// Listen variant omits the local address or a Dial variant omits
|
|
// the remote address.
|
|
addrLocalhost = "localhost"
|
|
)
|
|
|
|
// provider is the package's default provider instance. All of the
|
|
// package-level functions interact with this object.
|
|
var provider Provider
|
|
|
|
// MapNetwork enables mapping the network value provided to this Provider's
|
|
// Dial and Listen functions from the specified "from" value to the
|
|
// specified "to" value.
|
|
//
|
|
// For example, calling MapNetwork("tcp", "memu") means a subsequent
|
|
// Dial("tcp", "address") gets translated to Dial("memu", "address").
|
|
//
|
|
// Calling MapNetwork("tcp", "") removes any previous translation for
|
|
// the "tcp" network.
|
|
func MapNetwork(from, to string) {
|
|
provider.MapNetwork(from, to)
|
|
}
|
|
|
|
// Listen begins listening at address for the specified network.
|
|
//
|
|
// Known networks are "memb" (memconn buffered) and "memu" (memconn unbuffered).
|
|
//
|
|
// When the specified address is already in use on the specified
|
|
// network an error is returned.
|
|
//
|
|
// When the provided network is unknown the operation defers to
|
|
// net.Dial.
|
|
func Listen(network, address string) (net.Listener, error) {
|
|
return provider.Listen(network, address)
|
|
}
|
|
|
|
// ListenMem begins listening at laddr.
|
|
//
|
|
// Known networks are "memb" (memconn buffered) and "memu" (memconn unbuffered).
|
|
//
|
|
// If laddr is nil then ListenMem listens on "localhost" on the
|
|
// specified network.
|
|
func ListenMem(network string, laddr *Addr) (*Listener, error) {
|
|
return provider.ListenMem(network, laddr)
|
|
}
|
|
|
|
// Dial dials a named connection.
|
|
//
|
|
// Known networks are "memb" (memconn buffered) and "memu" (memconn unbuffered).
|
|
//
|
|
// When the provided network is unknown the operation defers to
|
|
// net.Dial.
|
|
func Dial(network, address string) (net.Conn, error) {
|
|
return provider.Dial(network, address)
|
|
}
|
|
|
|
// DialContext dials a named connection using a
|
|
// Go context to provide timeout behavior.
|
|
//
|
|
// Please see Dial for more information.
|
|
func DialContext(
|
|
ctx context.Context,
|
|
network, address string) (net.Conn, error) {
|
|
|
|
return provider.DialContext(ctx, network, address)
|
|
}
|
|
|
|
// DialMem dials a named connection.
|
|
//
|
|
// Known networks are "memb" (memconn buffered) and "memu" (memconn unbuffered).
|
|
//
|
|
// If laddr is nil then a new address is generated using
|
|
// time.Now().UnixNano(). Please note that client addresses are
|
|
// not required to be unique.
|
|
//
|
|
// If raddr is nil then the "localhost" endpoint is used on the
|
|
// specified network.
|
|
func DialMem(network string, laddr, raddr *Addr) (*Conn, error) {
|
|
return provider.DialMem(network, laddr, raddr)
|
|
}
|
|
|
|
// DialMemContext dials a named connection using a
|
|
// Go context to provide timeout behavior.
|
|
//
|
|
// Please see DialMem for more information.
|
|
func DialMemContext(
|
|
ctx context.Context,
|
|
network string,
|
|
laddr, raddr *Addr) (*Conn, error) {
|
|
|
|
return provider.DialMemContext(ctx, network, laddr, raddr)
|
|
}
|