Index
Modules:
chronos/asyncsync
,
chronos/bipbuffer
,
chronos/config
,
chronos/debugutils
,
chronos/futures
,
chronos/handles
,
chronos/internal/asyncengine
,
chronos/internal/asyncfutures
,
chronos/internal/asyncmacro
,
chronos/internal/errors
,
chronos/internal/raisesfutures
,
chronos/osdefs
,
chronos/oserrno
,
chronos/osutils
,
chronos/selectors2
,
chronos/sendfile
,
chronos/srcloc
,
chronos/streams/asyncstream
,
chronos/streams/chunkstream
,
chronos/timer
,
chronos/transports/common
,
chronos/transports/datagram
,
chronos/transports/ipnet
,
chronos/transports/osnet
,
chronos/transports/stream
.
API symbols
`$`:
asyncsync: `$`[T](aq: AsyncQueue[T]): string
srcloc: `$`(loc: ptr SrcLoc): string
timer: `$`(a: Duration): string
timer: `$`(a: Moment): string
common: `$`(address: TransportAddress): string
ipnet: `$`(mask: IpMask; include0x = false): string
ipnet: `$`(net: IpNet): string
osnet: `$`(ifa: InterfaceAddress): string
osnet: `$`(iface: NetworkInterface): string
osnet: `$`(route: Route): string
`>=`:
timer: `>=`(a, b: Duration): bool
timer: `>=`(a, b: Moment): bool
`>`:
timer: `>`(a, b: Duration): bool
timer: `>`(a, b: Moment): bool
`<=`:
timer: `<=`(a, b: Duration): bool
timer: `<=`(a, b: Moment): bool
`<`:
timer: `<`(a, b: Duration): bool
timer: `<`(a, b: Moment): bool
`*`:
timer: `*`(a: Duration; b: SomeIntegerI64): Duration
timer: `*`(a: SomeIntegerI64; b: Duration): Duration
`+=`:
timer: `+=`(a: var Duration; b: Duration)
timer: `+=`(a: var Moment; b: Duration)
`+`:
timer: `+`(a: Duration; b: Duration): Duration
timer: `+`(a: Duration; b: Moment): Moment
timer: `+`(a: Moment; b: Duration): Moment
ipnet: `+`(address: TransportAddress; v: int | uint): TransportAddress
`-=`:
timer: `-=`(a: var Duration; b: Duration)
timer: `-=`(a: var Moment; b: Duration)
`-`:
timer: `-`(a: Duration; b: Duration): Duration
timer: `-`(a: Moment; b: Duration): Moment
timer: `-`(a, b: Moment): Duration
ipnet: `-`(address: TransportAddress; v: int | uint): TransportAddress
`==`:
asyncengine: `==`(x: AsyncFD; y: AsyncFD): bool
osdefs: `==`(x: SocketHandle; y: int): bool
osdefs: `==`(x: SocketHandle; y: SocketHandle): bool
timer: `==`(a, b: Duration): bool
timer: `==`(a, b: Moment): bool
common: `==`(lhs, rhs: TransportAddress): bool
ipnet: `==`(m1, m2: IpMask): bool
ipnet: `==`(n1, n2: IpNet): bool
`[]=`:
asyncsync: `[]=`[T](aq: AsyncQueue[T]; i: BackwardsIndex; item: T)
asyncsync: `[]=`[T](aq: AsyncQueue[T]; i: Natural; item: T)
`[]`:
asyncsync: `[]`[T](aq: AsyncQueue[T]; i: BackwardsIndex): T
asyncsync: `[]`[T](aq: AsyncQueue[T]; i: Natural): T
asyncfutures: `[]`(loc: array[LocationKind, ptr SrcLoc]; v: int): ptr SrcLoc
`and`:
asyncfutures: `and`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
ipnet: `and`(address1, address2: TransportAddress): TransportAddress
`div`:
timer: `div`(a: Duration; b: SomeIntegerI64): Duration
`not`:
ipnet: `not`(address: TransportAddress): TransportAddress
`or`:
asyncfutures: `or`[T, Y](fut1: Future[T]; fut2: Future[Y]): Future[void]
asyncfutures: `or`[T, Y, E1, E2](fut1: InternalRaisesFuture[T, E1]; fut2: InternalRaisesFuture[Y, E2]): auto
ipnet: `or`(address1, address2: TransportAddress): TransportAddress
accept:
stream: accept(server: StreamServer): InternalRaisesFuture[StreamTransport, ( TransportUseClosedError, TransportTooManyError, TransportAbortedError, TransportOsError, CancelledError)]
accept4:
osdefs: accept4(a1: cint; a2: ptr SockAddr; a3: ptr SockLen; a4: cint): cint
acceptConn:
osutils: acceptConn(a1: cint; a2: ptr SockAddr; a3: ptr SockLen; a4: set[DescriptorFlag]): Result[ cint, OSErrorCode]
acquire:
asyncsync: acquire(lock: AsyncLock): InternalRaisesFuture[void, (CancelledError,)]
addCallback:
asyncfutures: addCallback(future: FutureBase; cb: CallbackFunc)
asyncfutures: addCallback(future: FutureBase; cb: CallbackFunc; udata: pointer)
addFirst:
asyncsync: addFirst[T](aq: AsyncQueue[T]; item: T): InternalRaisesFuture[void, (CancelledError,)]
addFirstNoWait:
asyncsync: addFirstNoWait[T](aq: AsyncQueue[T]; item: T)
addLast:
asyncsync: addLast[T](aq: AsyncQueue[T]; item: T): InternalRaisesFuture[void, (CancelledError,)]
addLastNoWait:
asyncsync: addLastNoWait[T](aq: AsyncQueue[T]; item: T)
addReader2:
asyncengine: addReader2(fd: AsyncFD; cb: CallbackFunc; udata: pointer = nil): Result[void, OSErrorCode]
address:
common: address(ta: TransportAddress): IpAddress
AddressFamily:
common: AddressFamily
addTimer:
asyncengine: addTimer(at: int64; cb: CallbackFunc; udata: pointer = nil)
asyncengine: addTimer(at: Moment; cb: CallbackFunc; udata: pointer = nil)
asyncengine: addTimer(at: uint64; cb: CallbackFunc; udata: pointer = nil)
addTracker:
asyncengine: addTracker[T](id: string; tracker: T)
addWriter2:
asyncengine: addWriter2(fd: AsyncFD; cb: CallbackFunc; udata: pointer = nil): Result[void, OSErrorCode]
AF_NETLINK:
osdefs: AF_NETLINK
AF_PACKET:
osdefs: AF_PACKET
all:
asyncfutures: all[T](futs: varargs[Future[T]]): auto
allFinished:
asyncfutures: allFinished[F: SomeFuture](futs: varargs[F]): InternalRaisesFuture[seq[F], (CancelledError,)]
allFutures:
asyncfutures: allFutures[T](futs: varargs[Future[T]]): InternalRaisesFuture[void, (CancelledError,)]
asyncfutures: allFutures(futs: varargs[FutureBase]): InternalRaisesFuture[void, (CancelledError,)]
asyncfutures: allFutures[T, E](futs: varargs[InternalRaisesFuture[T, E]]): InternalRaisesFuture[ void, (CancelledError,)]
AllFutureStates:
debugutils: AllFutureStates
AnyAddress:
common: AnyAddress
AnyAddress6:
common: AnyAddress6
ARPHRD_ARCNET:
osdefs: ARPHRD_ARCNET
ARPHRD_ATM:
osdefs: ARPHRD_ATM
ARPHRD_CISCO:
osdefs: ARPHRD_CISCO
ARPHRD_CSLIP:
osdefs: ARPHRD_CSLIP
ARPHRD_CSLIP6:
osdefs: ARPHRD_CSLIP6
ARPHRD_EETHER:
osdefs: ARPHRD_EETHER
ARPHRD_ETHER:
osdefs: ARPHRD_ETHER
ARPHRD_FRAD:
osdefs: ARPHRD_FRAD
ARPHRD_HDLC:
osdefs: ARPHRD_HDLC
ARPHRD_HIPPI:
osdefs: ARPHRD_HIPPI
ARPHRD_IEEE1394:
osdefs: ARPHRD_IEEE1394
ARPHRD_IEEE80211:
osdefs: ARPHRD_IEEE80211
ARPHRD_IEEE80211_PRISM:
osdefs: ARPHRD_IEEE80211_PRISM
ARPHRD_IEEE80211_RADIOTAP:
osdefs: ARPHRD_IEEE80211_RADIOTAP
ARPHRD_LAPB:
osdefs: ARPHRD_LAPB
ARPHRD_LOOPBACK:
osdefs: ARPHRD_LOOPBACK
ARPHRD_PPP:
osdefs: ARPHRD_PPP
ARPHRD_SLIP:
osdefs: ARPHRD_SLIP
ARPHRD_SLIP6:
osdefs: ARPHRD_SLIP6
async:
asyncmacro: async(prc: untyped): untyped
asyncmacro: async(params, prc: untyped): untyped
AsyncBuffer:
asyncstream: AsyncBuffer
AsyncBufferRef:
asyncstream: AsyncBufferRef
AsyncCallback:
asyncengine: AsyncCallback
asyncCheck:
asyncfutures: asyncCheck[T](future: Future[T])
AsyncDescriptorDefault:
osutils: AsyncDescriptorDefault
asyncDiscard:
asyncfutures: asyncDiscard[T](future: Future[T])
AsyncError:
errors: AsyncError
AsyncEvent:
asyncsync: AsyncEvent
AsyncEventQueue:
asyncsync: AsyncEventQueue
AsyncEventQueueFullError:
asyncsync: AsyncEventQueueFullError
AsyncExceptionError:
errors: AsyncExceptionError
AsyncFD:
asyncengine: AsyncFD
asyncInvalidPipe:
handles: asyncInvalidPipe
asyncInvalidSocket:
handles: asyncInvalidSocket
AsyncLock:
asyncsync: AsyncLock
AsyncLockError:
asyncsync: AsyncLockError
AsyncQueue:
asyncsync: AsyncQueue
AsyncQueueEmptyError:
asyncsync: AsyncQueueEmptyError
AsyncQueueFullError:
asyncsync: AsyncQueueFullError
asyncSpawn:
asyncfutures: asyncSpawn(future: Future[void])
AsyncStream:
asyncstream: AsyncStream
AsyncStreamDefaultBufferSize:
asyncstream: AsyncStreamDefaultBufferSize
AsyncStreamDefaultQueueSize:
asyncstream: AsyncStreamDefaultQueueSize
AsyncStreamError:
asyncstream: AsyncStreamError
AsyncStreamIncompleteError:
asyncstream: AsyncStreamIncompleteError
AsyncStreamIncorrectDefect:
asyncstream: AsyncStreamIncorrectDefect
AsyncStreamLimitError:
asyncstream: AsyncStreamLimitError
AsyncStreamReader:
asyncstream: AsyncStreamReader
AsyncStreamReadError:
asyncstream: AsyncStreamReadError
AsyncStreamReaderTrackerName:
asyncstream: AsyncStreamReaderTrackerName
AsyncStreamRW:
asyncstream: AsyncStreamRW
AsyncStreamState:
asyncstream: AsyncStreamState
AsyncStreamUseClosedError:
asyncstream: AsyncStreamUseClosedError
AsyncStreamWriteEOFError:
asyncstream: AsyncStreamWriteEOFError
AsyncStreamWriteError:
asyncstream: AsyncStreamWriteError
AsyncStreamWriter:
asyncstream: AsyncStreamWriter
AsyncStreamWriterTrackerName:
asyncstream: AsyncStreamWriterTrackerName
AsyncTimeoutError:
errors: AsyncTimeoutError
asyncTimer:
timer: asyncTimer
atEof:
asyncstream: atEof(rstream: AsyncStreamReader): bool
asyncstream: atEof(wstream: AsyncStreamWriter): bool
stream: atEof(transp: StreamTransport): bool
availSpace:
bipbuffer: availSpace(bp: BipBuffer): Natural
await:
asyncmacro: await[T](f: Future[T]): T
asyncmacro: await[T, E](fut: InternalRaisesFuture[T, E]): T
awaitne:
asyncmacro: awaitne[T](f: Future[T]): Future[T]
BipBuffer:
bipbuffer: BipBuffer
Broadcast:
ServerFlags.Broadcast
broadcast:
ipnet: broadcast(net: IpNet): TransportAddress
osnet: broadcast(ifa: InterfaceAddress): TransportAddress
callback=:
asyncfutures: callback=(future: FutureBase; cb: CallbackFunc)
asyncfutures: callback=(future: FutureBase; cb: CallbackFunc; udata: pointer)
CallbackFunc:
futures: CallbackFunc
callIdle:
asyncengine: callIdle(cbproc: CallbackFunc)
asyncengine: callIdle(cbproc: CallbackFunc; data: pointer)
asyncengine: callIdle(acb: AsyncCallback)
callSoon:
asyncengine: callSoon(cbproc: CallbackFunc)
asyncengine: callSoon(cbproc: CallbackFunc; data: pointer)
asyncengine: callSoon(acb: AsyncCallback)
cancel:
asyncfutures: cancel(future: FutureBase)
cancelAndSchedule:
asyncfutures: cancelAndSchedule(future: FutureBase)
cancelAndWait:
asyncfutures: cancelAndWait(future: FutureBase; loc: ptr SrcLoc): InternalRaisesFuture[void, void]
asyncfutures: cancelAndWait(future: FutureBase): Future[void].Raising([])
cancelCallback=:
asyncfutures: cancelCallback=(future: FutureBase; cb: CallbackFunc)
cancelled:
futures: cancelled(future: FutureBase): bool
CancelledError:
futures: CancelledError
cancelSoon:
asyncfutures: cancelSoon(fut: FutureBase)
asyncfutures: cancelSoon(fut: FutureBase; cb: CallbackFunc)
asyncfutures: cancelSoon(fut: FutureBase; cb: CallbackFunc; udata: pointer)
asyncfutures: cancelSoon(fut: FutureBase; acb: AsyncCallback)
checkClosed:
common: checkClosed(t: untyped)
common: checkClosed(t: untyped; future: untyped)
checkRaises:
raisesfutures: checkRaises[T: CatchableError](future: InternalRaisesFuture; raises: typed; error: ref T; warn: static bool = true): untyped
checkStreamClosed:
asyncstream: checkStreamClosed(t: untyped)
checkStreamFinished:
asyncstream: checkStreamFinished(t: untyped)
checkWriteEof:
common: checkWriteEof(t: untyped; future: untyped)
chronosDumpAsync:
config: chronosDumpAsync
chronosEventEngine:
config: chronosEventEngine
chronosEventsCount:
config: chronosEventsCount
chronosFutureId:
config: chronosFutureId
chronosFutureTracking:
config: chronosFutureTracking
chronosHandleException:
config: chronosHandleException
chronosHasRaises:
config: chronosHasRaises
chronosInitialSize:
config: chronosInitialSize
chronosMoveSink:
config: chronosMoveSink(val: auto): untyped
chronosProcShell:
config: chronosProcShell
chronosStackTrace:
config: chronosStackTrace
chronosStreamDefaultBufferSize:
config: chronosStreamDefaultBufferSize
chronosStrictFutureAccess:
config: chronosStrictFutureAccess
chronosTLSSessionCacheBufferSize:
config: chronosTLSSessionCacheBufferSize
chronosTransportDefaultBufferSize:
config: chronosTransportDefaultBufferSize
ChunkedStreamError:
chunkstream: ChunkedStreamError
ChunkedStreamIncompleteError:
chunkstream: ChunkedStreamIncompleteError
ChunkedStreamProtocolError:
chunkstream: ChunkedStreamProtocolError
ChunkedStreamReader:
chunkstream: ChunkedStreamReader
ChunkedStreamWriter:
chunkstream: ChunkedStreamWriter
clear:
asyncsync: clear(event: AsyncEvent)
asyncsync: clear[T](aq: AsyncQueue[T])
clearTimer:
asyncengine: clearTimer(timer: TimerCallback)
close:
asyncsync: close(ab: AsyncEventQueue)
selectors2: close(ev: SelectEvent)
selectors2: close[T](s: Selector[T])
asyncstream: close(rw: AsyncStreamRW)
datagram: close(transp: DatagramTransport)
stream: close(server: StreamServer)
stream: close(transp: StreamTransport)
Closed:
AsyncStreamState.Closed
closed:
asyncstream: closed(rw: AsyncStreamRW): bool
Closed:
ServerStatus.Closed
closed:
datagram: closed(transp: DatagramTransport): bool
stream: closed(server: StreamServer): bool
stream: closed(transp: StreamTransport): bool
closeFd:
osutils: closeFd(s: cint): int
osutils: closeFd(s: SocketHandle): int
closeHandle:
asyncengine: closeHandle(fd: AsyncFD; aftercb: CallbackFunc = nil)
closeSocket:
asyncengine: closeSocket(fd: AsyncFD; aftercb: CallbackFunc = nil)
closeWait:
asyncsync: closeWait(ab: AsyncEventQueue): InternalRaisesFuture[void, void]
asyncstream: closeWait(rw: AsyncStreamRW): InternalRaisesFuture[void, void]
datagram: closeWait(transp: DatagramTransport): InternalRaisesFuture[void, void]
stream: closeWait(server: StreamServer): InternalRaisesFuture[void, void]
stream: closeWait(transp: StreamTransport): InternalRaisesFuture[void, void]
Closing:
AsyncStreamState.Closing
cmp:
osnet: cmp(a, b: NetworkInterface): int
commit:
bipbuffer: commit(bp: var BipBuffer; size: Natural)
complete:
asyncfutures: complete[T](future: Future[T]; val: T)
asyncfutures: complete(future: Future[void])
completed:
futures: completed(future: FutureBase): bool
futures: completed(F: type Future; fromProc: static[string] = ""): Future[void]
futures: completed[T: not void](F: type Future; valueParam: T; fromProc: static[string] = ""): Future[T]
connect:
stream: connect(address: TransportAddress; bufferSize = DefaultStreamBufferSize; child: StreamTransport = nil; localAddress = TransportAddress(); flags: set[SocketFlags] = {}; dualstack = DualStackType.Auto): InternalRaisesFuture[ StreamTransport, (TransportError, CancelledError)]
stream: connect(address: TransportAddress; bufferSize = DefaultStreamBufferSize; child: StreamTransport = nil; flags: set[TransportFlags]; localAddress = TransportAddress(); dualstack = DualStackType.Auto): InternalRaisesFuture[ StreamTransport, (TransportError, CancelledError)]
consume:
bipbuffer: consume(bp: var BipBuffer; size: Natural)
asyncstream: consume(rstream: AsyncStreamReader): InternalRaisesFuture[int, (CancelledError, AsyncStreamError)]
asyncstream: consume(rstream: AsyncStreamReader; n: int): InternalRaisesFuture[int, (CancelledError, AsyncStreamError)]
stream: consume(transp: StreamTransport): InternalRaisesFuture[int, (TransportError, CancelledError)]
stream: consume(transp: StreamTransport; n: int): InternalRaisesFuture[int, (TransportError, CancelledError)]
contains:
asyncsync: contains[T](aq: AsyncQueue[T]; item: T): bool
selectors2: contains[T](s: Selector[T]; fd: SocketHandle | int): bool
ipnet: contains(net: IpNet; address: TransportAddress): bool
copyOut:
asyncstream: copyOut(dest: pointer; item: WriteItem; length: int)
createAsyncPipe:
handles: createAsyncPipe(): tuple[read: AsyncFD, write: AsyncFD]
createAsyncSocket:
handles: createAsyncSocket(domain: Domain; sockType: SockType; protocol: Protocol; inherit = true): AsyncFD
createAsyncSocket2:
handles: createAsyncSocket2(domain: Domain; sockType: SockType; protocol: Protocol; inherit = true): Result[AsyncFD, OSErrorCode]
createOsPipe:
osutils: createOsPipe(readset, writeset: set[DescriptorFlag]): Result[ tuple[read: cint, write: cint], OSErrorCode]
createStreamServer:
stream: createStreamServer(port: Port; host: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; udata: pointer = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer[T](port: Port; host: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer(cbproc: StreamCallback2; port: Port; host: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; udata: pointer = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer[T](cbproc: StreamCallback2; port: Port; host: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer(host: TransportAddress; flags: set[ServerFlags] = {}; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; udata: pointer = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer[T](host: TransportAddress; flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer(host: TransportAddress; cbproc: StreamCallback; flags: set[ServerFlags] = {}; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; udata: pointer = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer[T](host: TransportAddress; cbproc: StreamCallback; flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer(host: TransportAddress; cbproc: StreamCallback2; flags: set[ServerFlags] = {}; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; udata: pointer = nil; dualstack = DualStackType.Auto): StreamServer
stream: createStreamServer[T](host: TransportAddress; cbproc: StreamCallback2; flags: set[ServerFlags] = {}; udata: ref T; sock: AsyncFD = asyncInvalidSocket; backlog: int = DefaultBacklogSize; bufferSize: int = DefaultStreamBufferSize; child: StreamServer = nil; init: TransportInitCallback = nil; dualstack = DualStackType.Auto): StreamServer
DatagramCallback:
datagram: DatagramCallback
DatagramTransport:
datagram: DatagramTransport
Day:
timer: Day
days:
timer: days(v: Duration): int64
timer: days(v: SomeIntegerI64): Duration
dec:
ipnet: dec(address: var TransportAddress; v: int = 1)
DefaultBacklogSize:
stream: DefaultBacklogSize
DefaultDatagramBufferSize:
common: DefaultDatagramBufferSize
DefaultStreamBufferSize:
common: DefaultStreamBufferSize
DescriptorFlag:
osutils: DescriptorFlag
DgramTransportTrackerName:
datagram: DgramTransportTrackerName
done:
asyncfutures: done(future: FutureBase): bool
DualStackType:
common: DualStackType
dumpPendingFutures:
debugutils: dumpPendingFutures(filter = AllFutureStates): string
Duration:
timer: Duration
E2BIG:
oserrno: E2BIG
EACCES:
oserrno: EACCES
EADDRINUSE:
oserrno: EADDRINUSE
EADDRNOTAVAIL:
oserrno: EADDRNOTAVAIL
EADV:
oserrno: EADV
EAFNOSUPPORT:
oserrno: EAFNOSUPPORT
EAGAIN:
oserrno: EAGAIN
EALREADY:
oserrno: EALREADY
EBADE:
oserrno: EBADE
EBADF:
oserrno: EBADF
EBADFD:
oserrno: EBADFD
EBADMSG:
oserrno: EBADMSG
EBADR:
oserrno: EBADR
EBADRQC:
oserrno: EBADRQC
EBADSLT:
oserrno: EBADSLT
EBFONT:
oserrno: EBFONT
EBUSY:
oserrno: EBUSY
ECANCELED:
oserrno: ECANCELED
ECHILD:
oserrno: ECHILD
ECHRNG:
oserrno: ECHRNG
ECOMM:
oserrno: ECOMM
ECONNABORTED:
oserrno: ECONNABORTED
ECONNREFUSED:
oserrno: ECONNREFUSED
ECONNRESET:
oserrno: ECONNRESET
EDEADLK:
oserrno: EDEADLK
EDEADLOCK:
oserrno: EDEADLOCK
EDESTADDRREQ:
oserrno: EDESTADDRREQ
EDOM:
oserrno: EDOM
EDOTDOT:
oserrno: EDOTDOT
EDQUOT:
oserrno: EDQUOT
EEXIST:
oserrno: EEXIST
EFAULT:
oserrno: EFAULT
EFBIG:
oserrno: EFBIG
EFD_CLOEXEC:
osdefs: EFD_CLOEXEC
EFD_NONBLOCK:
osdefs: EFD_NONBLOCK
EHOSTDOWN:
oserrno: EHOSTDOWN
EHOSTUNREACH:
oserrno: EHOSTUNREACH
EHWPOISON:
oserrno: EHWPOISON
EIDRM:
oserrno: EIDRM
EILSEQ:
oserrno: EILSEQ
EINPROGRESS:
oserrno: EINPROGRESS
EINTR:
oserrno: EINTR
EINVAL:
oserrno: EINVAL
EIO:
oserrno: EIO
EISCONN:
oserrno: EISCONN
EISDIR:
oserrno: EISDIR
EISNAM:
oserrno: EISNAM
EKEYEXPIRED:
oserrno: EKEYEXPIRED
EKEYREJECTED:
oserrno: EKEYREJECTED
EKEYREVOKED:
oserrno: EKEYREVOKED
EL2HLT:
oserrno: EL2HLT
EL2NSYNC:
oserrno: EL2NSYNC
EL3HLT:
oserrno: EL3HLT
EL3RST:
oserrno: EL3RST
ELIBACC:
oserrno: ELIBACC
ELIBBAD:
oserrno: ELIBBAD
ELIBEXEC:
oserrno: ELIBEXEC
ELIBMAX:
oserrno: ELIBMAX
ELIBSCN:
oserrno: ELIBSCN
ELNRNG:
oserrno: ELNRNG
ELOOP:
oserrno: ELOOP
EMEDIUMTYPE:
oserrno: EMEDIUMTYPE
EMFILE:
oserrno: EMFILE
emit:
asyncsync: emit[T](ab: AsyncEventQueue[T]; data: T)
EMLINK:
oserrno: EMLINK
empty:
asyncsync: empty[T](aq: AsyncQueue[T]): bool
EMSGSIZE:
oserrno: EMSGSIZE
EMULTIHOP:
oserrno: EMULTIHOP
ENAMETOOLONG:
oserrno: ENAMETOOLONG
ENAVAIL:
oserrno: ENAVAIL
ENETDOWN:
oserrno: ENETDOWN
ENETRESET:
oserrno: ENETRESET
ENETUNREACH:
oserrno: ENETUNREACH
ENFILE:
oserrno: ENFILE
ENOANO:
oserrno: ENOANO
ENOBUFS:
oserrno: ENOBUFS
ENOCSI:
oserrno: ENOCSI
ENODATA:
oserrno: ENODATA
ENODEV:
oserrno: ENODEV
ENOENT:
oserrno: ENOENT
ENOEXEC:
oserrno: ENOEXEC
ENOKEY:
oserrno: ENOKEY
ENOLCK:
oserrno: ENOLCK
ENOLINK:
oserrno: ENOLINK
ENOMEDIUM:
oserrno: ENOMEDIUM
ENOMEM:
oserrno: ENOMEM
ENOMSG:
oserrno: ENOMSG
ENONET:
oserrno: ENONET
ENOPKG:
oserrno: ENOPKG
ENOPROTOOPT:
oserrno: ENOPROTOOPT
ENOSPC:
oserrno: ENOSPC
ENOSR:
oserrno: ENOSR
ENOSTR:
oserrno: ENOSTR
ENOSYS:
oserrno: ENOSYS
ENOTBLK:
oserrno: ENOTBLK
ENOTCONN:
oserrno: ENOTCONN
ENOTDIR:
oserrno: ENOTDIR
ENOTEMPTY:
oserrno: ENOTEMPTY
ENOTNAM:
oserrno: ENOTNAM
ENOTRECOVERABLE:
oserrno: ENOTRECOVERABLE
ENOTSOCK:
oserrno: ENOTSOCK
ENOTTY:
oserrno: ENOTTY
ENOTUNIQ:
oserrno: ENOTUNIQ
ENXIO:
oserrno: ENXIO
EOPNOTSUPP:
oserrno: EOPNOTSUPP
EOVERFLOW:
oserrno: EOVERFLOW
EOWNERDEAD:
oserrno: EOWNERDEAD
EPERM:
oserrno: EPERM
EPFNOSUPPORT:
oserrno: EPFNOSUPPORT
EPIPE:
oserrno: EPIPE
epochNanoSeconds:
timer: epochNanoSeconds(moment: Moment): int64
epochSeconds:
timer: epochSeconds(moment: Moment): int64
epoll_create:
osdefs: epoll_create(size: cint): cint
epoll_create1:
osdefs: epoll_create1(flags: cint): cint
epoll_ctl:
osdefs: epoll_ctl(epfd: cint; op: cint; fd: cint; event: ptr EpollEvent): cint
EPOLL_CTL_ADD:
osdefs: EPOLL_CTL_ADD
EPOLL_CTL_DEL:
osdefs: EPOLL_CTL_DEL
EPOLL_CTL_MOD:
osdefs: EPOLL_CTL_MOD
EpollData:
osdefs: EpollData
EPOLLERR:
osdefs: EPOLLERR
EPOLLET:
osdefs: EPOLLET
EpollEvent:
osdefs: EpollEvent
EPOLLEXCLUSIVE:
osdefs: EPOLLEXCLUSIVE
EPOLLHUP:
osdefs: EPOLLHUP
EPOLLIN:
osdefs: EPOLLIN
EPOLLMSG:
osdefs: EPOLLMSG
EPOLLONESHOT:
osdefs: EPOLLONESHOT
EPOLLOUT:
osdefs: EPOLLOUT
EPOLLPRI:
osdefs: EPOLLPRI
EPOLLRDBAND:
osdefs: EPOLLRDBAND
EPOLLRDHUP:
osdefs: EPOLLRDHUP
EPOLLRDNORM:
osdefs: EPOLLRDNORM
epoll_wait:
osdefs: epoll_wait(epfd: cint; events: ptr EpollEvent; maxevents: cint; timeout: cint): cint
EPOLLWAKEUP:
osdefs: EPOLLWAKEUP
EPOLLWRBAND:
osdefs: EPOLLWRBAND
EPOLLWRNORM:
osdefs: EPOLLWRNORM
EPROTO:
oserrno: EPROTO
EPROTONOSUPPORT:
oserrno: EPROTONOSUPPORT
EPROTOTYPE:
oserrno: EPROTOTYPE
ERANGE:
oserrno: ERANGE
EREMCHG:
oserrno: EREMCHG
EREMOTE:
oserrno: EREMOTE
EREMOTEIO:
oserrno: EREMOTEIO
ERESTART:
oserrno: ERESTART
ERFKILL:
oserrno: ERFKILL
EROFS:
oserrno: EROFS
error:
futures: error(future: FutureBase): ref CatchableError
raisesfutures: error[T](future: InternalRaisesFuture[T, void]): ref CatchableError
Error:
AsyncStreamState.Error
ESHUTDOWN:
oserrno: ESHUTDOWN
ESOCKTNOSUPPORT:
oserrno: ESOCKTNOSUPPORT
ESPIPE:
oserrno: ESPIPE
ESRCH:
oserrno: ESRCH
ESRMNT:
oserrno: ESRMNT
ESTALE:
oserrno: ESTALE
ESTRPIPE:
oserrno: ESTRPIPE
ETIME:
oserrno: ETIME
ETIMEDOUT:
oserrno: ETIMEDOUT
ETOOMANYREFS:
oserrno: ETOOMANYREFS
ETXTBSY:
oserrno: ETXTBSY
EUCLEAN:
oserrno: EUCLEAN
EUNATCH:
oserrno: EUNATCH
EUSERS:
oserrno: EUSERS
Event:
selectors2: Event
eventfd:
osdefs: eventfd(count: cuint; flags: cint): cint
EventQueueKey:
asyncsync: EventQueueKey
EventQueueReader:
asyncsync: EventQueueReader
EWOULDBLOCK:
oserrno: EWOULDBLOCK
EXDEV:
oserrno: EXDEV
EXFULL:
oserrno: EXFULL
fail:
asyncfutures: fail[T](future: Future[T]; error: ref CatchableError; warn: static bool = false)
asyncfutures: fail[T, E](future: InternalRaisesFuture[T, E]; error: ref CatchableError; warn: static bool = true)
failed:
futures: failed(future: FutureBase): bool
futures: failed[T](F: type Future[T]; errorParam: ref CatchableError; fromProc: static[string] = ""): Future[T]
raisesfutures: failed[T](future: InternalRaisesFuture[T, void]): bool
asyncstream: failed(rw: AsyncStreamRW): bool
stream: failed(transp: StreamTransport): bool
fastEpochTime:
timer: fastEpochTime(): uint64
finish:
asyncstream: finish(wstream: AsyncStreamWriter): InternalRaisesFuture[void, (CancelledError, AsyncStreamError)]
finished:
futures: finished(future: FutureBase): bool
Finished:
asyncfutures: Finished()
asyncfutures: Finished(T: type FutureState): FutureState
AsyncStreamState.Finished
finished:
asyncstream: finished(rw: AsyncStreamRW): bool
stream: finished(transp: StreamTransport): bool
fire:
asyncsync: fire(event: AsyncEvent)
FirstPipe:
ServerFlags.FirstPipe
flags:
futures: flags(future: FutureBase): FutureFlags
forget:
asyncstream: forget(sb: AsyncBufferRef)
fromNow:
timer: fromNow(t: typedesc[Moment]; a: Duration): Moment
fromPipe:
stream: fromPipe(fd: AsyncFD; child: StreamTransport = nil; bufferSize = DefaultStreamBufferSize): StreamTransport
fromPipe2:
stream: fromPipe2(fd: AsyncFD; child: StreamTransport = nil; bufferSize = DefaultStreamBufferSize): Result[StreamTransport, OSErrorCode]
fromSAddr:
common: fromSAddr(sa: ptr Sockaddr_storage; sl: SockLen; address: var TransportAddress)
full:
asyncsync: full[T](aq: AsyncQueue[T]): bool
Future:
futures: Future
FutureBase:
futures: FutureBase
FutureCompletedError:
asyncfutures: FutureCompletedError
futureContinue:
asyncfutures: futureContinue(fut: FutureBase)
FutureDefect:
futures: FutureDefect
FutureError:
futures: FutureError
FutureFlag:
futures: FutureFlag
FutureFlags:
futures: FutureFlags
FuturePendingError:
asyncfutures: FuturePendingError
FutureSeq:
asyncfutures: FutureSeq
FutureState:
futures: FutureState
FutureStr:
asyncfutures: FutureStr
GCUserData:
ServerFlags.GCUserData
get:
asyncsync: get[T](aq: AsyncQueue[T]): InternalRaisesFuture[T, (CancelledError,)]
getAsyncTimestamp:
asyncengine: getAsyncTimestamp(a: Duration): auto
getAutoAddress:
common: getAutoAddress(port: Port): TransportAddress
getAutoAddresses:
common: getAutoAddresses(localPort: Port; remotePort: Port): tuple[ local: TransportAddress, remote: TransportAddress]
getBestRoute:
osnet: getBestRoute(address: TransportAddress): Route
getConnectionAbortedError:
common: getConnectionAbortedError(code: OSErrorCode): ref TransportAbortedError
common: getConnectionAbortedError(m: string = ""): ref TransportAbortedError
getData:
selectors2: getData[T](s: Selector[T]; fd: SocketHandle | int): var T
getDescriptorInheritance:
osutils: getDescriptorInheritance(s: cint): Result[bool, OSErrorCode]
getDomain:
common: getDomain(socket: AsyncFD): Result[AddressFamily, OSErrorCode]
common: getDomain(address: TransportAddress): Domain
getDualstack:
handles: getDualstack(fd: AsyncFD): Result[bool, OSErrorCode]
getError:
common: getError(t: untyped): ref TransportError
getFd:
selectors2: getFd[T](s: Selector[T]): int
getGlobalDispatcher:
asyncengine: getGlobalDispatcher(): PDispatcher
getInheritable:
handles: getInheritable(fd: AsyncFD): Result[bool, OSErrorCode]
getInterfaces:
osnet: getInterfaces(): seq[NetworkInterface]
getMaxOpenFiles:
handles: getMaxOpenFiles(): int
getMaxOpenFiles2:
handles: getMaxOpenFiles2(): Result[int, OSErrorCode]
getMessage:
datagram: getMessage(transp: DatagramTransport): seq[byte]
getNoWait:
asyncsync: getNoWait[T](aq: AsyncQueue[T]): T
getRaisesTypes:
raisesfutures: getRaisesTypes(raises: NimNode): NimNode
getServerUseClosedError:
common: getServerUseClosedError(): ref TransportUseClosedError
getSocketError:
handles: getSocketError(socket: AsyncFD; err: var int): bool
getSocketError2:
handles: getSocketError2(socket: AsyncFD): Result[cint, OSErrorCode]
getSockOpt:
handles: getSockOpt(socket: AsyncFD; level, optname: int; value: var int): bool
handles: getSockOpt(socket: AsyncFD; level, optname: int; value: var pointer; valuelen: var int): bool
getSockOpt2:
handles: getSockOpt2(socket: AsyncFD; level, optname: int): Result[cint, OSErrorCode]
handles: getSockOpt2(socket: AsyncFD; level, optname: int; T: type): Result[T, OSErrorCode]
getSrcLocation:
srcloc: getSrcLocation(procedure: static string = ""): ptr SrcLoc
getThreadDispatcher:
asyncengine: getThreadDispatcher(): PDispatcher
getTracker:
asyncengine: getTracker(id: string): TrackerBase
getTrackerCounter:
asyncengine: getTrackerCounter(name: string): TrackerCounter
getTransportError:
common: getTransportError(ecode: OSErrorCode): untyped
getTransportOsError:
common: getTransportOsError(err: cint): ref TransportOsError
common: getTransportOsError(err: OSErrorCode): ref TransportOsError
getTransportTooManyError:
common: getTransportTooManyError(code = OSErrorCode(0)): ref TransportTooManyError
getTransportUseClosedError:
common: getTransportUseClosedError(): ref TransportUseClosedError
getUserData:
asyncstream: getUserData[T](rw: AsyncStreamRW): T
datagram: getUserData[T](transp: DatagramTransport): T
stream: getUserData[T](server: StreamServer): T
handleEintr:
osutils: handleEintr(body: untyped): untyped
hexValue:
chunkstream: hexValue(c: byte): int
high:
timer: high(T: typedesc[Duration]): Duration
timer: high(T: typedesc[Moment]): Moment
host:
common: host(ta: TransportAddress): string
Hour:
timer: Hour
hours:
timer: hours(v: Duration): int64
timer: hours(v: SomeIntegerI64): Duration
id:
futures: id(fut: FutureBase): uint
idleAsync:
asyncfutures: idleAsync(): InternalRaisesFuture[void, (CancelledError,)]
IfA12MppSwitch:
InterfaceType.IfA12MppSwitch
IFA_ADDRESS:
osdefs: IFA_ADDRESS
IfAal2:
InterfaceType.IfAal2
IfAal5:
InterfaceType.IfAal5
IfAddrMessage:
osdefs: IfAddrMessage
IfAdsl:
InterfaceType.IfAdsl
IfAflane8023:
InterfaceType.IfAflane8023
IfAflane8025:
InterfaceType.IfAflane8025
IFA_LOCAL:
osdefs: IFA_LOCAL
IfArap:
InterfaceType.IfArap
IfArcNet:
InterfaceType.IfArcNet
IfArcNetPlus:
InterfaceType.IfArcNetPlus
IfAsync:
InterfaceType.IfAsync
IfAtm:
InterfaceType.IfAtm
IfAtmDxi:
InterfaceType.IfAtmDxi
IfAtmFuni:
InterfaceType.IfAtmFuni
IfAtmIma:
InterfaceType.IfAtmIma
IfAtmLogical:
InterfaceType.IfAtmLogical
IfAtmRadio:
InterfaceType.IfAtmRadio
IfAtmSubInterface:
InterfaceType.IfAtmSubInterface
IfAtmVciEndpt:
InterfaceType.IfAtmVciEndpt
IfAtmVirtual:
InterfaceType.IfAtmVirtual
IfBasicIsdn:
InterfaceType.IfBasicIsdn
IfBgpPolicyAccounting:
InterfaceType.IfBgpPolicyAccounting
IfBsc:
InterfaceType.IfBsc
IfCctemul:
InterfaceType.IfCctemul
IfCes:
InterfaceType.IfCes
IfChannel:
InterfaceType.IfChannel
IfCnr:
InterfaceType.IfCnr
IfCoffee:
InterfaceType.IfCoffee
IfCompositeLink:
InterfaceType.IfCompositeLink
IfDcn:
InterfaceType.IfDcn
IfDdnX25:
InterfaceType.IfDdnX25
IfDigitalPowerline:
InterfaceType.IfDigitalPowerline
IfDigitalWrapperOverheadChannel:
InterfaceType.IfDigitalWrapperOverheadChannel
IfDlsw:
InterfaceType.IfDlsw
IfDocScableDownstream:
InterfaceType.IfDocScableDownstream
IfDocScableMaclayer:
InterfaceType.IfDocScableMaclayer
IfDocScableUpstream:
InterfaceType.IfDocScableUpstream
IfDs0:
InterfaceType.IfDs0
IfDs0Bundle:
InterfaceType.IfDs0Bundle
IfDs1:
InterfaceType.IfDs1
IfDs1Fdl:
InterfaceType.IfDs1Fdl
IfDs3:
InterfaceType.IfDs3
IfDtm:
InterfaceType.IfDtm
IfDvbAsiIn:
InterfaceType.IfDvbAsiIn
IfDvbAsiOut:
InterfaceType.IfDvbAsiOut
IfDvbrccDownstream:
InterfaceType.IfDvbrccDownstream
IfDvbrccMaclayer:
InterfaceType.IfDvbrccMaclayer
IfDvbrccUpstream:
InterfaceType.IfDvbrccUpstream
IfE1:
InterfaceType.IfE1
IfEon:
InterfaceType.IfEon
IfEplrs:
InterfaceType.IfEplrs
IfError:
InterfaceType.IfError
IfEscon:
InterfaceType.IfEscon
IfEthernet3Mbit:
InterfaceType.IfEthernet3Mbit
IfEthernetCsmacd:
InterfaceType.IfEthernetCsmacd
IfFast:
InterfaceType.IfFast
IfFastEther:
InterfaceType.IfFastEther
IfFastEtherFx:
InterfaceType.IfFastEtherFx
IfFddi:
InterfaceType.IfFddi
IfFibreChannel:
InterfaceType.IfFibreChannel
IfFrameRelay:
InterfaceType.IfFrameRelay
IfFrameRelayInterconnect:
InterfaceType.IfFrameRelayInterconnect
IfFrameRelayMpi:
InterfaceType.IfFrameRelayMpi
IfFrameRelayService:
InterfaceType.IfFrameRelayService
IfFrDlciEndpt:
InterfaceType.IfFrDlciEndpt
IfFrf16MfrBundle:
InterfaceType.IfFrf16MfrBundle
IfFrForward:
InterfaceType.IfFrForward
IfG7032MB:
InterfaceType.IfG7032MB
IfG70364K:
InterfaceType.IfG70364K
IfGigabitEthernet:
InterfaceType.IfGigabitEthernet
IfGr303Idt:
InterfaceType.IfGr303Idt
IfGr303Rdt:
InterfaceType.IfGr303Rdt
IfH323Gatekeeper:
InterfaceType.IfH323Gatekeeper
IfH323Proxy:
InterfaceType.IfH323Proxy
IfHdh1822:
InterfaceType.IfHdh1822
IfHdlc:
InterfaceType.IfHdlc
IfHdsl2:
InterfaceType.IfHdsl2
IfHiperLan2:
InterfaceType.IfHiperLan2
IfHippi:
InterfaceType.IfHippi
IfHippiInterface:
InterfaceType.IfHippiInterface
IfHostPad:
InterfaceType.IfHostPad
IfHssi:
InterfaceType.IfHssi
IfHyperChannel:
InterfaceType.IfHyperChannel
IfIbm370Parchan:
InterfaceType.IfIbm370Parchan
IfIdsl:
InterfaceType.IfIdsl
IfIeee1394:
InterfaceType.IfIeee1394
IfIeee80211:
InterfaceType.IfIeee80211
IfIeee80212:
InterfaceType.IfIeee80212
IfIeee802154:
InterfaceType.IfIeee802154
IfIeee80216Wman:
InterfaceType.IfIeee80216Wman
IfIeee8023AdLag:
InterfaceType.IfIeee8023AdLag
IfIfGsn:
InterfaceType.IfIfGsn
IfImt:
InterfaceType.IfImt
IfInfoMessage:
osdefs: IfInfoMessage
IfInterleave:
InterfaceType.IfInterleave
IfIp:
InterfaceType.IfIp
IfIpForward:
InterfaceType.IfIpForward
IfIpoverAtm:
InterfaceType.IfIpoverAtm
IfIpoverCdlc:
InterfaceType.IfIpoverCdlc
IfIpoverClaw:
InterfaceType.IfIpoverClaw
IfIpSwitch:
InterfaceType.IfIpSwitch
IfIsdn:
InterfaceType.IfIsdn
IfIsdnS:
InterfaceType.IfIsdnS
IfIsdnU:
InterfaceType.IfIsdnU
IfIso88022Llc:
InterfaceType.IfIso88022Llc
IfIso88023Csmacd:
InterfaceType.IfIso88023Csmacd
IfIso88024TokenBus:
InterfaceType.IfIso88024TokenBus
IfIso88025Crfprint:
InterfaceType.IfIso88025Crfprint
IfIso88025Fiber:
InterfaceType.IfIso88025Fiber
IfIso88025rDtr:
InterfaceType.IfIso88025rDtr
IfIso88025TokenRing:
InterfaceType.IfIso88025TokenRing
IfIso88026MAN:
InterfaceType.IfIso88026MAN
IfIsup:
InterfaceType.IfIsup
IfL2Vlan:
InterfaceType.IfL2Vlan
IfL3IpVlan:
InterfaceType.IfL3IpVlan
IfL3IpxVlan:
InterfaceType.IfL3IpxVlan
IFLA_ADDRESS:
osdefs: IFLA_ADDRESS
IFLA_IFNAME:
osdefs: IFLA_IFNAME
IFLA_MTU:
osdefs: IFLA_MTU
IFLA_OPERSTATE:
osdefs: IFLA_OPERSTATE
IfLapB:
InterfaceType.IfLapB
IfLapD:
InterfaceType.IfLapD
IfLapF:
InterfaceType.IfLapF
IFLIST_REPLY_BUFFER:
osdefs: IFLIST_REPLY_BUFFER
IfLocalTalk:
InterfaceType.IfLocalTalk
IfMediaMailOverIp:
InterfaceType.IfMediaMailOverIp
IfMfSigLink:
InterfaceType.IfMfSigLink
IfMioX25:
InterfaceType.IfMioX25
IfModem:
InterfaceType.IfModem
IfMpc:
InterfaceType.IfMpc
IfMpls:
InterfaceType.IfMpls
IfMplsTunnel:
InterfaceType.IfMplsTunnel
IfMsdsl:
InterfaceType.IfMsdsl
IfMvl:
InterfaceType.IfMvl
IfMyrInet:
InterfaceType.IfMyrInet
IfNfas:
InterfaceType.IfNfas
IfNsip:
InterfaceType.IfNsip
IfOpticalChannel:
InterfaceType.IfOpticalChannel
IfOpticalTransport:
InterfaceType.IfOpticalTransport
IfOther:
InterfaceType.IfOther
IfPara:
InterfaceType.IfPara
IfPlc:
InterfaceType.IfPlc
IfPos:
InterfaceType.IfPos
IfPpp:
InterfaceType.IfPpp
IfPppMultilinkBundle:
InterfaceType.IfPppMultilinkBundle
IfPrimaryIsdn:
InterfaceType.IfPrimaryIsdn
IfPropBwaP2mp:
InterfaceType.IfPropBwaP2mp
IfPropCnls:
InterfaceType.IfPropCnls
IfPropDocsWirelessDownstream:
InterfaceType.IfPropDocsWirelessDownstream
IfPropDocsWirelessMaclayer:
InterfaceType.IfPropDocsWirelessMaclayer
IfPropDocsWirelessUpstream:
InterfaceType.IfPropDocsWirelessUpstream
IfPropMultiplexor:
InterfaceType.IfPropMultiplexor
IfPropPoint2PointSerial:
InterfaceType.IfPropPoint2PointSerial
IfPropVirtual:
InterfaceType.IfPropVirtual
IfPropWirelessP2p:
InterfaceType.IfPropWirelessP2p
IfProteon10Mbit:
InterfaceType.IfProteon10Mbit
IfProteon80Mbit:
InterfaceType.IfProteon80Mbit
IfQllc:
InterfaceType.IfQllc
IfRadioMac:
InterfaceType.IfRadioMac
IfRadsl:
InterfaceType.IfRadsl
IfReachDsl:
InterfaceType.IfReachDsl
IfRegular1822:
InterfaceType.IfRegular1822
IfRfc1483:
InterfaceType.IfRfc1483
IfRfc877X25:
InterfaceType.IfRfc877X25
IfRs232:
InterfaceType.IfRs232
IfRsrb:
InterfaceType.IfRsrb
IfSdlc:
InterfaceType.IfSdlc
IfSdsl:
InterfaceType.IfSdsl
IfShdsl:
InterfaceType.IfShdsl
IfSip:
InterfaceType.IfSip
IfSlip:
InterfaceType.IfSlip
IfSmdsDxi:
InterfaceType.IfSmdsDxi
IfSmdsIcip:
InterfaceType.IfSmdsIcip
IfSoftwareLoopback:
InterfaceType.IfSoftwareLoopback
IfSonet:
InterfaceType.IfSonet
IfSonetOverheadChannel:
InterfaceType.IfSonetOverheadChannel
IfSonetPath:
InterfaceType.IfSonetPath
IfSonetVt:
InterfaceType.IfSonetVt
IfSrp:
InterfaceType.IfSrp
IfSs7SigLink:
InterfaceType.IfSs7SigLink
IfStackToStack:
InterfaceType.IfStackToStack
IfStarlan:
InterfaceType.IfStarlan
IfTdlc:
InterfaceType.IfTdlc
IfTermPad:
InterfaceType.IfTermPad
IfTr008:
InterfaceType.IfTr008
IfTransPhdlc:
InterfaceType.IfTransPhdlc
IfTunnel:
InterfaceType.IfTunnel
IfUltra:
InterfaceType.IfUltra
IfUsb:
InterfaceType.IfUsb
IfV11:
InterfaceType.IfV11
IfV35:
InterfaceType.IfV35
IfV36:
InterfaceType.IfV36
IfV37:
InterfaceType.IfV37
IfVdsl:
InterfaceType.IfVdsl
IfVirtualIpAddress:
InterfaceType.IfVirtualIpAddress
IfVoiceEm:
InterfaceType.IfVoiceEm
IfVoiceEncap:
InterfaceType.IfVoiceEncap
IfVoiceFxo:
InterfaceType.IfVoiceFxo
IfVoiceFxs:
InterfaceType.IfVoiceFxs
IfVoiceOverAtm:
InterfaceType.IfVoiceOverAtm
IfVoiceOverFrameRelay:
InterfaceType.IfVoiceOverFrameRelay
IfVoiceOverip:
InterfaceType.IfVoiceOverip
IfWwanPp:
InterfaceType.IfWwanPp
IfWwanPp2:
InterfaceType.IfWwanPp2
IfX213:
InterfaceType.IfX213
IfX25HuntGroup:
InterfaceType.IfX25HuntGroup
IfX25Mlp:
InterfaceType.IfX25Mlp
IfX25Ple:
InterfaceType.IfX25Ple
IfXboxWireless:
InterfaceType.IfXboxWireless
inc:
ipnet: inc(address: var TransportAddress; v: int = 1)
InfiniteDuration:
timer: InfiniteDuration
init:
bipbuffer: init(t: typedesc[BipBuffer]; size: int): BipBuffer
futures: init[T](F: type Future[T]; fromProc: static[string] = ""): Future[T]
futures: init[T](F: type Future[T]; fromProc: static[string] = ""; flags: static[FutureFlags]): Future[T]
raisesfutures: init[T, E](F: type InternalRaisesFuture[T, E]; fromProc: static[string] = ""): F:type
raisesfutures: init[T, E](F: type InternalRaisesFuture[T, E]; fromProc: static[string] = ""; flags: static[FutureFlags]): F:type
asyncstream: init(child, rsource: AsyncStreamReader)
asyncstream: init[T](child, rsource: AsyncStreamReader; udata: ref T)
asyncstream: init(child, rsource: AsyncStreamReader; loop: StreamReaderLoop; bufferSize = AsyncStreamDefaultBufferSize)
asyncstream: init[T](child, rsource: AsyncStreamReader; loop: StreamReaderLoop; bufferSize = AsyncStreamDefaultBufferSize; udata: ref T)
asyncstream: init(child: AsyncStreamReader; tsource: StreamTransport)
asyncstream: init[T](child: AsyncStreamReader; tsource: StreamTransport; udata: ref T)
asyncstream: init(child, wsource: AsyncStreamWriter)
asyncstream: init[T](child, wsource: AsyncStreamWriter; udata: ref T)
asyncstream: init(child, wsource: AsyncStreamWriter; loop: StreamWriterLoop; queueSize = AsyncStreamDefaultQueueSize)
asyncstream: init[T](child, wsource: AsyncStreamWriter; loop: StreamWriterLoop; queueSize = AsyncStreamDefaultQueueSize; udata: ref T)
asyncstream: init(child: AsyncStreamWriter; tsource: StreamTransport)
asyncstream: init[T](child: AsyncStreamWriter; tsource: StreamTransport; udata: ref T)
chunkstream: init(child: ChunkedStreamReader; rsource: AsyncStreamReader; bufferSize = ChunkBufferSize)
chunkstream: init[T](child: ChunkedStreamReader; rsource: AsyncStreamReader; bufferSize = ChunkBufferSize; udata: ref T)
chunkstream: init(child: ChunkedStreamWriter; wsource: AsyncStreamWriter; queueSize = AsyncStreamDefaultQueueSize)
chunkstream: init[T](child: ChunkedStreamWriter; wsource: AsyncStreamWriter; queueSize = AsyncStreamDefaultQueueSize; udata: ref T)
timer: init(t: typedesc[Moment]; value: int64; precision: Duration): Moment
ipnet: init(t: typedesc[IpMask]; family: AddressFamily; prefix: int): IpMask
ipnet: init(t: typedesc[IpMask]; netmask: string): IpMask
ipnet: init(t: typedesc[IpMask]; netmask: TransportAddress): IpMask
ipnet: init(t: typedesc[IpNet]; network: string): IpNet
ipnet: init(t: typedesc[IpNet]; host: TransportAddress; prefix: int): IpNet
ipnet: init(t: typedesc[IpNet]; host: TransportAddress; mask: IpMask): IpNet
ipnet: init(t: typedesc[IpNet]; host, mask: TransportAddress): IpNet
osnet: init(ift: typedesc[InterfaceAddress]; address: TransportAddress; prefix: int): InterfaceAddress
initIp:
ipnet: initIp(t: typedesc[IpMask]; netmask: string): IpMask
initTAddress:
common: initTAddress(address: IpAddress; port: Port): TransportAddress
common: initTAddress(address: string): TransportAddress
common: initTAddress(address: string; port: int): TransportAddress
common: initTAddress(address: string; port: Port): TransportAddress
InterfaceAddress:
osnet: InterfaceAddress
InterfaceState:
osnet: InterfaceState
InterfaceType:
osnet: InterfaceType
InternalAsyncCallback:
futures: InternalAsyncCallback
internalCallTick:
asyncengine: internalCallTick(cbproc: CallbackFunc)
asyncengine: internalCallTick(cbproc: CallbackFunc; data: pointer)
asyncengine: internalCallTick(acb: AsyncCallback)
InternalFutureBase:
futures: InternalFutureBase
internalInitFutureBase:
futures: internalInitFutureBase(fut: FutureBase; loc: ptr SrcLoc; state: FutureState; flags: FutureFlags)
internalRaiseIfError:
asyncfutures: internalRaiseIfError(fut: FutureBase; info: typed)
asyncfutures: internalRaiseIfError(fut: InternalRaisesFuture; raises, info: typed)
InternalRaisesFuture:
raisesfutures: InternalRaisesFuture
INVALID_HANDLE_VALUE:
osdefs: INVALID_HANDLE_VALUE
INVALID_SOCKET:
osdefs: INVALID_SOCKET
InvalidSocketHandle:
osdefs: InvalidSocketHandle
IOSelectorsException:
selectors2: IOSelectorsException
ip:
ipnet: ip(mask: IpMask): string
IpMask:
ipnet: IpMask
IP_MULTICAST_TTL:
osdefs: IP_MULTICAST_TTL
IpNet:
ipnet: IpNet
IPPROTO_TCP:
osdefs: IPPROTO_TCP
IPV6_V6ONLY:
osdefs: IPV6_V6ONLY
isAnyLocal:
ipnet: isAnyLocal(address: TransportAddress): bool
isAvailable:
handles: isAvailable(domain: Domain): bool
common: isAvailable(family: AddressFamily): bool
isBenchmarking:
ipnet: isBenchmarking(address: TransportAddress): bool
isBroadcast:
ipnet: isBroadcast(address: TransportAddress): bool
isCounterLeaked:
asyncengine: isCounterLeaked(name: string): bool
isDocumentation:
ipnet: isDocumentation(address: TransportAddress): bool
isEmpty:
selectors2: isEmpty[T](s: Selector[T]): bool
isGlobal:
ipnet: isGlobal(address: TransportAddress): bool
isGlobalMulticast:
ipnet: isGlobalMulticast(address: TransportAddress): bool
isInfinite:
timer: isInfinite(a: Duration): bool
isInterfaceLocalMulticast:
ipnet: isInterfaceLocalMulticast(address: TransportAddress): bool
isLinkLocal:
ipnet: isLinkLocal(address: TransportAddress): bool
isLinkLocalMulticast:
ipnet: isLinkLocalMulticast(address: TransportAddress): bool
isLinkLocalUnicast:
ipnet: isLinkLocalUnicast(address: TransportAddress): bool
isLoopback:
ipnet: isLoopback(address: TransportAddress): bool
isMulticast:
ipnet: isMulticast(address: TransportAddress): bool
isNone:
ipnet: isNone(address: TransportAddress): bool
isNoRaises:
raisesfutures: isNoRaises(n: NimNode): bool
isPrivate:
ipnet: isPrivate(address: TransportAddress): bool
isReserved:
ipnet: isReserved(address: TransportAddress): bool
isSet:
asyncsync: isSet(event: AsyncEvent): bool
isShared:
ipnet: isShared(address: TransportAddress): bool
isSiteLocal:
ipnet: isSiteLocal(address: TransportAddress): bool
isUnicast:
ipnet: isUnicast(address: TransportAddress): bool
isUnicastLinkLocal:
ipnet: isUnicastLinkLocal(address: TransportAddress): bool
isUniqueLocal:
ipnet: isUniqueLocal(address: TransportAddress): bool
isUnspecified:
ipnet: isUnspecified(address: TransportAddress): bool
isV4Mapped:
ipnet: isV4Mapped(address: TransportAddress): bool
isZero:
timer: isZero(a: Duration): bool
ipnet: isZero(address: TransportAddress): bool
items:
asyncsync: items[T](aq: AsyncQueue[T]): T
bipbuffer: items(bp: BipBuffer): byte
join:
asyncfutures: join(future: FutureBase): InternalRaisesFuture[void, (CancelledError,)]
asyncfutures: join(future: SomeFuture): InternalRaisesFuture[void, (CancelledError,)]
asyncstream: join(rw: AsyncStreamRW): InternalRaisesFuture[void, (CancelledError,)]
datagram: join(transp: DatagramTransport): InternalRaisesFuture[void, (CancelledError,)]
stream: join(server: StreamServer): InternalRaisesFuture[void, (CancelledError,)]
stream: join(transp: StreamTransport): InternalRaisesFuture[void, (CancelledError,)]
len:
asyncsync: len(ab: AsyncEventQueue): int
asyncsync: len[T](aq: AsyncQueue[T]): int
bipbuffer: len(bp: BipBuffer): Natural
localAddress:
datagram: localAddress(transp: DatagramTransport): TransportAddress
stream: localAddress(server: StreamServer): TransportAddress
stream: localAddress(transp: StreamTransport): TransportAddress
localAddress2:
datagram: localAddress2(transp: DatagramTransport): Result[TransportAddress, OSErrorCode]
stream: localAddress2(transp: StreamTransport): Result[TransportAddress, OSErrorCode]
location:
futures: location(future: FutureBase): array[LocationKind, ptr SrcLoc]
LocationKind:
futures: LocationKind
LocCompleteIndex:
asyncfutures: LocCompleteIndex(): untyped
LocCreateIndex:
asyncfutures: LocCreateIndex(): auto
LocFinishIndex:
asyncfutures: LocFinishIndex(): auto
locked:
asyncsync: locked(lock: AsyncLock): bool
low:
timer: low(T: typedesc[Duration]): Duration
timer: low(T: typedesc[Moment]): Moment
makeNoRaises:
raisesfutures: makeNoRaises(): NimNode
mask:
ipnet: mask(a: TransportAddress; m: IpMask): TransportAddress
MaxAdapterAddressLength:
osnet: MaxAdapterAddressLength
MaxEventsCount:
asyncengine: MaxEventsCount
MaxSignalEventLength:
osutils: MaxSignalEventLength
MaxSignalSuffixLength:
osutils: MaxSignalSuffixLength
micros:
timer: micros(v: Duration): int64
timer: micros(v: SomeIntegerI64): Duration
Microsecond:
timer: Microsecond
microseconds:
timer: microseconds(v: Duration): int64
timer: microseconds(v: SomeIntegerI64): Duration
millis:
timer: millis(v: Duration): int64
timer: millis(v: SomeIntegerI64): Duration
Millisecond:
timer: Millisecond
milliseconds:
timer: milliseconds(v: Duration): int64
timer: milliseconds(v: SomeIntegerI64): Duration
Minute:
timer: Minute
minutes:
timer: minutes(v: Duration): int64
timer: minutes(v: SomeIntegerI64): Duration
mitems:
asyncsync: mitems[T](aq: AsyncQueue[T]): var T
Moment:
timer: Moment
nanos:
timer: nanos(v: Duration): int64
timer: nanos(v: SomeIntegerI64): Duration
Nanosecond:
timer: Nanosecond
nanoseconds:
timer: nanoseconds(v: Duration): int64
timer: nanoseconds(v: SomeIntegerI64): Duration
NETLINK_ROUTE:
osdefs: NETLINK_ROUTE
netmask:
osnet: netmask(ifa: InterfaceAddress): TransportAddress
network:
ipnet: network(net: IpNet): TransportAddress
osnet: network(ifa: InterfaceAddress): TransportAddress
NetworkInterface:
osnet: NetworkInterface
new:
asyncstream: new(t: typedesc[AsyncBufferRef]; size: int): AsyncBufferRef
newAsyncEvent:
asyncsync: newAsyncEvent(): AsyncEvent
newAsyncEventQueue:
asyncsync: newAsyncEventQueue[T](limitSize = 0): AsyncEventQueue[T]
newAsyncLock:
asyncsync: newAsyncLock(): AsyncLock
newAsyncQueue:
asyncsync: newAsyncQueue[T](maxsize: int = 0): AsyncQueue[T]
newAsyncStreamIncompleteError:
asyncstream: newAsyncStreamIncompleteError(): ref AsyncStreamIncompleteError
newAsyncStreamLimitError:
asyncstream: newAsyncStreamLimitError(): ref AsyncStreamLimitError
newAsyncStreamReader:
asyncstream: newAsyncStreamReader(rsource: AsyncStreamReader): AsyncStreamReader
asyncstream: newAsyncStreamReader[T](rsource: AsyncStreamReader; udata: ref T): AsyncStreamReader
asyncstream: newAsyncStreamReader(rsource: AsyncStreamReader; loop: StreamReaderLoop; bufferSize = AsyncStreamDefaultBufferSize): AsyncStreamReader
asyncstream: newAsyncStreamReader[T](rsource: AsyncStreamReader; loop: StreamReaderLoop; bufferSize = AsyncStreamDefaultBufferSize; udata: ref T): AsyncStreamReader
asyncstream: newAsyncStreamReader(tsource: StreamTransport): AsyncStreamReader
asyncstream: newAsyncStreamReader[T](tsource: StreamTransport; udata: ref T): AsyncStreamReader
newAsyncStreamUseClosedError:
asyncstream: newAsyncStreamUseClosedError(): ref AsyncStreamUseClosedError
newAsyncStreamWriter:
asyncstream: newAsyncStreamWriter(wsource: AsyncStreamWriter): AsyncStreamWriter
asyncstream: newAsyncStreamWriter[T](wsource: AsyncStreamWriter; udata: ref T): AsyncStreamWriter
asyncstream: newAsyncStreamWriter(wsource: AsyncStreamWriter; loop: StreamWriterLoop; queueSize = AsyncStreamDefaultQueueSize): AsyncStreamWriter
asyncstream: newAsyncStreamWriter[T](wsource: AsyncStreamWriter; loop: StreamWriterLoop; queueSize = AsyncStreamDefaultQueueSize; udata: ref T): AsyncStreamWriter
asyncstream: newAsyncStreamWriter(tsource: StreamTransport): AsyncStreamWriter
asyncstream: newAsyncStreamWriter[T](tsource: StreamTransport; udata: ref T): AsyncStreamWriter
newChunkedStreamReader:
chunkstream: newChunkedStreamReader(rsource: AsyncStreamReader; bufferSize = AsyncStreamDefaultBufferSize): ChunkedStreamReader
chunkstream: newChunkedStreamReader[T](rsource: AsyncStreamReader; bufferSize = AsyncStreamDefaultBufferSize; udata: ref T): ChunkedStreamReader
newChunkedStreamWriter:
chunkstream: newChunkedStreamWriter(wsource: AsyncStreamWriter; queueSize = AsyncStreamDefaultQueueSize): ChunkedStreamWriter
chunkstream: newChunkedStreamWriter[T](wsource: AsyncStreamWriter; queueSize = AsyncStreamDefaultQueueSize; udata: ref T): ChunkedStreamWriter
newDatagramTransport:
datagram: newDatagramTransport(cbproc: DatagramCallback; localPort: Port; local: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; udata: pointer = nil; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport[T](cbproc: DatagramCallback; localPort: Port; local: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; udata: ref T; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport(cbproc: DatagramCallback; localPort: Port; remotePort: Port; local: Opt[IpAddress] = Opt.none(IpAddress); remote: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; udata: pointer = nil; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport[T](cbproc: DatagramCallback; localPort: Port; remotePort: Port; local: Opt[IpAddress] = Opt.none(IpAddress); remote: Opt[IpAddress] = Opt.none(IpAddress); flags: set[ServerFlags] = {}; udata: ref T; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport[T](cbproc: DatagramCallback; udata: ref T; remote: TransportAddress = AnyAddress; local: TransportAddress = AnyAddress; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport(cbproc: DatagramCallback; remote: TransportAddress = AnyAddress; local: TransportAddress = AnyAddress; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; udata: pointer = nil; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport[T](cbproc: UnsafeDatagramCallback; udata: ref T; remote: TransportAddress = AnyAddress; local: TransportAddress = AnyAddress; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport(cbproc: UnsafeDatagramCallback; remote: TransportAddress = AnyAddress; local: TransportAddress = AnyAddress; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; udata: pointer = nil; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
newDatagramTransport6:
datagram: newDatagramTransport6[T](cbproc: DatagramCallback; udata: ref T; remote: TransportAddress = AnyAddress6; local: TransportAddress = AnyAddress6; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport6(cbproc: DatagramCallback; remote: TransportAddress = AnyAddress6; local: TransportAddress = AnyAddress6; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; udata: pointer = nil; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport6[T](cbproc: UnsafeDatagramCallback; udata: ref T; remote: TransportAddress = AnyAddress6; local: TransportAddress = AnyAddress6; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
datagram: newDatagramTransport6(cbproc: UnsafeDatagramCallback; remote: TransportAddress = AnyAddress6; local: TransportAddress = AnyAddress6; sock: AsyncFD = asyncInvalidSocket; flags: set[ServerFlags] = {}; udata: pointer = nil; child: DatagramTransport = nil; bufSize: int = DefaultDatagramBufferSize; ttl: int = 0; dualstack = DualStackType.Auto): DatagramTransport
newDispatcher:
asyncengine: newDispatcher(): PDispatcher
newFuture:
asyncfutures: newFuture[T](fromProc: static[string] = ""; flags: static[FutureFlags] = {}): auto
newFutureSeq:
asyncfutures: newFutureSeq[A, B](fromProc: static[string] = ""): FutureSeq[A, B]
newFutureStr:
asyncfutures: newFutureStr[T](fromProc: static[string] = ""): FutureStr[T]
newInternalRaisesFuture:
asyncfutures: newInternalRaisesFuture[T, E](fromProc: static[string] = ""): auto
newSelectEvent:
selectors2: newSelectEvent(): SelectEvent
newSelector:
selectors2: newSelector[T](): Selector[T]
NLM_F_DUMP:
osdefs: NLM_F_DUMP
NLM_F_MATCH:
osdefs: NLM_F_MATCH
NLM_F_REQUEST:
osdefs: NLM_F_REQUEST
NLM_F_ROOT:
osdefs: NLM_F_ROOT
NLMSG_ALIGNTO:
osdefs: NLMSG_ALIGNTO
NLMSG_DONE:
osdefs: NLMSG_DONE
NLMSG_ERROR:
osdefs: NLMSG_ERROR
NlMsgHeader:
osdefs: NlMsgHeader
NLReq:
osdefs: NLReq
NLRouteReq:
osdefs: NLRouteReq
NoAutoRead:
ServerFlags.NoAutoRead
noCancel:
asyncfutures: noCancel[F: SomeFuture](future: F): auto
None:
TransportFlags.None
NoPipeFlash:
ServerFlags.NoPipeFlash
now:
timer: now(t: typedesc[Moment]): Moment
O_CLOEXEC:
osdefs: O_CLOEXEC
one:
asyncfutures: one[F: SomeFuture](fut0: F; futs: varargs[F]): InternalRaisesFuture[F, (CancelledError,)]
asyncfutures: one[F: SomeFuture](futs: openArray[F]): InternalRaisesFuture[F, (ValueError, CancelledError)]
oneIndex:
asyncfutures: oneIndex[T](futs: varargs[Future[T]]): Future[int]
oneValue:
asyncfutures: oneValue[T](futs: varargs[Future[T]]): Future[T]
OnlyCompleted:
debugutils: OnlyCompleted
OnlyPending:
debugutils: OnlyPending
orImpl:
asyncfutures: orImpl[T, Y](fut1: Future[T]; fut2: Future[Y]): untyped
pairs:
asyncsync: pairs[T](aq: AsyncQueue[T]): tuple[key: int, val: T]
Pause:
ServerCommand.Pause
PDispatcher:
asyncengine: PDispatcher
peekMessage:
datagram: peekMessage(transp: DatagramTransport; msg: var seq[byte]; msglen: var int)
pendingFuturesCount:
debugutils: pendingFuturesCount(filter: set[FutureState]): uint
pipe2:
osdefs: pipe2(a: array[0 .. 1, cint]; flags: cint): cint
PipeHeaderName:
osutils: PipeHeaderName
Pointer:
WriteType.Pointer
poll:
asyncengine: poll()
popFirst:
asyncsync: popFirst[T](aq: AsyncQueue[T]): InternalRaisesFuture[T, (CancelledError,)]
popFirstNoWait:
asyncsync: popFirstNoWait[T](aq: AsyncQueue[T]): T
popLast:
asyncsync: popLast[T](aq: AsyncQueue[T]): InternalRaisesFuture[T, (CancelledError,)]
popLastNoWait:
asyncsync: popLastNoWait[T](aq: AsyncQueue[T]): T
posixSpawn:
osdefs: posixSpawn(a1: var Pid; a2: cstring; a3: var PosixSpawnFileActions; a4: var PosixSpawnAttr; a5, a6: cstringArray): cint
PosixSpawnAttr:
osdefs: PosixSpawnAttr
posixSpawnAttrDestroy:
osdefs: posixSpawnAttrDestroy(a1: var PosixSpawnAttr): cint
posixSpawnAttrGetFlags:
osdefs: posixSpawnAttrGetFlags(a1: var PosixSpawnAttr; a2: var cshort): cint
posixSpawnAttrGetPgroup:
osdefs: posixSpawnAttrGetPgroup(a1: var PosixSpawnAttr; a2: var Pid): cint
posixSpawnAttrGetSchedParam:
osdefs: posixSpawnAttrGetSchedParam(a1: var PosixSpawnAttr; a2: var SchedParam): cint
posixSpawnAttrGetSchedPolicy:
osdefs: posixSpawnAttrGetSchedPolicy(a1: var PosixSpawnAttr; a2: var cint): cint
posixSpawnAttrGetSigDefault:
osdefs: posixSpawnAttrGetSigDefault(a1: var PosixSpawnAttr; a2: var Sigset): cint
posixSpawnAttrGetSigMask:
osdefs: posixSpawnAttrGetSigMask(a1: var PosixSpawnAttr; a2: var Sigset): cint
posixSpawnAttrInit:
osdefs: posixSpawnAttrInit(a1: var PosixSpawnAttr): cint
posixSpawnAttrSetFlags:
osdefs: posixSpawnAttrSetFlags(a1: var PosixSpawnAttr; a2: cint): cint
posixSpawnAttrSetPgroup:
osdefs: posixSpawnAttrSetPgroup(a1: var PosixSpawnAttr; a2: Pid): cint
posixSpawnAttrSetSchedParam:
osdefs: posixSpawnAttrSetSchedParam(a1: var PosixSpawnAttr; a2: var SchedParam): cint
posixSpawnAttrSetSchedPolicy:
osdefs: posixSpawnAttrSetSchedPolicy(a1: var PosixSpawnAttr; a2: cint): cint
posixSpawnAttrSetSigDefault:
osdefs: posixSpawnAttrSetSigDefault(a1: var PosixSpawnAttr; a2: var Sigset): cint
posixSpawnAttrSetSigMask:
osdefs: posixSpawnAttrSetSigMask(a1: var PosixSpawnAttr; a2: var Sigset): cint
PosixSpawnFileActions:
osdefs: PosixSpawnFileActions
posixSpawnFileActionsAddClose:
osdefs: posixSpawnFileActionsAddClose(a1: var PosixSpawnFileActions; a2: cint): cint
posixSpawnFileActionsAddDup2:
osdefs: posixSpawnFileActionsAddDup2(a1: var PosixSpawnFileActions; a2, a3: cint): cint
posixSpawnFileActionsAddOpen:
osdefs: posixSpawnFileActionsAddOpen(a1: var PosixSpawnFileActions; a2: cint; a3: cstring; a4: cint; a5: Mode): cint
posixSpawnFileActionsDestroy:
osdefs: posixSpawnFileActionsDestroy(a1: var PosixSpawnFileActions): cint
posixSpawnFileActionsInit:
osdefs: posixSpawnFileActionsInit(a1: var PosixSpawnFileActions): cint
posixSpawnp:
osdefs: posixSpawnp(a1: var Pid; a2: cstring; a3: var PosixSpawnFileActions; a4: var PosixSpawnAttr; a5, a6: cstringArray): cint
POSIX_SPAWN_RESETIDS:
osdefs: POSIX_SPAWN_RESETIDS
POSIX_SPAWN_SETPGROUP:
osdefs: POSIX_SPAWN_SETPGROUP
POSIX_SPAWN_SETSCHEDPARAM:
osdefs: POSIX_SPAWN_SETSCHEDPARAM
POSIX_SPAWN_SETSCHEDULER:
osdefs: POSIX_SPAWN_SETSCHEDULER
POSIX_SPAWN_SETSIGDEF:
osdefs: POSIX_SPAWN_SETSIGDEF
POSIX_SPAWN_SETSIGMASK:
osdefs: POSIX_SPAWN_SETSIGMASK
POSIX_SPAWN_USEVFORK:
osdefs: POSIX_SPAWN_USEVFORK
P_PID:
osdefs: P_PID
prefix:
ipnet: prefix(mask: IpMask): int
prepend:
raisesfutures: prepend(tup: typedesc; typs: varargs[typed]): typedesc
put:
asyncsync: put[T](aq: AsyncQueue[T]; item: T): InternalRaisesFuture[void, (CancelledError,)]
putNoWait:
asyncsync: putNoWait[T](aq: AsyncQueue[T]; item: T)
race:
asyncfutures: race(fut0: FutureBase; futs: varargs[FutureBase]): InternalRaisesFuture[ FutureBase, (CancelledError,)]
asyncfutures: race(futs: openArray[FutureBase]): InternalRaisesFuture[FutureBase, (ValueError, CancelledError)]
asyncfutures: race(futs: openArray[SomeFuture]): InternalRaisesFuture[FutureBase, (ValueError, CancelledError)]
raiseAsDefect:
asyncengine: raiseAsDefect(exc: ref Exception; msg: string)
raiseAsyncStreamIncompleteError:
asyncstream: raiseAsyncStreamIncompleteError()
raiseAsyncStreamLimitError:
asyncstream: raiseAsyncStreamLimitError()
raiseAsyncStreamUseClosedError:
asyncstream: raiseAsyncStreamUseClosedError()
raiseAsyncStreamWriteEOFError:
asyncstream: raiseAsyncStreamWriteEOFError()
raiseEmptyMessageDefect:
asyncstream: raiseEmptyMessageDefect()
raiseOsDefect:
asyncengine: raiseOsDefect(error: OSErrorCode; msg = "")
raiseTransportError:
common: raiseTransportError(ecode: OSErrorCode)
raiseTransportOsError:
common: raiseTransportOsError(err: OSErrorCode)
Raising:
raisesfutures: Raising[T](F: typedesc[Future[T]]; E: typed): untyped
read:
asyncfutures: read[T: not void](fut: Future[T]): lent T
asyncfutures: read(fut: Future[void])
asyncfutures: read[T: not void; E](fut: InternalRaisesFuture[T, E]): lent T
asyncfutures: read[E](fut: InternalRaisesFuture[void, E])
asyncstream: read(rstream: AsyncStreamReader): InternalRaisesFuture[seq[byte], (CancelledError, AsyncStreamError)]
asyncstream: read(rstream: AsyncStreamReader; n: int): InternalRaisesFuture[seq[byte], (CancelledError, AsyncStreamError)]
stream: read(transp: StreamTransport): InternalRaisesFuture[seq[byte], (TransportError, CancelledError)]
stream: read(transp: StreamTransport; n: int): InternalRaisesFuture[seq[byte], (TransportError, CancelledError)]
ReadClosed:
TransportState.ReadClosed
ReadEof:
TransportState.ReadEof
readerOverflow:
asyncsync: readerOverflow(ab: AsyncEventQueue; reader: EventQueueReader): bool
readError:
asyncfutures: readError(fut: FutureBase): ref CatchableError
raisesfutures: readError[T](future: InternalRaisesFuture[T, void]): ref CatchableError
ReadError:
TransportState.ReadError
readExactly:
asyncstream: readExactly(rstream: AsyncStreamReader; pbytes: pointer; nbytes: int): InternalRaisesFuture[ void, (CancelledError, AsyncStreamError)]
stream: readExactly(transp: StreamTransport; pbytes: pointer; nbytes: int): InternalRaisesFuture[ void, (TransportError, CancelledError)]
readLine:
asyncstream: readLine(rstream: AsyncStreamReader; limit = 0; sep = "\r "): InternalRaisesFuture[ string, (CancelledError, AsyncStreamError)]
stream: readLine(transp: StreamTransport; limit = 0; sep = "\r "): InternalRaisesFuture[ string, (TransportError, CancelledError)]
readMessage:
asyncstream: readMessage(rstream: AsyncStreamReader; pred: ReadMessagePredicate): InternalRaisesFuture[ void, (CancelledError, AsyncStreamError)]
stream: readMessage(transp: StreamTransport; predicate: ReadMessagePredicate): InternalRaisesFuture[ void, (TransportError, CancelledError)]
ReadMessagePredicate:
stream: ReadMessagePredicate
readOnce:
asyncstream: readOnce(rstream: AsyncStreamReader; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (CancelledError, AsyncStreamError)]
stream: readOnce(transp: StreamTransport; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (TransportError, CancelledError)]
ReadPaused:
TransportState.ReadPaused
ReadPending:
TransportState.ReadPending
readUntil:
asyncstream: readUntil(rstream: AsyncStreamReader; pbytes: pointer; nbytes: int; sep: seq[byte]): InternalRaisesFuture[int, (CancelledError, AsyncStreamError)]
stream: readUntil(transp: StreamTransport; pbytes: pointer; nbytes: int; sep: seq[byte]): InternalRaisesFuture[ int, (TransportError, CancelledError)]
ReadyKey:
selectors2: ReadyKey
regions:
bipbuffer: regions(bp: var BipBuffer): tuple[data: ptr byte, size: Natural]
register:
asyncsync: register(ab: AsyncEventQueue): EventQueueKey
register2:
asyncengine: register2(fd: AsyncFD): Result[void, OSErrorCode]
registerEvent:
selectors2: registerEvent[T](s: Selector[T]; ev: SelectEvent; data: T)
registerHandle:
selectors2: registerHandle[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event]; data: T)
registerProcess:
selectors2: registerProcess[T](s: Selector[T]; pid: int; data: T): int
registerSignal:
selectors2: registerSignal[T](s: Selector[T]; signal: int; data: T): int
registerTimer:
selectors2: registerTimer[T](s: Selector[T]; timeout: int; oneshot: bool; data: T): int
registerVnode:
selectors2: registerVnode[T](s: Selector[T]; fd: cint; events: set[Event]; data: T)
release:
asyncsync: release(lock: AsyncLock)
remoteAddress:
datagram: remoteAddress(transp: DatagramTransport): TransportAddress
stream: remoteAddress(transp: StreamTransport): TransportAddress
remoteAddress2:
datagram: remoteAddress2(transp: DatagramTransport): Result[TransportAddress, OSErrorCode]
stream: remoteAddress2(transp: StreamTransport): Result[TransportAddress, OSErrorCode]
remove:
raisesfutures: remove(tup: typedesc; typs: varargs[typed]): typedesc
removeCallback:
asyncfutures: removeCallback(future: FutureBase; cb: CallbackFunc)
asyncfutures: removeCallback(future: FutureBase; cb: CallbackFunc; udata: pointer)
removeReader2:
asyncengine: removeReader2(fd: AsyncFD): Result[void, OSErrorCode]
removeTimer:
asyncengine: removeTimer(at: int64; cb: CallbackFunc; udata: pointer = nil)
asyncengine: removeTimer(at: Moment; cb: CallbackFunc; udata: pointer = nil)
asyncengine: removeTimer(at: uint64; cb: CallbackFunc; udata: pointer = nil)
removeWriter2:
asyncengine: removeWriter2(fd: AsyncFD): Result[void, OSErrorCode]
reserve:
bipbuffer: reserve(bp: var BipBuffer; size: Natural = 0): tuple[data: ptr byte, size: Natural]
resolveTAddress:
common: resolveTAddress(address: string): seq[TransportAddress]
common: resolveTAddress(address: string; family: AddressFamily): seq[TransportAddress]
common: resolveTAddress(address: string; domain: Domain): seq[TransportAddress]
common: resolveTAddress(address: string; family: IpAddressFamily): seq[TransportAddress]
common: resolveTAddress(address: string; port: Port): seq[TransportAddress]
common: resolveTAddress(address: string; port: Port; family: AddressFamily): seq[ TransportAddress]
common: resolveTAddress(address: string; port: Port; domain: Domain): seq[ TransportAddress]
common: resolveTAddress(address: string; port: Port; family: IpAddressFamily): seq[ TransportAddress]
ReuseAddr:
ServerFlags.ReuseAddr
ReusePort:
ServerFlags.ReusePort
Route:
osnet: Route
RTA_ALIGN:
osnet: RTA_ALIGN(length: uint): uint
RTA_ALIGNTO:
osdefs: RTA_ALIGNTO
RTA_DST:
osdefs: RTA_DST
RTA_GATEWAY:
osdefs: RTA_GATEWAY
RTA_OIF:
osdefs: RTA_OIF
RTA_PAYLOAD:
osnet: RTA_PAYLOAD(length: uint): uint
RTA_PREFSRC:
osdefs: RTA_PREFSRC
RtAttr:
osdefs: RtAttr
RtGenMsg:
osdefs: RtGenMsg
RtMessage:
osdefs: RtMessage
RTM_F_LOOKUP_TABLE:
osdefs: RTM_F_LOOKUP_TABLE
RTM_GETADDR:
osdefs: RTM_GETADDR
RTM_GETLINK:
osdefs: RTM_GETLINK
RTM_GETROUTE:
osdefs: RTM_GETROUTE
RTM_NEWLINK:
osdefs: RTM_NEWLINK
RTM_NEWROUTE:
osdefs: RTM_NEWROUTE
runForever:
asyncengine: runForever()
Running:
AsyncStreamState.Running
running:
asyncstream: running(rw: AsyncStreamRW): bool
Running:
ServerStatus.Running
running:
stream: running(transp: StreamTransport): bool
SchedParam:
osdefs: SchedParam
Second:
timer: Second
seconds:
timer: seconds(v: Duration): int64
timer: seconds(v: SomeIntegerI64): Duration
secs:
timer: secs(v: Duration): int64
timer: secs(v: SomeIntegerI64): Duration
select:
selectors2: select[T](s: Selector[T]; timeout: int): seq[ReadyKey]
SelectEvent:
selectors2: SelectEvent
selectInto:
selectors2: selectInto[T](s: Selector[T]; timeout: int; results: var openArray[ReadyKey]): int
Selector:
selectors2: Selector
send:
datagram: send(transp: DatagramTransport; pbytes: pointer; nbytes: int): InternalRaisesFuture[ void, (TransportError, CancelledError)]
datagram: send[T](transp: DatagramTransport; msg: seq[T]; msglen = -1): InternalRaisesFuture[ void, (TransportError, CancelledError)]
datagram: send(transp: DatagramTransport; msg: string; msglen = -1): InternalRaisesFuture[ void, (TransportError, CancelledError)]
sendfile:
sendfile: sendfile(outfd, infd: int; offset: int; count: var int): int
sendTo:
datagram: sendTo(transp: DatagramTransport; remote: TransportAddress; pbytes: pointer; nbytes: int): InternalRaisesFuture[void, (TransportError, CancelledError)]
datagram: sendTo[T](transp: DatagramTransport; remote: TransportAddress; msg: seq[T]; msglen = -1): InternalRaisesFuture[void, (TransportError, CancelledError)]
datagram: sendTo(transp: DatagramTransport; remote: TransportAddress; msg: string; msglen = -1): InternalRaisesFuture[void, (TransportError, CancelledError)]
Sequence:
WriteType.Sequence
ServerCommand:
common: ServerCommand
ServerFlags:
common: ServerFlags
ServerStatus:
common: ServerStatus
setData:
selectors2: setData[T](s: Selector[T]; fd: SocketHandle | int; data: var T): bool
setDescriptorBlocking:
osutils: setDescriptorBlocking(s: cint; value: bool): Result[void, OSErrorCode]
osutils: setDescriptorBlocking(s: SocketHandle; value: bool): Result[void, OSErrorCode]
setDescriptorFlags:
osutils: setDescriptorFlags(s: cint; nonblock, cloexec: bool): Result[void, OSErrorCode]
setDescriptorInheritance:
osutils: setDescriptorInheritance(s: cint; value: bool): Result[void, OSErrorCode]
setDualstack:
handles: setDualstack(fd: AsyncFD; value: bool): Result[void, OSErrorCode]
common: setDualstack(socket: AsyncFD; family: AddressFamily; flag: DualStackType): Result[ void, OSErrorCode]
common: setDualstack(socket: AsyncFD; flag: DualStackType): Result[void, OSErrorCode]
setGlobalDispatcher:
asyncengine: setGlobalDispatcher(disp: PDispatcher)
setMaxOpenFiles:
handles: setMaxOpenFiles(count: int)
setMaxOpenFiles2:
handles: setMaxOpenFiles2(count: int): Result[void, OSErrorCode]
setSocketBlocking:
handles: setSocketBlocking(s: SocketHandle; blocking: bool): bool
setSockOpt:
handles: setSockOpt(socket: AsyncFD; level, optname, optval: int): bool
handles: setSockOpt(socket: AsyncFD; level, optname: int; value: pointer; valuelen: int): bool
setSockOpt2:
handles: setSockOpt2(socket: AsyncFD; level, optname, optval: int): Result[void, OSErrorCode]
handles: setSockOpt2(socket: AsyncFD; level, optname: int; value: pointer; valuelen: int): Result[ void, OSErrorCode]
setThreadDispatcher:
asyncengine: setThreadDispatcher(disp: PDispatcher)
setTimer:
asyncengine: setTimer(at: Moment; cb: CallbackFunc; udata: pointer = nil): TimerCallback
SFD_CLOEXEC:
osdefs: SFD_CLOEXEC
SFD_NONBLOCK:
osdefs: SFD_NONBLOCK
shutdownWait:
stream: shutdownWait(transp: StreamTransport): InternalRaisesFuture[void, (TransportError, CancelledError)]
signalfd:
osdefs: signalfd(fd: cint; mask: var Sigset; flags: cint): cint
SignalFdInfo:
osdefs: SignalFdInfo
SignalPrefixName:
osutils: SignalPrefixName
size:
asyncsync: size[T](aq: AsyncQueue[T]): int
sleepAsync:
asyncfutures: sleepAsync(duration: Duration): InternalRaisesFuture[void, (CancelledError,)]
asyncfutures: sleepAsync(ms: int): InternalRaisesFuture[void, (CancelledError,)]
Sockaddr_nl:
osdefs: Sockaddr_nl
SOCK_CLOEXEC:
osdefs: SOCK_CLOEXEC
SocketFlags:
stream: SocketFlags
SocketServer:
common: SocketServer
SOCK_NONBLOCK:
osdefs: SOCK_NONBLOCK
SomeIntegerI64:
timer: SomeIntegerI64
SrcLoc:
srcloc: SrcLoc
Start:
ServerCommand.Start
start:
stream: start(server: StreamServer)
start2:
stream: start2(server: StreamServer): Result[void, OSErrorCode]
Starting:
ServerStatus.Starting
state:
futures: state(future: FutureBase): FutureState
StatusDormant:
InterfaceState.StatusDormant
StatusDown:
InterfaceState.StatusDown
StatusError:
InterfaceState.StatusError
StatusLowerLayerDown:
InterfaceState.StatusLowerLayerDown
StatusNotPresent:
InterfaceState.StatusNotPresent
StatusTesting:
InterfaceState.StatusTesting
StatusUnknown:
InterfaceState.StatusUnknown
StatusUp:
InterfaceState.StatusUp
stepsAsync:
asyncfutures: stepsAsync(number: int): InternalRaisesFuture[void, (CancelledError,)]
Stop:
ServerCommand.Stop
stop:
stream: stop(server: StreamServer)
stop2:
stream: stop2(server: StreamServer): Result[void, OSErrorCode]
Stopped:
AsyncStreamState.Stopped
stopped:
asyncstream: stopped(rw: AsyncStreamRW): bool
Stopped:
ServerStatus.Stopped
StreamCallback:
stream: StreamCallback
StreamCallback2:
stream: StreamCallback2
StreamReaderLoop:
asyncstream: StreamReaderLoop
StreamServer:
stream: StreamServer
StreamServerTrackerName:
stream: StreamServerTrackerName
StreamTransport:
stream: StreamTransport
StreamTransportTrackerName:
stream: StreamTransportTrackerName
StreamWriterLoop:
asyncstream: StreamWriterLoop
String:
WriteType.String
subnetMask:
ipnet: subnetMask(mask: IpMask): TransportAddress
ipnet: subnetMask(net: IpNet): TransportAddress
TCP_NODELAY:
osdefs: TCP_NODELAY
TcpNoDelay:
ServerFlags.TcpNoDelay
TransportFlags.TcpNoDelay
TFD_CLOEXEC:
osdefs: TFD_CLOEXEC
TFD_NONBLOCK:
osdefs: TFD_NONBLOCK
TimerCallback:
asyncengine: TimerCallback
timerfd_create:
osdefs: timerfd_create(clock_id: ClockId; flags: cint): cint
timerfd_settime:
osdefs: timerfd_settime(ufd: cint; flags: cint; utmr: var Itimerspec; otmr: var Itimerspec): cint
toException:
asyncengine: toException(v: OSErrorCode): ref OSError
stream: toException(v: OSErrorCode): ref TransportOsError
toHex:
common: toHex(address: TransportAddress): string
toIpAddress:
common: toIpAddress(address: TransportAddress): IpAddress
toIPv4:
ipnet: toIPv4(address: TransportAddress): TransportAddress
toIPv6:
ipnet: toIPv6(address: TransportAddress): TransportAddress
toSAddr:
common: toSAddr(address: TransportAddress; sa: var Sockaddr_storage; sl: var SockLen)
toString:
timer: toString(a: timer.Duration; parts = int.high): string
toUnchecked:
stream: toUnchecked(a: untyped): untyped
trackCounter:
asyncengine: trackCounter(name: string)
TrackerBase:
asyncengine: TrackerBase
TrackerCounter:
asyncengine: TrackerCounter
trackerCounterKeys:
asyncengine: trackerCounterKeys(loop: PDispatcher): string
trackerCounters:
asyncengine: trackerCounters(loop: PDispatcher): tuple[name: string, value: TrackerCounter]
transfer:
asyncstream: transfer(sb: AsyncBufferRef): untyped
TransportAbortedError:
common: TransportAbortedError
TransportAddress:
common: TransportAddress
TransportAddressError:
common: TransportAddressError
TransportError:
common: TransportError
TransportFlags:
stream: TransportFlags
TransportIncompleteError:
common: TransportIncompleteError
TransportInitCallback:
stream: TransportInitCallback
TransportKind:
stream: TransportKind
TransportLimitError:
common: TransportLimitError
TransportNoSupport:
common: TransportNoSupport
TransportOsError:
common: TransportOsError
TransportState:
common: TransportState
TransportTooManyError:
common: TransportTooManyError
TransportUseClosedError:
common: TransportUseClosedError
TransportUseEofError:
common: TransportUseEofError
trigger:
selectors2: trigger(ev: SelectEvent)
tryCancel:
asyncfutures: tryCancel(future: FutureBase): bool
union:
raisesfutures: union(tup0: typedesc; tup1: typedesc): typedesc
unregister:
asyncsync: unregister(ab: AsyncEventQueue; key: EventQueueKey)
selectors2: unregister[T](s: Selector[T]; fd: int | SocketHandle | cint)
selectors2: unregister[T](s: Selector[T]; ev: SelectEvent)
unregister2:
asyncengine: unregister2(fd: AsyncFD): Result[void, OSErrorCode]
unregisterAndCloseFd:
asyncengine: unregisterAndCloseFd(fd: AsyncFD): Result[void, OSErrorCode]
UnsafeDatagramCallback:
datagram: UnsafeDatagramCallback
untrackCounter:
asyncengine: untrackCounter(name: string)
updateHandle:
selectors2: updateHandle[T](s: Selector[T]; fd: int | SocketHandle; events: set[Event])
upload:
asyncstream: upload(sb: AsyncBufferRef; pbytes: ptr byte; nbytes: int): InternalRaisesFuture[ void, (CancelledError,)]
V4Mapped:
ServerFlags.V4Mapped
TransportFlags.V4Mapped
value:
futures: value[T: not void](future: Future[T]): lent T
futures: value(future: Future[void])
wait:
asyncsync: wait(event: AsyncEvent): InternalRaisesFuture[void, (CancelledError,)]
asyncfutures: wait[T](fut: Future[T]; timeout = InfiniteDuration): Future[T]
asyncfutures: wait[T](fut: Future[T]; timeout = -1): Future[T]
asyncfutures: wait[T](fut: Future[T]; deadline: SomeFuture): Future[T]
asyncfutures: wait(fut: InternalRaisesFuture; timeout = InfiniteDuration): auto
asyncfutures: wait(fut: InternalRaisesFuture; deadline: SomeFuture): auto
asyncstream: wait(sb: AsyncBufferRef): untyped
waitEvents:
asyncsync: waitEvents[T](ab: AsyncEventQueue[T]; key: EventQueueKey; eventsCount = -1): InternalRaisesFuture[ seq[T], (AsyncEventQueueFullError, CancelledError)]
WAITEXITSTATUS:
osdefs: WAITEXITSTATUS(s: cint): cint
waitFor:
asyncfutures: waitFor[T: not void](fut: Future[T]): lent T
asyncfutures: waitFor(fut: Future[void])
asyncfutures: waitFor[T: not void; E](fut: InternalRaisesFuture[T, E]): lent T
asyncfutures: waitFor[E](fut: InternalRaisesFuture[void, E])
WAITIFCONTINUED:
osdefs: WAITIFCONTINUED(s: cint): bool
WAITIFEXITED:
osdefs: WAITIFEXITED(s: cint): bool
WAITIFSIGNALED:
osdefs: WAITIFSIGNALED(s: cint): bool
WAITIFSTOPPED:
osdefs: WAITIFSTOPPED(s: cint): bool
WAITSTOPSIG:
osdefs: WAITSTOPSIG(s: cint): cint
WAITTERMSIG:
osdefs: WAITTERMSIG(s: cint): cint
Week:
timer: Week
weeks:
timer: weeks(v: Duration): int64
timer: weeks(v: SomeIntegerI64): Duration
WEXITED:
osdefs: WEXITED
windowsAnyAddressFix:
common: windowsAnyAddressFix(a: TransportAddress): TransportAddress
WinNoPipeFlash:
TransportFlags.WinNoPipeFlash
WinServerPipe:
TransportFlags.WinServerPipe
withData:
selectors2: withData[T](s: Selector[T]; fd: SocketHandle | int; value, body: untyped)
selectors2: withData[T](s: Selector[T]; fd: SocketHandle | int; value, body1, body2: untyped)
WithoutCompleted:
debugutils: WithoutCompleted
withTimeout:
asyncfutures: withTimeout[T](fut: Future[T]; timeout: Duration): InternalRaisesFuture[bool, (CancelledError,)]
asyncfutures: withTimeout[T](fut: Future[T]; timeout: int): Future[bool]
WNOHANG:
osdefs: WNOHANG
WNOWAIT:
osdefs: WNOWAIT
wrapAsyncSocket:
handles: wrapAsyncSocket(sock: cint | SocketHandle): AsyncFD
wrapAsyncSocket2:
handles: wrapAsyncSocket2(sock: cint | SocketHandle): Result[AsyncFD, OSErrorCode]
write:
asyncstream: write(wstream: AsyncStreamWriter; pbytes: pointer; nbytes: int): InternalRaisesFuture[ void, (CancelledError, AsyncStreamError)]
asyncstream: write(wstream: AsyncStreamWriter; sbytes: seq[byte]; msglen = -1): InternalRaisesFuture[ void, (CancelledError, AsyncStreamError)]
asyncstream: write(wstream: AsyncStreamWriter; sbytes: string; msglen = -1): InternalRaisesFuture[ void, (CancelledError, AsyncStreamError)]
stream: write(transp: StreamTransport; pbytes: pointer; nbytes: int): InternalRaisesFuture[ int, (TransportError, CancelledError)]
stream: write[T](transp: StreamTransport; msg: seq[T]; msglen = -1): InternalRaisesFuture[ int, (TransportError, CancelledError)]
stream: write(transp: StreamTransport; msg: string; msglen = -1): InternalRaisesFuture[ int, (TransportError, CancelledError)]
WriteClosed:
TransportState.WriteClosed
WriteEof:
TransportState.WriteEof
WriteError:
TransportState.WriteError
writeFile:
stream: writeFile(transp: StreamTransport; handle: int; offset: uint = 0; size: int = 0): InternalRaisesFuture[ int, (TransportError, CancelledError)]
WriteItem:
asyncstream: WriteItem
WritePaused:
TransportState.WritePaused
WritePending:
TransportState.WritePending
WriteType:
asyncstream: WriteType
WSTOPPED:
osdefs: WSTOPPED
ZeroDuration:
timer: ZeroDuration