example.proto.zig

// =============================================================================
// DO NOT EDIT - This file is automatically generated by gremlin.zig
// =============================================================================
const std = @import("std");
const gremlin = @import("gremlin");
// structs
const UserWire = struct {
    const NAME_WIRE: gremlin.ProtoWireNumber = 1;
    const ID_WIRE: gremlin.ProtoWireNumber = 2;
    const TAGS_WIRE: gremlin.ProtoWireNumber = 10;
};
pub const User = struct {
    // fields
    name: ?[]const u8 = null,
    id: u64 = 0,
    tags: ?[]const ?[]const u8 = null,
    pub fn calcProtobufSize(self: *const User) usize {
        var res: usize = 0;
        if (self.name) |v| {
            if (v.len > 0) {
                res += gremlin.sizes.sizeWireNumber(UserWire.NAME_WIRE) + gremlin.sizes.sizeUsize(v.len) + v.len;
            }
        }
        if (self.id != 0) {
            res += gremlin.sizes.sizeWireNumber(UserWire.ID_WIRE) + gremlin.sizes.sizeU64(self.id);
        }
        if (self.tags) |arr| {
            for (arr) |maybe_v| {
                res += gremlin.sizes.sizeWireNumber(UserWire.TAGS_WIRE);
                if (maybe_v) |v| {
                    res += gremlin.sizes.sizeUsize(v.len) + v.len;
                } else {
                    res += gremlin.sizes.sizeUsize(0);
                }
            }
        }
        return res;
    }
    pub fn encode(self: *const User, allocator: std.mem.Allocator) gremlin.Error![]const u8 {
        const size = self.calcProtobufSize();
        if (size == 0) {
            return &[_]u8{};
        }
        const buf = try allocator.alloc(u8, self.calcProtobufSize());
        var writer = gremlin.Writer.init(buf);
        self.encodeTo(&writer);
        return buf;
    }
    pub fn encodeTo(self: *const User, target: *gremlin.Writer) void {
        if (self.name) |v| {
            if (v.len > 0) {
                target.appendBytes(UserWire.NAME_WIRE, v);
            }
        }
        if (self.id != 0) {
            target.appendUint64(UserWire.ID_WIRE, self.id);
        }
        if (self.tags) |arr| {
            for (arr) |maybe_v| {
                if (maybe_v) |v| {
                    target.appendBytes(UserWire.TAGS_WIRE, v);
                } else {
                    target.appendBytesTag(UserWire.TAGS_WIRE, 0);
                }
            }
        }
    }
};
pub const UserReader = struct {
    buf: gremlin.Reader,
    _name: ?[]const u8 = null,
    _id: u64 = 0,
    _tags_offset: ?usize = null,
    _tags_last_offset: ?usize = null,
    _tags_cnt: usize = 0,
    pub fn init(src: []const u8) gremlin.Error!UserReader {
        const buf = gremlin.Reader.init(src);
        var res = UserReader{ .buf = buf };
        if (buf.buf.len == 0) {
            return res;
        }
        var offset: usize = 0;
        while (buf.hasNext(offset, 0)) {
            const tag = try buf.readTagAt(offset);
            offset += tag.size;
            switch (tag.number) {
                UserWire.NAME_WIRE => {
                    const result = try buf.readBytes(offset);
                    offset += result.size;
                    res._name = result.value;
                },
                UserWire.ID_WIRE => {
                    const result = try buf.readUInt64(offset);
                    offset += result.size;
                    res._id = result.value;
                },
                UserWire.TAGS_WIRE => {
                    const result = try buf.readBytes(offset);
                    offset += result.size;
                    if (res._tags_offset == null) {
                        res._tags_offset = offset - result.size;
                    }
                    res._tags_last_offset = offset;
                    res._tags_cnt += 1;
                },
                else => {
                    offset = try buf.skipData(offset, tag.wire);
                },
            }
        }
        return res;
    }
    pub fn sourceBytes(self: *const @This()) []const u8 {
        return self.buf.buf;
    }
    pub inline fn getName(self: *const UserReader) []const u8 {
        return self._name orelse &[_]u8{};
    }
    pub inline fn getId(self: *const UserReader) u64 {
        return self._id;
    }
    pub fn tagsCount(self: *const UserReader) usize {
        return self._tags_cnt;
    }
    pub fn tagsNext(self: *UserReader) ?[]const u8 {
        if (self._tags_offset == null) return null;
        const current_offset = self._tags_offset.?;
        const result = self.buf.readBytes(current_offset) catch return null;
        if (self._tags_last_offset != null and current_offset >= self._tags_last_offset.?) {
            self._tags_offset = null;
            return result.value;
        }
        if (self._tags_last_offset == null) unreachable;
        var next_offset = current_offset + result.size;
        const max_offset = self._tags_last_offset.?;
        while (next_offset <= max_offset and self.buf.hasNext(next_offset, 0)) {
            const tag = self.buf.readTagAt(next_offset) catch break;
            next_offset += tag.size;
            if (tag.number == UserWire.TAGS_WIRE) {
                self._tags_offset = next_offset;
                return result.value;
            } else {
                next_offset = self.buf.skipData(next_offset, tag.wire) catch break;
            }
        }
        self._tags_offset = null;
        return result.value;
    }
};