package http:nbio/poly
Source

⌘K

Ctrl+K

or

/

Filter Results

Overview

Package nbio/poly contains variants of the nbio procedures that use generic/poly data so users can avoid casts and use multiple arguments.

Please reference the documentation in nbio.

Intention is to import this like so import nbio "nbio/poly"

Index

Types (5)

Closable
Completion
IO
Poll_Event
Whence

Constants (0)

This section is empty.

Variables (0)

This section is empty.

Procedures (64)

Procedure Groups (20)

accept
close
connect
next_tick
poll
read
read_all
read_at
read_at_all
read_entire_file
read_full
recv
recv_all
send
send_all
timeout
write
write_all
write_at
write_at_all

Types

Closable ¶
Source

Closable :: nbio.Closable

Completion ¶
Source

Completion :: nbio.Completion

IO ¶
Source

IO :: nbio._IO

Poll_Event ¶
Source

Poll_Event :: nbio.Poll_Event

Whence ¶
Source

Whence :: nbio.Whence

Constants

This section is empty.

Variables

This section is empty.

Procedures

accept1 ¶
Source

accept1 :: proc(io: ^nbio._IO, socket: net.TCP_Socket, p: $T, callback: $C/proc(p: $T)) {…}

accept2 ¶
Source

accept2 :: proc(io: ^nbio._IO, socket: net.TCP_Socket, p: $T, p2: $T2, callback: $C/proc(p: $T)) {…}

accept3 ¶
Source

accept3 :: proc(
	io:       ^nbio._IO, 
	socket:   net.TCP_Socket, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

close1 ¶
Source

close1 :: proc(io: ^nbio._IO, fd: nbio.Closable, p: $T, callback: $C/proc(p: $T)) {…}

close2 ¶
Source

close2 :: proc(io: ^nbio._IO, fd: nbio.Closable, p: $T, p2: $T2, callback: $C/proc(p: $T)) {…}

close3 ¶
Source

close3 :: proc(
	io:       ^nbio._IO, 
	fd:       nbio.Closable, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

close_no_cb ¶
Source

close_no_cb :: proc(io: ^nbio._IO, fd: nbio.Closable) {…}

connect1 ¶
Source

connect1 :: proc(io: ^nbio._IO, endpoint: net.Endpoint, p: $T, callback: $C/proc(p: $T)) {…}

connect2 ¶
Source

connect2 :: proc(io: ^nbio._IO, endpoint: net.Endpoint, p: $T, p2: $T2, callback: $C/proc(p: $T)) {…}

connect3 ¶
Source

connect3 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

next_tick1 ¶
Source

next_tick1 :: proc(io: ^nbio._IO, p: $T, callback: $C/proc(p: $T)) {…}

next_tick2 ¶
Source

next_tick2 :: proc(io: ^nbio._IO, p: $T, p2: $T2, callback: $C/proc(p: $T)) {…}

next_tick3 ¶
Source

next_tick3 :: proc(io: ^nbio._IO, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: $T)) {…}

poll1 ¶
Source

poll1 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	event:    nbio.Poll_Event, 
	multi:    bool, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

poll2 ¶
Source

poll2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	event:    nbio.Poll_Event, 
	multi:    bool, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

poll3 ¶
Source

poll3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	event:    nbio.Poll_Event, 
	multi:    bool, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

read1 ¶
Source

read1 :: proc(io: ^nbio._IO, fd: os.Handle, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

read2 ¶
Source

read2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

read3 ¶
Source

read3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

read_all1 ¶
Source

read_all1 :: proc(io: ^nbio._IO, fd: os.Handle, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

read_all2 ¶
Source

read_all2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

read_all3 ¶
Source

read_all3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

read_at1 ¶
Source

read_at1 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

read_at2 ¶
Source

read_at2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

read_at3 ¶
Source

read_at3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

read_at_all1 ¶
Source

read_at_all1 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

read_at_all2 ¶
Source

read_at_all2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

read_at_all3 ¶
Source

read_at_all3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

read_full1 ¶
Source

read_full1 :: proc(io: ^nbio._IO, fd: os.Handle, p: $T, callback: $C/proc(p: $T), allocator := context.allocator) {…}

read_full2 ¶
Source

read_full2 :: proc(
	io:        ^nbio._IO, 
	fd:        os.Handle, 
	p:         $T, 
	p2:        $T2, 
	callback:  $C/proc(p: $T), 
	allocator := context.allocator, 
) {…}

read_full3 ¶
Source

read_full3 :: proc(
	io:        ^nbio._IO, 
	fd:        os.Handle, 
	p:         $T, 
	p2:        $T2, 
	p3:        $T3, 
	callback:  $C/proc(p: $T), 
	allocator := context.allocator, 
) {…}

recv1 ¶
Source

recv1 :: proc(io: ^nbio._IO, socket: net.Any_Socket, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

recv2 ¶
Source

recv2 :: proc(
	io:       ^nbio._IO, 
	socket:   net.Any_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

recv3 ¶
Source

recv3 :: proc(
	io:       ^nbio._IO, 
	socket:   net.Any_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

recv_all1 ¶
Source

recv_all1 :: proc(io: ^nbio._IO, socket: net.Any_Socket, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

recv_all2 ¶
Source

recv_all2 :: proc(
	io:       ^nbio._IO, 
	socket:   net.Any_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

recv_all3 ¶
Source

recv_all3 :: proc(
	io:       ^nbio._IO, 
	socket:   net.Any_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

send_all_tcp1 ¶
Source

send_all_tcp1 :: proc(io: ^nbio._IO, socket: net.TCP_Socket, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

send_all_tcp2 ¶
Source

send_all_tcp2 :: proc(
	io:       ^nbio._IO, 
	socket:   net.TCP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

send_all_tcp3 ¶
Source

send_all_tcp3 :: proc(
	io:       ^nbio._IO, 
	socket:   net.TCP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

send_all_udp1 ¶
Source

send_all_udp1 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	socket:   net.UDP_Socket, 
	buf:      []u8, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

send_all_udp2 ¶
Source

send_all_udp2 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	socket:   net.UDP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

send_all_udp3 ¶
Source

send_all_udp3 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	socket:   net.UDP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

send_tcp1 ¶
Source

send_tcp1 :: proc(io: ^nbio._IO, socket: net.TCP_Socket, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

send_tcp2 ¶
Source

send_tcp2 :: proc(
	io:       ^nbio._IO, 
	socket:   net.TCP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

send_tcp3 ¶
Source

send_tcp3 :: proc(
	io:       ^nbio._IO, 
	socket:   net.TCP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

send_udp1 ¶
Source

send_udp1 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	socket:   net.UDP_Socket, 
	buf:      []u8, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

send_udp2 ¶
Source

send_udp2 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	socket:   net.UDP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

send_udp3 ¶
Source

send_udp3 :: proc(
	io:       ^nbio._IO, 
	endpoint: net.Endpoint, 
	socket:   net.UDP_Socket, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

timeout1 ¶
Source

timeout1 :: proc(io: ^nbio._IO, dur: time.Duration, p: $T, callback: $C/proc(p: $T)) {…}

timeout2 ¶
Source

timeout2 :: proc(io: ^nbio._IO, dur: time.Duration, p: $T, p2: $T2, callback: $C/proc(p: $T)) {…}

timeout3 ¶
Source

timeout3 :: proc(
	io:       ^nbio._IO, 
	dur:      time.Duration, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

write1 ¶
Source

write1 :: proc(io: ^nbio._IO, fd: os.Handle, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

write2 ¶
Source

write2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

write3 ¶
Source

write3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

write_all1 ¶
Source

write_all1 :: proc(io: ^nbio._IO, fd: os.Handle, buf: []u8, p: $T, callback: $C/proc(p: $T)) {…}

write_all2 ¶
Source

write_all2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

write_all3 ¶
Source

write_all3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

write_at1 ¶
Source

write_at1 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

write_at2 ¶
Source

write_at2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

write_at3 ¶
Source

write_at3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

write_at_all1 ¶
Source

write_at_all1 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	callback: $C/proc(p: $T), 
) {…}

write_at_all2 ¶
Source

write_at_all2 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	callback: $C/proc(p: $T), 
) {…}

write_at_all3 ¶
Source

write_at_all3 :: proc(
	io:       ^nbio._IO, 
	fd:       os.Handle, 
	offset:   untyped integer, 
	buf:      []u8, 
	p:        $T, 
	p2:       $T2, 
	p3:       $T3, 
	callback: $C/proc(p: $T), 
) {…}

Procedure Groups

accept ¶
Source

accept :: proc{
	accept1,
	accept2,
	accept3,
}

close ¶
Source

close :: proc{
	close_no_cb,
	close1,
	close2,
	close3,
}

connect ¶
Source

connect :: proc{
	connect1,
	connect2,
	connect3,
}

next_tick ¶
Source

next_tick :: proc{
	next_tick1,
	next_tick2,
	next_tick3,
}

poll ¶
Source

poll :: proc{
	poll1,
	poll2,
	poll3,
}

read ¶
Source

read :: proc{
	read1,
	read2,
	read3,
}

read_all ¶
Source

read_all :: proc{
	read_all1,
	read_all2,
	read_all3,
}

read_at ¶
Source

read_at :: proc{
	read_at1,
	read_at2,
	read_at3,
}

read_at_all ¶
Source

read_at_all :: proc{
	read_at_all1,
	read_at_all2,
	read_at_all3,
}

read_entire_file ¶
Source

read_entire_file :: proc{
	read_full1,
	read_full2,
	read_full3,
}

read_full ¶
Source

read_full :: proc{
	read_full1,
	read_full2,
	read_full3,
}

recv ¶
Source

recv :: proc{
	recv1,
	recv2,
	recv3,
}

recv_all ¶
Source

recv_all :: proc{
	recv_all1,
	recv_all2,
	recv_all3,
}

send ¶
Source

send :: proc{
	send_tcp1,
	send_tcp2,
	send_tcp3,
	send_udp1,
	send_udp2,
	send_udp3,
}

send_all ¶
Source

send_all :: proc{
	send_all_tcp1,
	send_all_tcp2,
	send_all_tcp3,
	send_all_udp1,
	send_all_udp2,
	send_all_udp3,
}

timeout ¶
Source

timeout :: proc{
	timeout1,
	timeout2,
	timeout3,
}

write ¶
Source

write :: proc{
	write1,
	write2,
	write3,
}

write_all ¶
Source

write_all :: proc{
	write_all1,
	write_all2,
	write_all3,
}

write_at ¶
Source

write_at :: proc{
	write_at1,
	write_at2,
	write_at3,
}

write_at_all ¶
Source

write_at_all :: proc{
	write_at_all1,
	write_at_all2,
	write_at_all3,
}

Source Files

poly.odin

Generation Information

Generated with odin version dev-2025-04 (vendor "odin") Linux_amd64 @ 2025-04-09 18:34:37.738368554 +0000 UTC