1139 lines
42 KiB
Odin
1139 lines
42 KiB
Odin
|
// 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"`
|
||
|
|
package poly
|
||
|
|
|
||
|
|
import "core:mem"
|
||
|
|
import "core:net"
|
||
|
|
import "core:os"
|
||
|
|
import "core:time"
|
||
|
|
|
||
|
|
import nbio ".."
|
||
|
|
|
||
|
|
// Because mem is only used inside the poly procs, the checker thinks we aren't using it.
|
||
|
|
_ :: mem
|
||
|
|
|
||
|
|
/// Re-export `nbio` stuff that is not wrapped in this package.
|
||
|
|
|
||
|
|
Completion :: nbio.Completion
|
||
|
|
IO :: nbio.IO
|
||
|
|
init :: nbio.init
|
||
|
|
tick :: nbio.tick
|
||
|
|
num_waiting :: nbio.num_waiting
|
||
|
|
destroy :: nbio.destroy
|
||
|
|
open_socket :: nbio.open_socket
|
||
|
|
open_and_listen_tcp :: nbio.open_and_listen_tcp
|
||
|
|
listen :: nbio.listen
|
||
|
|
Closable :: nbio.Closable
|
||
|
|
open :: nbio.open
|
||
|
|
Whence :: nbio.Whence
|
||
|
|
seek :: nbio.seek
|
||
|
|
Poll_Event :: nbio.Poll_Event
|
||
|
|
poll_remove :: nbio.poll_remove
|
||
|
|
|
||
|
|
/// Timeout
|
||
|
|
|
||
|
|
timeout :: proc {
|
||
|
|
timeout1,
|
||
|
|
timeout2,
|
||
|
|
timeout3,
|
||
|
|
}
|
||
|
|
|
||
|
|
timeout1 :: proc(io: ^nbio.IO, dur: time.Duration, p: $T, callback: $C/proc(p: T))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._timeout(io, dur, nil, proc(completion: rawptr) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
timeout2 :: proc(io: ^nbio.IO, dur: time.Duration, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._timeout(io, dur, nil, proc(completion: rawptr) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
timeout3 :: proc(io: ^nbio.IO, dur: time.Duration, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._timeout(io, dur, nil, proc(completion: rawptr) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Close
|
||
|
|
|
||
|
|
close :: proc {
|
||
|
|
close_no_cb,
|
||
|
|
close1,
|
||
|
|
close2,
|
||
|
|
close3,
|
||
|
|
}
|
||
|
|
|
||
|
|
close_no_cb :: proc(io: ^nbio.IO, fd: nbio.Closable) {
|
||
|
|
nbio.close(io, fd)
|
||
|
|
}
|
||
|
|
|
||
|
|
close1 :: proc(io: ^nbio.IO, fd: nbio.Closable, p: $T, callback: $C/proc(p: T, ok: bool))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._close(io, fd, nil, proc(completion: rawptr, ok: bool) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, ok)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
close2 :: proc(io: ^nbio.IO, fd: nbio.Closable, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, ok: bool))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._close(io, fd, nil, proc(completion: rawptr, ok: bool) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, ok)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
close3 :: proc(io: ^nbio.IO, fd: nbio.Closable, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, ok: bool))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._close(io, fd, nil, proc(completion: rawptr, ok: bool) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T3):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, ok)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Accept
|
||
|
|
|
||
|
|
accept :: proc {
|
||
|
|
accept1,
|
||
|
|
accept2,
|
||
|
|
accept3,
|
||
|
|
}
|
||
|
|
|
||
|
|
accept1 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, p: $T, callback: $C/proc(p: T, client: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._accept(io, socket, nil, proc(completion: rawptr, client: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, client, source, err)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
accept2 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, client: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._accept(io, socket, nil, proc(completion: rawptr, client: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, client, source, err)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
accept3 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, client: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._accept(io, socket, nil, proc(completion: rawptr, client: net.TCP_Socket, source: net.Endpoint, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, client, source, err)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Connect
|
||
|
|
|
||
|
|
connect :: proc {
|
||
|
|
connect1,
|
||
|
|
connect2,
|
||
|
|
connect3,
|
||
|
|
}
|
||
|
|
|
||
|
|
connect1 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, p: $T, callback: $C/proc(p: T, socket: net.TCP_Socket, err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion, err := nbio._connect(io, endpoint, nil, proc(completion: rawptr, socket: net.TCP_Socket, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, socket, err)
|
||
|
|
})
|
||
|
|
if err != nil {
|
||
|
|
callback(p, {}, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
connect2 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, socket: net.TCP_Socket, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion, err := nbio._connect(io, endpoint, nil, proc(completion: rawptr, socket: net.TCP_Socket, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, socket, err)
|
||
|
|
})
|
||
|
|
if err != nil {
|
||
|
|
callback(p, p2, {}, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
connect3 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, socket: net.TCP_Socket, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion, err := nbio._connect(io, endpoint, nil, proc(completion: rawptr, socket: net.TCP_Socket, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, socket, err)
|
||
|
|
})
|
||
|
|
if err != nil {
|
||
|
|
callback(p, p2, p3, {}, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Internal Recv
|
||
|
|
|
||
|
|
_recv :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, all: bool, p: $T, callback: $C/proc(p: T, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._recv(io, socket, buf, nil, proc(completion: rawptr, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, received, udp_client, err)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_recv2 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, all: bool, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._recv(io, socket, buf, nil, proc(completion: rawptr, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, received, udp_client, err)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_recv3 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, all: bool, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._recv(io, socket, buf, nil, proc(completion: rawptr, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, received, udp_client, err)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Recv
|
||
|
|
|
||
|
|
recv :: proc {
|
||
|
|
recv1,
|
||
|
|
recv2,
|
||
|
|
recv3,
|
||
|
|
}
|
||
|
|
|
||
|
|
recv1 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_recv(io, socket, buf, false, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
recv2 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_recv2(io, socket, buf, false, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
recv3 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_recv3(io, socket, buf, false, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Recv All
|
||
|
|
|
||
|
|
recv_all :: proc {
|
||
|
|
recv_all1,
|
||
|
|
recv_all2,
|
||
|
|
recv_all3,
|
||
|
|
}
|
||
|
|
|
||
|
|
recv_all1 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_recv(io, socket, buf, true, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
recv_all2 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_recv_all2(io, socket, buf, false, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
recv_all3 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, received: int, udp_client: Maybe(net.Endpoint), err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_recv_all2(io, socket, buf, false, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send
|
||
|
|
|
||
|
|
send :: proc {
|
||
|
|
send_tcp1,
|
||
|
|
send_tcp2,
|
||
|
|
send_tcp3,
|
||
|
|
send_udp1,
|
||
|
|
send_udp2,
|
||
|
|
send_udp3,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send Internal
|
||
|
|
|
||
|
|
_send :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, sent: int, err: net.Network_Error), endpoint: Maybe(net.Endpoint) = nil, all := false)
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._send(io, socket, buf, nil, proc(completion: rawptr, sent: int, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, sent, err)
|
||
|
|
}, endpoint, all)
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_send2 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, sent: int, err: net.Network_Error), endpoint: Maybe(net.Endpoint) = nil, all := false)
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._send(io, socket, buf, nil, proc(completion: rawptr, sent: int, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, sent, err)
|
||
|
|
}, endpoint, all)
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_send3 :: proc(io: ^nbio.IO, socket: net.Any_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, sent: int, err: net.Network_Error), endpoint: Maybe(net.Endpoint) = nil, all := false)
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._send(io, socket, buf, nil, proc(completion: rawptr, sent: int, err: net.Network_Error) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, sent, err)
|
||
|
|
}, endpoint, all)
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send TCP
|
||
|
|
|
||
|
|
send_tcp1 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send(io, socket, buf, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_tcp2 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send2(io, socket, buf, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_tcp3 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send3(io, socket, buf, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send UDP
|
||
|
|
|
||
|
|
send_udp1 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, socket: net.UDP_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send(io, socket, buf, p, callback, endpoint)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_udp2 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, socket: net.UDP_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send2(io, socket, buf, p, p2, callback, endpoint)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_udp3 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, socket: net.UDP_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send3(io, socket, buf, p, p2, p3, callback, endpoint)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send All
|
||
|
|
|
||
|
|
send_all :: proc {
|
||
|
|
send_all_tcp1,
|
||
|
|
send_all_tcp2,
|
||
|
|
send_all_tcp3,
|
||
|
|
send_all_udp1,
|
||
|
|
send_all_udp2,
|
||
|
|
send_all_udp3,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send All TCP
|
||
|
|
|
||
|
|
send_all_tcp1 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send(io, socket, buf, p, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_all_tcp2 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send2(io, socket, buf, p, p2, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_all_tcp3 :: proc(io: ^nbio.IO, socket: net.TCP_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send3(io, socket, buf, p, p2, p3, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Send All UDP
|
||
|
|
|
||
|
|
send_all_udp1 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, socket: net.UDP_Socket, buf: []byte, p: $T, callback: $C/proc(p: T, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send(io, socket, buf, p, callback, endpoint, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_all_udp2 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, socket: net.UDP_Socket, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send2(io, socket, buf, p, p2, callback, endpoint, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
send_all_udp3 :: proc(io: ^nbio.IO, endpoint: net.Endpoint, socket: net.UDP_Socket, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, sent: int, err: net.Network_Error))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_send3(io, socket, buf, p, p2, p3, callback, endpoint, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read Internal
|
||
|
|
|
||
|
|
_read :: proc(io: ^nbio.IO, fd: os.Handle, offset: Maybe(int), buf: []byte, p: $T, callback: $C/proc(p: T, read: int, err: os.Errno), all := false)
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._read(io, fd, offset, buf, nil, proc(completion: rawptr, read: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, read, err)
|
||
|
|
}, all)
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_read2 :: proc(io: ^nbio.IO, fd: os.Handle, offset: Maybe(int), buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, read: int, err: os.Errno), all := false)
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._read(io, fd, offset, buf, nil, proc(completion: rawptr, read: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, read, err)
|
||
|
|
}, all)
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_read3 :: proc(io: ^nbio.IO, fd: os.Handle, offset: Maybe(int), buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, read: int, err: os.Errno), all := false)
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._read(io, fd, offset, buf, nil, proc(completion: rawptr, read: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, read, err)
|
||
|
|
}, all)
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read
|
||
|
|
|
||
|
|
read :: proc {
|
||
|
|
read1,
|
||
|
|
read2,
|
||
|
|
read3,
|
||
|
|
}
|
||
|
|
|
||
|
|
read1 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, callback: $C/proc(p: T, read: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read(io, fd, nil, buf, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
read2 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read2(io, fd, nil, buf, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
read3 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read3(io, fd, nil, buf, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read All
|
||
|
|
|
||
|
|
read_all :: proc {
|
||
|
|
read_all1,
|
||
|
|
read_all2,
|
||
|
|
read_all3,
|
||
|
|
}
|
||
|
|
|
||
|
|
read_all1 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, callback: $C/proc(p: T, read: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read(io, fd, nil, buf, p, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
read_all2 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read2(io, fd, nil, buf, p, p2, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
read_all3 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read3(io, fd, nil, buf, p, p2, p3, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read At
|
||
|
|
|
||
|
|
read_at :: proc {
|
||
|
|
read_at1,
|
||
|
|
read_at2,
|
||
|
|
read_at3,
|
||
|
|
}
|
||
|
|
|
||
|
|
read_at1 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, callback: $C/proc(p: T, read: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read(io, fd, offset, buf, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
read_at2 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read2(io, fd, offset, buf, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
read_at3 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read3(io, fd, offset, buf, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read At All
|
||
|
|
|
||
|
|
read_at_all :: proc {
|
||
|
|
read_at_all1,
|
||
|
|
read_at_all2,
|
||
|
|
read_at_all3,
|
||
|
|
}
|
||
|
|
|
||
|
|
read_at_all1 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, callback: $C/proc(p: T, read: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read(io, fd, offset, buf, p, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
read_at_all2 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read2(io, fd, offset, buf, p, p2, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
read_at_all3 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, read: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_read3(io, fd, offset, buf, p, p2, p3, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Read Full / Entire File
|
||
|
|
|
||
|
|
read_entire_file :: read_full
|
||
|
|
|
||
|
|
read_full :: proc {
|
||
|
|
read_full1,
|
||
|
|
read_full2,
|
||
|
|
read_full3,
|
||
|
|
}
|
||
|
|
|
||
|
|
read_full1 :: proc(io: ^nbio.IO, fd: os.Handle, p: $T, callback: $C/proc(p: T, buf: []byte, read: int, err: os.Errno), allocator := context.allocator)
|
||
|
|
where size_of(T) + size_of([]byte) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
size, err := seek(io, fd, 0, .End)
|
||
|
|
if err != os.ERROR_NONE {
|
||
|
|
callback(p, nil, 0, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
if size <= 0 {
|
||
|
|
callback(p, nil, 0, os.ERROR_NONE)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
buf := make([]byte, size, allocator)
|
||
|
|
|
||
|
|
completion := nbio._read(io, fd, 0, buf, nil, proc(completion: rawptr, read: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
buf := (^[]byte)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C) + size_of([]byte):]))^
|
||
|
|
|
||
|
|
cb(p, buf, read, err)
|
||
|
|
}, all = true)
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&buf))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
read_full2 :: proc(io: ^nbio.IO, fd: os.Handle, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, buf: []byte, read: int, err: os.Errno), allocator := context.allocator)
|
||
|
|
where size_of(T) + size_of(T2) + size_of([]byte) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
size, err := seek(io, fd, 0, .End)
|
||
|
|
if err != os.ERROR_NONE {
|
||
|
|
callback(p, p2, nil, 0, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
if size <= 0 {
|
||
|
|
callback(p, p2, nil, 0, os.ERROR_NONE)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
buf := make([]byte, size, allocator)
|
||
|
|
|
||
|
|
completion := nbio._read(io, fd, 0, buf, nil, proc(completion: rawptr, read: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
buf := (^[]byte)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C) + size_of([]byte):]))^
|
||
|
|
p2 := (^T2) (raw_data(completion.user_args[size_of(C) + size_of([]byte) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, buf, read, err)
|
||
|
|
}, all = true)
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&buf))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
read_full3 :: proc(io: ^nbio.IO, fd: os.Handle, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, buf: []byte, read: int, err: os.Errno), allocator := context.allocator)
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) + size_of([]byte) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
size, err := seek(io, fd, 0, .End)
|
||
|
|
if err != os.ERROR_NONE {
|
||
|
|
callback(p, p2, p3, nil, 0, err)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
if size <= 0 {
|
||
|
|
callback(p, p2, p3, nil, 0, os.ERROR_NONE)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
buf := make([]byte, size, allocator)
|
||
|
|
|
||
|
|
completion := nbio._read(io, fd, 0, buf, nil, proc(completion: rawptr, read: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
buf := (^[]byte)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C) + size_of([]byte):]))^
|
||
|
|
p2 := (^T2) (raw_data(completion.user_args[size_of(C) + size_of([]byte) + size_of(T):]))^
|
||
|
|
p3 := (^T3) (raw_data(completion.user_args[size_of(C) + size_of([]byte) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, buf, read, err)
|
||
|
|
}, all = true)
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&buf))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write Internal
|
||
|
|
|
||
|
|
_write :: proc(io: ^nbio.IO, fd: os.Handle, offset: Maybe(int), buf: []byte, p: $T, callback: $C/proc(p: T, written: int, err: os.Errno), all := false)
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._write(io, fd, offset, buf, nil, proc(completion: rawptr, written: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, written, err)
|
||
|
|
}, all)
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_write2 :: proc(io: ^nbio.IO, fd: os.Handle, offset: Maybe(int), buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, written: int, err: os.Errno), all := false)
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._write(io, fd, offset, buf, nil, proc(completion: rawptr, written: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, written, err)
|
||
|
|
}, all)
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
_write3 :: proc(io: ^nbio.IO, fd: os.Handle, offset: Maybe(int), buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, written: int, err: os.Errno), all := false)
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._write(io, fd, offset, buf, nil, proc(completion: rawptr, written: int, err: os.Errno) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, written, err)
|
||
|
|
}, all)
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write
|
||
|
|
|
||
|
|
write :: proc {
|
||
|
|
write1,
|
||
|
|
write2,
|
||
|
|
write3,
|
||
|
|
}
|
||
|
|
|
||
|
|
write1 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, callback: $C/proc(p: T, written: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write(io, fd, nil, buf, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
write2 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write2(io, fd, nil, buf, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
write3 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write3(io, fd, nil, buf, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write All
|
||
|
|
|
||
|
|
write_all :: proc {
|
||
|
|
write_all1,
|
||
|
|
write_all2,
|
||
|
|
write_all3,
|
||
|
|
}
|
||
|
|
|
||
|
|
write_all1 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, callback: $C/proc(p: T, written: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write(io, fd, nil, buf, p, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
write_all2 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write2(io, fd, nil, buf, p, p2, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
write_all3 :: proc(io: ^nbio.IO, fd: os.Handle, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write3(io, fd, nil, buf, p, p2, p3, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write At
|
||
|
|
|
||
|
|
write_at :: proc {
|
||
|
|
write_at1,
|
||
|
|
write_at2,
|
||
|
|
write_at3,
|
||
|
|
}
|
||
|
|
|
||
|
|
write_at1 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, callback: $C/proc(p: T, written: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write(io, fd, offset, buf, p, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
write_at2 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write2(io, fd, offset, buf, p, p2, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
write_at3 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write3(io, fd, offset, buf, p, p2, p3, callback)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Write At All
|
||
|
|
|
||
|
|
write_at_all :: proc {
|
||
|
|
write_at_all1,
|
||
|
|
write_at_all2,
|
||
|
|
write_at_all3,
|
||
|
|
}
|
||
|
|
|
||
|
|
write_at_all1 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, callback: $C/proc(p: T, written: int, err: os.Errno))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write(io, fd, offset, buf, p, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
write_at_all2 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write2(io, fd, offset, buf, p, p2, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
write_at_all3 :: proc(io: ^nbio.IO, fd: os.Handle, offset: int, buf: []byte, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, written: int, err: os.Errno))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
_write3(io, fd, offset, buf, p, p2, p3, callback, all = true)
|
||
|
|
}
|
||
|
|
|
||
|
|
next_tick1 :: proc(io: ^IO, p: $T, callback: $C/proc(p: T))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._next_tick(io, nil, proc(completion: rawptr) {
|
||
|
|
completion := (^Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
next_tick2 :: proc(io: ^nbio.IO, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._next_tick(io, nil, proc(completion: rawptr) {
|
||
|
|
completion := (^nbio.Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
next_tick3 :: proc(io: ^IO, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._next_tick(io, nil, proc(completion: rawptr) {
|
||
|
|
completion := (^Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
next_tick :: proc {
|
||
|
|
next_tick1,
|
||
|
|
next_tick2,
|
||
|
|
next_tick3,
|
||
|
|
}
|
||
|
|
|
||
|
|
poll1 :: proc(io: ^IO, fd: os.Handle, event: Poll_Event, multi: bool, p: $T, callback: $C/proc(p: T, event: Poll_Event))
|
||
|
|
where size_of(T) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._poll(io, fd, event, multi, nil, proc(completion: rawptr, event: Poll_Event) {
|
||
|
|
completion := (^Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
|
||
|
|
cb(p, event)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p := callback, p
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
poll2 :: proc(io: ^IO, fd: os.Handle, event: Poll_Event, multi: bool, p: $T, p2: $T2, callback: $C/proc(p: T, p2: T2, event: Poll_Event))
|
||
|
|
where size_of(T) + size_of(T2) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._poll(io, fd, event, multi, nil, proc(completion: rawptr, event: Poll_Event) {
|
||
|
|
completion := (^Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C)(&completion.user_args[0])^
|
||
|
|
p := (^T)(raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
|
||
|
|
cb(p, p2, event)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2 := callback, p, p2
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
poll3 :: proc(io: ^IO, fd: os.Handle, event: Poll_Event, multi: bool, p: $T, p2: $T2, p3: $T3, callback: $C/proc(p: T, p2: T2, p3: T3, event: Poll_Event))
|
||
|
|
where size_of(T) + size_of(T2) + size_of(T3) <= nbio.MAX_USER_ARGUMENTS {
|
||
|
|
completion := nbio._poll(io, fd, event, multi, nil, proc(completion: rawptr, event: Poll_Event) {
|
||
|
|
completion := (^Completion)(completion)
|
||
|
|
|
||
|
|
cb := (^C) (&completion.user_args[0])^
|
||
|
|
p := (^T) (raw_data(completion.user_args[size_of(C):]))^
|
||
|
|
p2 := (^T2)(raw_data(completion.user_args[size_of(C) + size_of(T):]))^
|
||
|
|
p3 := (^T3)(raw_data(completion.user_args[size_of(C) + size_of(T) + size_of(T2):]))^
|
||
|
|
|
||
|
|
cb(p, p2, p3, event)
|
||
|
|
})
|
||
|
|
|
||
|
|
callback, p, p2, p3 := callback, p, p2, p3
|
||
|
|
n := copy(completion.user_args[:], mem.ptr_to_bytes(&callback))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p))
|
||
|
|
n += copy(completion.user_args[n:], mem.ptr_to_bytes(&p2))
|
||
|
|
_ = copy(completion.user_args[n:], mem.ptr_to_bytes(&p3))
|
||
|
|
|
||
|
|
completion.user_data = completion
|
||
|
|
}
|
||
|
|
|
||
|
|
poll :: proc {
|
||
|
|
poll1,
|
||
|
|
poll2,
|
||
|
|
poll3,
|
||
|
|
}
|