buf.zig

const std = @import("std");
const os = std.os;
const Allocator = std.mem.Allocator;
const RESP3 = @import("./parser.zig").RESP3Parser;
const ArgSerializer = @import("./serializer.zig").ArgSerializer;

pub const Client = struct {
    broken: bool = false,
    fd: os.fd_t,
    sock: std.fs.File,
    sock_addr: os.sockaddr,
    in: std.fs.File.InStream,
    out: std.fs.File.OutStream,
    bufin: InBuff,
    bufout: OutBuff,

    const Self = @This();
    const InBuff = std.io.BufferedInStream(std.fs.File.InStream.Error);
    const OutBuff = std.io.BufferedOutStream(std.fs.File.OutStream.Error);

    pub fn initIp4(addr: []const u8, port: u16) !Self {
        const sockfd = try os.socket(os.AF_INET, os.SOCK_STREAM, 0);
        errdefer os.close(sockfd);
        var new: Self = undefined;

        var sock_addr = os.sockaddr{ .in = undefined };
        sock_addr.in.family = os.AF_INET;
        sock_addr.in.port = std.mem.nativeToBig(u16, port);
        sock_addr.in.addr = try std.net.parseIp4(addr);
        sock_addr.in.zero = [_]u8{0} ** 8;

        try os.connect(sockfd, &sock_addr, @sizeOf(os.sockaddr_in));

        var sock = std.fs.File.openHandle(sockfd);
        var in = sock.inStream();
        var out = sock.outStream();
        var bufin = InBuff.init(&in.stream);
        var bufout = OutBuff.init(&out.stream);

        // try new.out.stream.write("*2\r\n$5\r\nHELLO\r\n$1\r\n3\r\n");
        try bufout.stream.write("*2\r\n$5\r\nHELLO\r\n$1\r\n3\r\n");
        try bufout.flush();
        RESP3.parse(void, &bufin.stream) catch |err| switch (err) {
            else => return err,
            error.GotErrorReply => @panic("Sorry, heyredis is RESP3 only and requires a Redis server built from the unstable branch."),
        };

        return Self{
            .fd = sockfd,
            .sock = sock,
            .sock_addr = sock_addr,
            .in = in,
            .out = out,
            .bufin = bufin,
            .bufout = bufout,
        };
    }

    pub fn close(self: Self) void {
        os.close(self.fd);
    }

    pub fn send(self: *Self, comptime T: type, args: ...) !T {
        if (self.broken) return error.BrokenConnection;
        errdefer self.broken = true;

        // try ArgSerializer.serialize(&self.out.stream, args);
        try ArgSerializer.serialize(&self.bufout.stream, args);
        try self.bufout.flush();
        return RESP3.parse(T, &self.bufin.stream);
    }

    pub fn sendAlloc(self: *Self, comptime T: type, allocator: *Allocator, args: ...) !T {
        if (self.broken) return error.BrokenConnection;
        errdefer self.broken = true;

        // try ArgSerializer.serialize(&self.out.stream, args);
        try ArgSerializer.serialize(&self.bufout.stream, args);
        try self.bufout.flush();
        return RESP3.parseAlloc(T, allocator, &self.bufin.stream);
    }
};

diff --git a/buf.zig b/buf.zig
index 43636f5..d6afe04 100644
--- a/buf.zig
+++ b/buf.zig
@@ -18,42 +18,31 @@ pub const Client = struct {
     const InBuff = std.io.BufferedInStream(std.fs.File.InStream.Error);
     const OutBuff = std.io.BufferedOutStream(std.fs.File.OutStream.Error);
 
-    pub fn initIp4(addr: []const u8, port: u16) !Self {
+    pub fn initIp4(self: *Self, addr: []const u8, port: u16) !void {
         const sockfd = try os.socket(os.AF_INET, os.SOCK_STREAM, 0);
         errdefer os.close(sockfd);
-        var new: Self = undefined;
 
-        var sock_addr = os.sockaddr{ .in = undefined };
-        sock_addr.in.family = os.AF_INET;
-        sock_addr.in.port = std.mem.nativeToBig(u16, port);
-        sock_addr.in.addr = try std.net.parseIp4(addr);
-        sock_addr.in.zero = [_]u8{0} ** 8;
+        self.sock_addr = os.sockaddr{ .in = undefined };
+        self.sock_addr.in.family = os.AF_INET;
+        self.sock_addr.in.port = std.mem.nativeToBig(u16, port);
+        self.sock_addr.in.addr = try std.net.parseIp4(addr);
+        self.sock_addr.in.zero = [_]u8{0} ** 8;
 
-        try os.connect(sockfd, &sock_addr, @sizeOf(os.sockaddr_in));
+        try os.connect(sockfd, &self.sock_addr, @sizeOf(os.sockaddr_in));
 
-        var sock = std.fs.File.openHandle(sockfd);
-        var in = sock.inStream();
-        var out = sock.outStream();
-        var bufin = InBuff.init(&in.stream);
-        var bufout = OutBuff.init(&out.stream);
+        self.sock = std.fs.File.openHandle(sockfd);
+        self.in = sock.inStream();
+        self.out = sock.outStream();
+        self.bufin = InBuff.init(&in.stream);
+        self.bufout = OutBuff.init(&out.stream);
 
         // try new.out.stream.write("*2\r\n$5\r\nHELLO\r\n$1\r\n3\r\n");
-        try bufout.stream.write("*2\r\n$5\r\nHELLO\r\n$1\r\n3\r\n");
-        try bufout.flush();
-        RESP3.parse(void, &bufin.stream) catch |err| switch (err) {
+        try self.bufout.stream.write("*2\r\n$5\r\nHELLO\r\n$1\r\n3\r\n");
+        try self.bufout.flush();
+        RESP3.parse(void, &self.bufin.stream) catch |err| switch (err) {
             else => return err,
             error.GotErrorReply => @panic("Sorry, heyredis is RESP3 only and requires a Redis server built from the unstable branch."),
         };
-
-        return Self{
-            .fd = sockfd,
-            .sock = sock,
-            .sock_addr = sock_addr,
-            .in = in,
-            .out = out,
-            .bufin = bufin,
-            .bufout = bufout,
-        };
     }
 
     pub fn close(self: Self) void {

var client: Client = undefined;
client.initIp4(...);