mirror of
https://github.com/sbrow/zomq.git
synced 2026-08-26 10:53:32 -04:00
120 lines
3.0 KiB
Odin
120 lines
3.0 KiB
Odin
package zmq
|
|
|
|
import "core:c"
|
|
|
|
foreign import lib "system:zmq"
|
|
|
|
@(default_calling_convention = "c")
|
|
foreign lib {
|
|
@(link_name = "zmq_ctx_new") _ctx_new :: proc() -> rawptr ---
|
|
@(link_name = "zmq_ctx_term") _ctx_term :: proc(ctx: rawptr) -> c.int ---
|
|
@(link_name = "zmq_socket") _socket :: proc(ctx: rawptr, type: Socket_Type) -> rawptr ---
|
|
@(link_name = "zmq_close") _close :: proc(s: rawptr) -> c.int ---
|
|
@(link_name = "zmq_bind") _bind :: proc(s: rawptr, addr: cstring) -> c.int ---
|
|
@(link_name = "zmq_connect") _connect :: proc(s: rawptr, addr: cstring) -> c.int ---
|
|
@(link_name = "zmq_send") _send :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> c.int ---
|
|
@(link_name = "zmq_recv") _recv :: proc(s: rawptr, buf: rawptr, len: c.size_t, flags: c.int) -> c.int ---
|
|
@(link_name = "zmq_errno") _errno :: proc() -> c.int ---
|
|
@(link_name = "zmq_strerror") _strerror :: proc(errnum: c.int) -> cstring ---
|
|
@(link_name = "zmq_version") _version :: proc(major, minor, patch: ^c.int) ---
|
|
}
|
|
|
|
Context :: distinct rawptr
|
|
Socket :: distinct rawptr
|
|
|
|
Socket_Type :: enum c.int {
|
|
PAIR = 0,
|
|
PUB = 1,
|
|
SUB = 2,
|
|
REQ = 3,
|
|
REP = 4,
|
|
DEALER = 5,
|
|
ROUTER = 6,
|
|
PULL = 7,
|
|
PUSH = 8,
|
|
XPUB = 9,
|
|
XSUB = 10,
|
|
STREAM = 11,
|
|
}
|
|
|
|
Flag :: enum c.int {
|
|
DONTWAIT = 1,
|
|
SNDMORE = 2,
|
|
}
|
|
|
|
Flags :: bit_set[Flag; c.int]
|
|
|
|
NoBlock :: Flags{.DONTWAIT}
|
|
|
|
Error :: distinct c.int
|
|
|
|
OK :: Error(0)
|
|
|
|
is_ok :: proc(e: Error) -> bool { return c.int(e) == 0 }
|
|
|
|
error_string :: proc(e: Error) -> string {
|
|
return string(_strerror(c.int(e)))
|
|
}
|
|
|
|
last_error :: proc() -> Error { return Error(_errno()) }
|
|
|
|
version :: proc() -> (major, minor, patch: int) {
|
|
ma, mi, pa: c.int = 0, 0, 0
|
|
_version(&ma, &mi, &pa)
|
|
return int(ma), int(mi), int(pa)
|
|
}
|
|
|
|
new_context :: proc() -> Context {
|
|
return Context(_ctx_new())
|
|
}
|
|
|
|
term :: proc(ctx: Context) -> Error {
|
|
return _ctx_term(rawptr(ctx)) == 0 ? OK : last_error()
|
|
}
|
|
|
|
socket :: proc(ctx: Context, type: Socket_Type) -> (Socket, Error) {
|
|
s := _socket(rawptr(ctx), type)
|
|
if s == nil {
|
|
return nil, last_error()
|
|
}
|
|
return Socket(s), OK
|
|
}
|
|
|
|
close :: proc(s: Socket) -> Error {
|
|
return _close(rawptr(s)) == 0 ? OK : last_error()
|
|
}
|
|
|
|
bind :: proc(s: Socket, addr: string) -> Error {
|
|
return endpoint(rawptr(s), addr, _bind)
|
|
}
|
|
|
|
connect :: proc(s: Socket, addr: string) -> Error {
|
|
return endpoint(rawptr(s), addr, _connect)
|
|
}
|
|
|
|
send :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
|
|
n := _send(rawptr(s), rawptr(&buf[0]), c.size_t(len(buf)), transmute(c.int)flags)
|
|
if n < 0 {
|
|
return -1, last_error()
|
|
}
|
|
return int(n), OK
|
|
}
|
|
|
|
recv :: proc(s: Socket, buf: []u8, flags: Flags = Flags{}) -> (int, Error) {
|
|
n := _recv(rawptr(s), rawptr(&buf[0]), c.size_t(len(buf)), transmute(c.int)flags)
|
|
if n < 0 {
|
|
return -1, last_error()
|
|
}
|
|
return int(n), OK
|
|
}
|
|
|
|
endpoint :: proc(s: rawptr, addr: string, f: proc "c" (s: rawptr, addr: cstring) -> c.int) -> Error {
|
|
buf: [256]u8
|
|
n := copy(buf[:], addr)
|
|
if n >= len(buf) {
|
|
return Error(7)
|
|
}
|
|
buf[n] = 0
|
|
return f(s, cstring(rawptr(&buf[0]))) == 0 ? OK : last_error()
|
|
}
|