IPConn

constructor(aSock: Socket)

IPConn(Socket aSock)

init(_ aSock: Socket)

Sub New(aSock As Socket)

constructor(aSock: Socket)

IPConn(Socket aSock)

init(_ aSock: Socket)

Sub New(aSock As Socket)

method Close: error

error Close()

func Close() -> error

func Close() error

Function Close() As error

method CloseRead: error

error CloseRead()

func CloseRead() -> error

func CloseRead() error

Function CloseRead() As error

method CloseWrite: error

error CloseWrite()

func CloseWrite() -> error

func CloseWrite() error

Function CloseWrite() As error

method File: tuple of (File, error)

(File, error) File()

func File() -> (File, error)

func File() (File, error)

Function File() As Tuple (Of File, error)

method LocalAddr: Addr

Addr LocalAddr()

func LocalAddr() -> Addr

func LocalAddr() Addr

Function LocalAddr() As Addr

method Read(b: Slice<Byte>): tuple of (Int64, error)

(Int64, error) Read(Slice<Byte> b)

func Read(_ b: Slice<Byte>) -> (Int64, error)

func Read(b Slice<Byte>) (Int64, error)

Function Read(b As Slice<Byte>) As Tuple (Of Int64, error)

method ReadFrom(b: Slice<Byte>): tuple of (Int64, Addr, error)

(Int64, Addr, error) ReadFrom(Slice<Byte> b)

func ReadFrom(_ b: Slice<Byte>) -> (Int64, Addr, error)

func ReadFrom(b Slice<Byte>) (Int64, Addr, error)

Function ReadFrom(b As Slice<Byte>) As Tuple (Of Int64, Addr, error)

method ReadFromIP(b: Slice<Byte>): tuple of (Int64, IPAddr, error)

(Int64, IPAddr, error) ReadFromIP(Slice<Byte> b)

func ReadFromIP(_ b: Slice<Byte>) -> (Int64, IPAddr, error)

func ReadFromIP(b Slice<Byte>) (Int64, IPAddr, error)

Function ReadFromIP(b As Slice<Byte>) As Tuple (Of Int64, IPAddr, error)

method ReadFromUDP(b: Slice<Byte>): tuple of (Int64, UDPAddr, error)

(Int64, UDPAddr, error) ReadFromUDP(Slice<Byte> b)

func ReadFromUDP(_ b: Slice<Byte>) -> (Int64, UDPAddr, error)

func ReadFromUDP(b Slice<Byte>) (Int64, UDPAddr, error)

Function ReadFromUDP(b As Slice<Byte>) As Tuple (Of Int64, UDPAddr, error)

method RemoteAddr: Addr

Addr RemoteAddr()

func RemoteAddr() -> Addr

func RemoteAddr() Addr

Function RemoteAddr() As Addr

method SetDeadline(tt: Time): error

error SetDeadline(Time tt)

func SetDeadline(_ tt: Time) -> error

func SetDeadline(tt Time) error

Function SetDeadline(tt As Time) As error

method SetKeepAlive(b: Boolean): error

error SetKeepAlive(Boolean b)

func SetKeepAlive(_ b: Boolean) -> error

func SetKeepAlive(b Boolean) error

Function SetKeepAlive(b As Boolean) As error

method SetKeepAlivePeriod(d: Duration): error

error SetKeepAlivePeriod(Duration d)

func SetKeepAlivePeriod(_ d: Duration) -> error

func SetKeepAlivePeriod(d Duration) error

Function SetKeepAlivePeriod(d As Duration) As error

method SetLinger(b: Int32): error

error SetLinger(Int32 b)

func SetLinger(_ b: Int32) -> error

func SetLinger(b Int32) error

Function SetLinger(b As Int32) As error

method SetNoDelay(b: Boolean): error

error SetNoDelay(Boolean b)

func SetNoDelay(_ b: Boolean) -> error

func SetNoDelay(b Boolean) error

Function SetNoDelay(b As Boolean) As error

method SetReadBuffer(bytes: int): error

error SetReadBuffer(int bytes)

func SetReadBuffer(_ bytes: int) -> error

func SetReadBuffer(bytes int) error

Function SetReadBuffer(bytes As int) As error

method SetReadDeadline(tt: Time): error

error SetReadDeadline(Time tt)

func SetReadDeadline(_ tt: Time) -> error

func SetReadDeadline(tt Time) error

Function SetReadDeadline(tt As Time) As error

method SetWriteBuffer(bytes: int): error

error SetWriteBuffer(int bytes)

func SetWriteBuffer(_ bytes: int) -> error

func SetWriteBuffer(bytes int) error

Function SetWriteBuffer(bytes As int) As error

method SetWriteDeadline(t: Time): error

error SetWriteDeadline(Time t)

func SetWriteDeadline(_ t: Time) -> error

func SetWriteDeadline(t Time) error

Function SetWriteDeadline(t As Time) As error

method SyscallConn: tuple of (RawConn, error)

(RawConn, error) SyscallConn()

func SyscallConn() -> (RawConn, error)

func SyscallConn() (RawConn, error)

Function SyscallConn() As Tuple (Of RawConn, error)

method Write(b: Slice<Byte>): tuple of (Int64, error)

(Int64, error) Write(Slice<Byte> b)

func Write(_ b: Slice<Byte>) -> (Int64, error)

func Write(b Slice<Byte>) (Int64, error)

Function Write(b As Slice<Byte>) As Tuple (Of Int64, error)

method WriteTo(b: Slice<Byte>; addr: Addr): tuple of (Int64, error)

(Int64, error) WriteTo(Slice<Byte> b, Addr addr)

func WriteTo(_ b: Slice<Byte>, _ addr: Addr) -> (Int64, error)

func WriteTo(b Slice<Byte>, addr Addr) (Int64, error)

Function WriteTo(b As Slice<Byte>, addr As Addr) As Tuple (Of Int64, error)