package core:sync/chan

Source

Chan :: struct($T: typeid, $D: Direction = Direction.Both) {}

Direction :: enum int {
	Send = -1, 
	Both = 0, 
	Recv = 1, 
}

Raw_Chan :: struct {
	// Shared
	allocator:       runtime.Allocator,
	allocation_size: int,
	msg_size:        u16,
	closed:          b16,
	// atomic
	mutex:           sync.Mutex,
	r_cond:          sync.Cond,
	w_cond:          sync.Cond,
	r_waiting:       int,
	// atomic
	w_waiting:       int,
	// Buffered
	queue:           ^Raw_Queue,
	// Unbuffered
	r_mutex:         sync.Mutex,
	w_mutex:         sync.Mutex,
	unbuffered_data: rawptr,
}

Raw_Queue :: struct {
	data: [^]u8,
	len:  int,
	cap:  int,
	next: int,
	size: int,
}

as_recv :: proc "contextless" (c: $C/Chan($T, $D)) -> (r: Chan($T, $D=1)) {…}

as_send :: proc "contextless" (c: $C/Chan($T, $D)) -> (s: Chan($T, $D=-1)) {…}

can_recv :: proc "contextless" (c: ^Raw_Chan) -> bool {…}

can_send :: proc "contextless" (c: ^Raw_Chan) -> bool {…}

cap :: proc "contextless" (c: ^Raw_Chan) -> int {…}

close :: proc "contextless" (c: ^Raw_Chan) -> bool {…}

create_buffered :: proc($C: typeid/Chan($T, $D=0), #any_int cap: int, allocator: runtime.Allocator) -> (c: $/Chan($T, $D=0), err: runtime.Allocator_Error) {…}

create_raw_buffered :: proc(#any_int msg_size, #any_int msg_alignment: int, #any_int cap: int, allocator: runtime.Allocator) -> (c: ^Raw_Chan, err: runtime.Allocator_Error) {…}

create_raw_unbuffered :: proc(#any_int msg_size, #any_int msg_alignment: int, allocator: runtime.Allocator) -> (c: ^Raw_Chan, err: runtime.Allocator_Error) {…}

create_unbuffered :: proc($C: typeid/Chan($T, $D=0), allocator: runtime.Allocator) -> (c: $/Chan($T, $D=0), err: runtime.Allocator_Error) {…}

destroy :: proc(c: ^Raw_Chan) -> (err: runtime.Allocator_Error) {…}

is_buffered :: proc "contextless" (c: ^Raw_Chan) -> bool {…}

is_closed :: proc "contextless" (c: ^Raw_Chan) -> bool {…}

is_unbuffered :: proc "contextless" (c: ^Raw_Chan) -> bool {…}

len :: proc "contextless" (c: ^Raw_Chan) -> int {…}

raw_queue_init :: proc "contextless" (q: ^Raw_Queue, data: rawptr, cap: int, size: int) {…}

raw_queue_pop :: proc "contextless" (q: ^Raw_Queue) -> (data: rawptr) {…}

raw_queue_push :: proc "contextless" (q: ^Raw_Queue, data: rawptr) -> bool {…}

recv :: proc "contextless" (c: $C/Chan($T, $D=0)) -> (data: $T, ok: bool) {…}

recv_raw :: proc "contextless" (c: ^Raw_Chan, msg_out: rawptr) -> (ok: bool) {…}

select_raw :: proc(recvs: []^Raw_Chan, sends: []^Raw_Chan, send_msgs: []rawptr, recv_out: rawptr) -> (select_idx: int, ok: bool) {…}

send :: proc "contextless" (c: $C/Chan($T, $D), data: $T) -> (ok: bool) {…}

send_raw :: proc "contextless" (c: ^Raw_Chan, msg_in: rawptr) -> (ok: bool) {…}

try_recv :: proc "contextless" (c: $C/Chan($T, $D=0)) -> (data: $T, ok: bool) {…}

try_recv_raw :: proc "contextless" (c: ^Raw_Chan, msg_out: rawptr) -> bool {…}

try_send :: proc "contextless" (c: $C/Chan($T, $D), data: $T) -> (ok: bool) {…}

try_send_raw :: proc "contextless" (c: ^Raw_Chan, msg_in: rawptr) -> (ok: bool) {…}

create :: proc{
	create_unbuffered,
	create_buffered,
}

create_raw :: proc{
	create_raw_unbuffered,
	create_raw_buffered,
}