From f16860d1a2188eb22d95d64fc98b667fc2d6e87e Mon Sep 17 00:00:00 2001 From: Oskari Timperi Date: Wed, 11 Apr 2018 18:43:47 +0300 Subject: Reorganize repo --- nimpb.nimble | 3 +- nimpb/json.nim | 209 +++++++ nimpb/nimpb.nim | 605 +++++++++++++++++++ nimpb/wkt/any_pb.nim | 111 ++++ nimpb/wkt/api_pb.nim | 664 +++++++++++++++++++++ nimpb/wkt/duration_pb.nim | 112 ++++ nimpb/wkt/empty_pb.nim | 62 ++ nimpb/wkt/field_mask_pb.nim | 89 +++ nimpb/wkt/source_context_pb.nim | 91 +++ nimpb/wkt/struct_pb.nim | 440 ++++++++++++++ nimpb/wkt/timestamp_pb.nim | 112 ++++ nimpb/wkt/type_pb.nim | 1109 +++++++++++++++++++++++++++++++++++ nimpb/wkt/wrappers_pb.nim | 677 +++++++++++++++++++++ src/nimpb/json.nim | 209 ------- src/nimpb/nimpb.nim | 605 ------------------- src/nimpb/wkt/any_pb.nim | 112 ---- src/nimpb/wkt/api_pb.nim | 664 --------------------- src/nimpb/wkt/duration_pb.nim | 112 ---- src/nimpb/wkt/empty_pb.nim | 62 -- src/nimpb/wkt/field_mask_pb.nim | 89 --- src/nimpb/wkt/source_context_pb.nim | 91 --- src/nimpb/wkt/struct_pb.nim | 440 -------------- src/nimpb/wkt/timestamp_pb.nim | 112 ---- src/nimpb/wkt/type_pb.nim | 1109 ----------------------------------- src/nimpb/wkt/wrappers_pb.nim | 677 --------------------- tests/nim.cfg | 2 +- 26 files changed, 4284 insertions(+), 4284 deletions(-) create mode 100644 nimpb/json.nim create mode 100644 nimpb/nimpb.nim create mode 100644 nimpb/wkt/any_pb.nim create mode 100644 nimpb/wkt/api_pb.nim create mode 100644 nimpb/wkt/duration_pb.nim create mode 100644 nimpb/wkt/empty_pb.nim create mode 100644 nimpb/wkt/field_mask_pb.nim create mode 100644 nimpb/wkt/source_context_pb.nim create mode 100644 nimpb/wkt/struct_pb.nim create mode 100644 nimpb/wkt/timestamp_pb.nim create mode 100644 nimpb/wkt/type_pb.nim create mode 100644 nimpb/wkt/wrappers_pb.nim delete mode 100644 src/nimpb/json.nim delete mode 100644 src/nimpb/nimpb.nim delete mode 100644 src/nimpb/wkt/any_pb.nim delete mode 100644 src/nimpb/wkt/api_pb.nim delete mode 100644 src/nimpb/wkt/duration_pb.nim delete mode 100644 src/nimpb/wkt/empty_pb.nim delete mode 100644 src/nimpb/wkt/field_mask_pb.nim delete mode 100644 src/nimpb/wkt/source_context_pb.nim delete mode 100644 src/nimpb/wkt/struct_pb.nim delete mode 100644 src/nimpb/wkt/timestamp_pb.nim delete mode 100644 src/nimpb/wkt/type_pb.nim delete mode 100644 src/nimpb/wkt/wrappers_pb.nim diff --git a/nimpb.nimble b/nimpb.nimble index 80c6acc..7f55df3 100644 --- a/nimpb.nimble +++ b/nimpb.nimble @@ -2,6 +2,7 @@ version = "0.1.0" author = "Oskari Timperi" description = "protobuf library for Nim" license = "MIT" -srcDir = "src" + +skipDirs = @["examples", "tests"] requires "nim >= 0.18.0" diff --git a/nimpb/json.nim b/nimpb/json.nim new file mode 100644 index 0000000..28cd0f5 --- /dev/null +++ b/nimpb/json.nim @@ -0,0 +1,209 @@ +import base64 +import math +import std/json +import strutils +import times + +import nimpb + +import wkt/duration_pb +import wkt/timestamp_pb +import wkt/wrappers_pb +import wkt/field_mask_pb +import wkt/struct_pb +import wkt/any_pb + +proc `%`*(u: uint32): JsonNode = + newJFloat(float(u)) + +proc `%`*(b: bytes): JsonNode = + result = newJString(base64.encode(string(b), newLine="")) + +proc toJson*(value: float): JsonNode = + case classify(value) + of fcNan: result = %"NaN" + of fcInf: result = %"Infinity" + of fcNegInf: result = %"-Infinity" + else: result = %value + +proc toJson*(value: float32): JsonNode = + case classify(value) + of fcNan: result = %"NaN" + of fcInf: result = %"Infinity" + of fcNegInf: result = %"-Infinity" + else: result = %value + +proc toJson*(value: int64): JsonNode = + newJString($value) + +proc toJson*(value: uint64): JsonNode = + newJString($value) + +proc toJson*(message: google_protobuf_DoubleValue): JsonNode = + if hasValue(message): + result = toJson(message.value) + else: + result = newJNull() + +proc toJson*(message: google_protobuf_FloatValue): JsonNode = + if hasValue(message): + result = toJson(message.value) + else: + result = newJNull() + +proc toJson*(message: google_protobuf_Int64Value): JsonNode = + if hasValue(message): + result = toJson(message.value) + else: + result = newJNull() + +proc toJson*(message: google_protobuf_UInt64Value): JsonNode = + if hasValue(message): + result = toJson(message.value) + else: + result = newJNull() + +proc toJson*(message: google_protobuf_Int32Value): JsonNode = + if hasValue(message): + result = %message.value + else: + result = newJNull() + +proc toJson*(message: google_protobuf_UInt32Value): JsonNode = + if hasValue(message): + result = %message.value + else: + result = newJNull() + +proc toJson*(message: google_protobuf_BoolValue): JsonNode = + if hasValue(message): + result = %message.value + else: + result = newJNull() + +proc toJson*(message: google_protobuf_StringValue): JsonNode = + if hasValue(message): + result = %message.value + else: + result = newJNull() + +proc toJson*(message: google_protobuf_BytesValue): JsonNode = + if hasValue(message): + result = %message.value + else: + result = newJNull() + +proc toJson*(message: google_protobuf_Duration): JsonNode = + if (message.seconds < -315_576_000_000'i64) or + (message.seconds > 315_576_000_000'i64): + raise newException(ValueError, "seconds out of bounds") + + if (message.nanos < -999_999_999'i32) or + (message.nanos > 999_999_999'i32): + raise newException(ValueError, "nanos out of bounds") + + if message.seconds != 0: + if sgn(message.seconds) != sgn(message.nanos): + raise newException(ValueError, "different sign for seconds and nanos") + + var s = $message.seconds + + if message.nanos != 0: + add(s, ".") + add(s, intToStr(message.nanos, 9)) + removeSuffix(s, '0') + + add(s, "s") + + result = %s + +proc toJson*(message: google_protobuf_Timestamp): JsonNode = + let t = utc(fromUnix(message.seconds)) + + if t.year < 1 or t.year > 9999: + raise newException(ValueError, "invalid timestamp") + + var s = format(t, "yyyy-MM-dd'T'HH:mm:ss") + if message.nanos != 0: + add(s, ".") + add(s, intToStr(message.nanos, 9)) + removeSuffix(s, '0') + add(s, "Z") + result = %s + +proc toJson*(message: google_protobuf_FieldMask): JsonNode = + %join(message.paths, ",") + +proc toJson*(message: google_protobuf_Value): JsonNode + +proc toJson*(message: google_protobuf_Struct): JsonNode = + result = newJObject() + for key, value in message.fields: + result[key] = toJson(value) + +proc toJson*(message: google_protobuf_ListValue): JsonNode + +proc toJson*(message: google_protobuf_Value): JsonNode = + if hasNullValue(message): + result = newJNull() + elif hasNumberValue(message): + result = toJson(message.numberValue) + elif hasStringValue(message): + result = %message.stringValue + elif hasBoolValue(message): + result = %message.boolValue + elif hasStructValue(message): + result = toJson(message.structValue) + elif hasListValue(message): + result = toJson(message.listValue) + else: + raise newException(ValueError, "no field set") + +proc toJson*(message: google_protobuf_NullValue): JsonNode = + newJNull() + +proc toJson*(message: google_protobuf_ListValue): JsonNode = + result = newJArray() + for value in message.values: + add(result, toJson(value)) + +proc toJson*(message: google_protobuf_Any): JsonNode = + case message.typeUrl + of "type.googleapis.com/google.protobuf.Duration": + let duration = newGoogleProtobufDuration(string(message.value)) + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = toJson(duration) + of "type.googleapis.com/google.protobuf.Empty": + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = newJObject() + of "type.googleapis.com/google.protobuf.FieldMask": + let mask = newGoogleProtobufFieldMask(string(message.value)) + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = toJson(mask) + of "type.googleapis.com/google.protobuf.Struct": + let struct = newGoogleProtobufStruct(string(message.value)) + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = toJson(struct) + of "type.googleapis.com/google.protobuf.Value": + let value = newGoogleProtobufValue(string(message.value)) + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = toJson(value) + of "type.googleapis.com/google.protobuf.ListValue": + let lst = newGoogleProtobufListValue(string(message.value)) + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = toJson(lst) + of "type.googleapis.com/google.protobuf.Timestamp": + let value = newGoogleProtobufTimestamp(string(message.value)) + result = newJObject() + result["@type"] = %message.typeUrl + result["value"] = toJson(value) + else: + result = newJObject() + result["typeUrl"] = %message.typeUrl + result["value"] = %message.value diff --git a/nimpb/nimpb.nim b/nimpb/nimpb.nim new file mode 100644 index 0000000..4363c7d --- /dev/null +++ b/nimpb/nimpb.nim @@ -0,0 +1,605 @@ +import endians +import intsets +import macros +import streams +import strutils + +export streams + +const + MaximumVarintBytes = 10 + WireTypeBits = 3 + WireTypeMask = (1 shl WireTypeBits) - 1 + +type + ProtobufStreamObj* = object of StreamObj + stream: Stream + + ProtobufStream* = ref ProtobufStreamObj + + Tag* = distinct uint32 + + ParseError* = object of Exception + + InvalidFieldNumberError* = object of ParseError + + UnexpectedWireTypeError* = object of ParseError + + bytes* = distinct string + + WireType* {.pure.} = enum + Varint = 0 + Fixed64 = 1 + LengthDelimited = 2 + StartGroup = 3 + EndGroup = 4 + Fixed32 = 5 + + FieldType* {.pure.} = enum + Double = 1 + Float + Int64 + UInt64 + Int32 + Fixed64 + Fixed32 + Bool + String + Group + Message + Bytes + UInt32 + Enum + SFixed32 + SFixed64 + SInt32 + SInt64 + + UnknownField* = ref UnknownFieldObj + UnknownFieldObj* = object + fieldNumber: int + case wiretype: WireType + of WireType.Varint: + vint: uint64 + of WireType.Fixed64: + fixed64: uint64 + of WireType.LengthDelimited: + data: string + of WireType.Fixed32: + fixed32: uint32 + else: + discard + +proc wiretype*(ft: FieldType): WireType = + case ft + of FieldType.Double: result = WireType.Fixed64 + of FieldType.Float: result = WireType.Fixed32 + of FieldType.Int64: result = WireType.Varint + of FieldType.UInt64: result = WireType.Varint + of FieldType.Int32: result = WireType.Varint + of FieldType.Fixed64: result = WireType.Fixed64 + of FieldType.Fixed32: result = WireType.Fixed32 + of FieldType.Bool: result = WireType.Varint + of FieldType.String: result = WireType.LengthDelimited + of FieldType.Group: result = WireType.LengthDelimited # ??? + of FieldType.Message: result = WireType.LengthDelimited + of FieldType.Bytes: result = WireType.LengthDelimited + of FieldType.UInt32: result = WireType.Varint + of FieldType.Enum: result = WireType.Varint + of FieldType.SFixed32: result = WireType.Fixed32 + of FieldType.SFixed64: result = WireType.Fixed64 + of FieldType.SInt32: result = WireType.Varint + of FieldType.SInt64: result = WireType.Varint + +proc isNumeric*(wiretype: WireType): bool = + case wiretype + of WireType.Varint: result = true + of WireType.Fixed64: result = true + of WireType.Fixed32: result = true + else: result = false + +proc isNumeric*(ft: FieldType): bool = + result = isNumeric(wiretype(ft)) + +proc pbClose(s: Stream) = + close(ProtobufStream(s).stream) + ProtobufStream(s).stream = nil + +proc pbAtEnd(s: Stream): bool = + result = atEnd(ProtobufStream(s).stream) + +proc pbSetPosition(s: Stream, pos: int) = + setPosition(ProtobufStream(s).stream, pos) + +proc pbGetPosition(s: Stream): int = + result = getPosition(ProtobufStream(s).stream) + +proc pbReadData(s: Stream, buffer: pointer, bufLen: int): int = + result = readData(ProtobufStream(s).stream, buffer, bufLen) + +proc pbPeekData(s: Stream, buffer: pointer, bufLen: int): int = + result = peekData(ProtobufStream(s).stream, buffer, bufLen) + +proc pbWriteData(s: Stream, buffer: pointer, bufLen: int) = + writeData(ProtobufStream(s).stream, buffer, bufLen) + +proc pbFlush(s: Stream) = + flush(ProtobufStream(s).stream) + +proc newProtobufStream*(stream: Stream): ProtobufStream = + new(result) + + result.closeImpl = pbClose + result.atEndImpl = pbAtEnd + result.setPositionImpl = pbSetPosition + result.getPositionImpl = pbGetPosition + result.readDataImpl = pbReadData + result.peekDataImpl = pbPeekData + result.writeDataImpl = pbWriteData + result.flushImpl = pbFlush + + result.stream = stream + +proc readByte(stream: ProtobufStream): byte = + result = readInt8(stream).byte + +proc writeByte(stream: ProtobufStream, b: byte) = + var x: byte + shallowCopy(x, b) + writeData(stream, addr(x), sizeof(x)) + +proc readVarint*(stream: ProtobufStream): uint64 = + var + count = 0 + + result = 0 + + while true: + if count == MaximumVarintBytes: + raise newException(Exception, "invalid varint (<= 10 bytes)") + + let b = readByte(stream) + + result = result or ((b.uint64 and 0x7f) shl (7 * count)) + + inc(count) + + if (b and 0x80) == 0: + break + +proc writeVarint*(stream: ProtobufStream, n: uint64) = + var value = n + while value >= 0x80'u64: + writeByte(stream, (value or 0x80).byte) + value = value shr 7 + writeByte(stream, value.byte) + +proc zigzagEncode*(n: int32): uint32 = + let x = cast[uint32](n) + let a = cast[int32](x shl 1) + let b = -cast[int32](x shr 31) + result = uint32(a xor b) + +proc zigzagDecode*(n: uint32): int32 = + let a = int32(n shr 1) + let b = -int32(n and 1) + result = a xor b + +proc zigzagEncode*(n: int64): uint64 = + let x = cast[uint64](n) + let a = cast[int64](x shl 1) + let b = -cast[int64](x shr 63) + result = uint64(a xor b) + +proc zigzagDecode*(n: uint64): int64 = + let a = int64(n shr 1) + let b = -int64(n and 1) + result = a xor b + +template makeTag*(fieldNumber: int, wireType: WireType): Tag = + ((fieldNumber shl 3).uint32 or wireType.uint32).Tag + +template wireType*(tag: Tag): WireType = + (tag.uint32 and WireTypeMask).WireType + +template fieldNumber*(tag: Tag): int = + (tag.uint32 shr 3).int + +proc writeTag*(stream: ProtobufStream, tag: Tag) = + writeVarint(stream, tag.uint32) + +proc writeTag*(stream: ProtobufStream, fieldNumber: int, wireType: WireType) = + writeTag(stream, makeTag(fieldNumber, wireType)) + +proc readTag*(stream: ProtobufStream): Tag = + result = readVarint(stream).Tag + +proc writeInt32*(stream: ProtobufStream, n: int32) = + writeVarint(stream, n.uint64) + +proc writeInt32*(stream: ProtobufStream, n: int32, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeInt32(stream, n) + +proc readInt32*(stream: ProtobufStream): int32 = + result = readVarint(stream).int32 + +proc writeSInt32*(stream: ProtobufStream, n: int32) = + writeVarint(stream, zigzagEncode(n)) + +proc writeSInt32*(stream: ProtobufStream, n: int32, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeVarint(stream, zigzagEncode(n)) + +proc readSInt32*(stream: ProtobufStream): int32 = + result = zigzagDecode(readVarint(stream).uint32) + +proc writeUInt32*(stream: ProtobufStream, n: uint32) = + writeVarint(stream, n) + +proc writeUInt32*(stream: ProtobufStream, n: uint32, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeVarint(stream, n) + +proc readUInt32*(stream: ProtobufStream): uint32 = + result = readVarint(stream).uint32 + +proc writeInt64*(stream: ProtobufStream, n: int64) = + writeVarint(stream, n.uint64) + +proc writeInt64*(stream: ProtobufStream, n: int64, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeVarint(stream, n.uint64) + +proc readInt64*(stream: ProtobufStream): int64 = + result = readVarint(stream).int64 + +proc writeSInt64*(stream: ProtobufStream, n: int64) = + writeVarint(stream, zigzagEncode(n)) + +proc writeSInt64*(stream: ProtobufStream, n: int64, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeVarint(stream, zigzagEncode(n)) + +proc readSInt64*(stream: ProtobufStream): int64 = + result = zigzagDecode(readVarint(stream)) + +proc writeUInt64*(stream: ProtobufStream, n: uint64) = + writeVarint(stream, n) + +proc writeUInt64*(stream: ProtobufStream, n: uint64, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeVarint(stream, n) + +proc readUInt64*(stream: ProtobufStream): uint64 = + result = readVarint(stream) + +proc writeBool*(stream: ProtobufStream, value: bool) = + writeVarint(stream, value.uint32) + +proc writeBool*(stream: ProtobufStream, n: bool, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeVarint(stream, n.uint32) + +proc readBool*(stream: ProtobufStream): bool = + result = readVarint(stream).bool + +proc writeFixed64*(stream: ProtobufStream, value: uint64) = + var + input = value + output: uint64 + + littleEndian64(addr(output), addr(input)) + + write(stream, output) + +proc writeFixed64*(stream: ProtobufStream, n: uint64, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Fixed64) + writeFixed64(stream, n) + +proc readFixed64*(stream: ProtobufStream): uint64 = + var tmp: uint64 + if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): + raise newException(IOError, "cannot read from stream") + littleEndian64(addr(result), addr(tmp)) + +proc writeSFixed64*(stream: ProtobufStream, value: int64) = + writeFixed64(stream, cast[uint64](value)) + +proc writeSFixed64*(stream: ProtobufStream, value: int64, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Fixed64) + writeSFixed64(stream, value) + +proc readSFixed64*(stream: ProtobufStream): int64 = + result = cast[int64](readFixed64(stream)) + +proc writeDouble*(stream: ProtobufStream, value: float64) = + var + input = value + output: float64 + + littleEndian64(addr(output), addr(input)) + + write(stream, output) + +proc writeDouble*(stream: ProtobufStream, value: float64, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Fixed64) + writeDouble(stream, value) + +proc readDouble*(stream: ProtobufStream): float64 = + var tmp: uint64 + if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): + raise newException(IOError, "cannot read from stream") + littleEndian64(addr(result), addr(tmp)) + +proc writeFixed32*(stream: ProtobufStream, value: uint32) = + var + input = value + output: uint32 + + littleEndian32(addr(output), addr(input)) + + write(stream, output) + +proc writeFixed32*(stream: ProtobufStream, value: uint32, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Fixed32) + writeFixed32(stream, value) + +proc readFixed32*(stream: ProtobufStream): uint32 = + var tmp: uint32 + if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): + raise newException(IOError, "cannot read from stream") + littleEndian32(addr(result), addr(tmp)) + +proc writeSFixed32*(stream: ProtobufStream, value: int32) = + writeFixed32(stream, cast[uint32](value)) + +proc writeSFixed32*(stream: ProtobufStream, value: int32, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Fixed32) + writeSFixed32(stream, value) + +proc readSFixed32*(stream: ProtobufStream): int32 = + result = cast[int32](readFixed32(stream)) + +proc writeFloat*(stream: ProtobufStream, value: float32) = + var + input = value + output: float32 + + littleEndian32(addr(output), addr(input)) + + write(stream, output) + +proc writeFloat*(stream: ProtobufStream, value: float32, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Fixed32) + writeFloat(stream, value) + +proc readFloat*(stream: ProtobufStream): float32 = + var tmp: float32 + if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): + raise newException(IOError, "cannot read from stream") + littleEndian32(addr(result), addr(tmp)) + +proc writeString*(stream: ProtobufStream, s: string) = + writeUInt64(stream, len(s).uint64) + write(stream, s) + +proc writeString*(stream: ProtobufStream, s: string, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.LengthDelimited) + writeString(stream, s) + +proc writeBytes*(stream: ProtobufStream, s: bytes) = + writeString(stream, string(s)) + +proc writeBytes*(stream: ProtobufStream, s: bytes, fieldNumber: int) = + writeString(stream, string(s), fieldNumber) + +proc safeReadStr*(stream: Stream, size: int): string = + result = newString(size) + if readData(stream, addr(result[0]), size) != size: + raise newException(IOError, "cannot read from stream") + +proc readString*(stream: ProtobufStream): string = + let size = int(readUInt64(stream)) + result = safeReadStr(stream, size) + +proc readBytes*(stream: ProtobufStream): bytes = + bytes(readString(stream)) + +proc readEnum*[T](stream: ProtobufStream): T = + result = T(readUInt32(stream)) + +proc writeEnum*[T](stream: ProtobufStream, value: T) = + writeUInt32(stream, uint32(value)) + +proc writeEnum*[T](stream: ProtobufStream, value: T, fieldNumber: int) = + writeTag(stream, fieldNumber, WireType.Varint) + writeUInt32(stream, uint32(value)) + +proc sizeOfVarint[T](value: T): uint64 = + var tmp = uint64(value) + while tmp >= 0x80'u64: + tmp = tmp shr 7 + inc(result) + inc(result) + +proc packedFieldSize*[T](values: seq[T], fieldtype: FieldType): uint64 = + case fieldtype + of FieldType.Fixed64, FieldType.SFixed64, FieldType.Double: + result = uint64(len(values)) * 8 + of FieldType.Fixed32, FieldType.SFixed32, FieldType.Float: + result = uint64(len(values)) * 4 + of FieldType.Int64, FieldType.UInt64, FieldType.Int32, FieldType.Bool, + FieldType.UInt32, FieldType.Enum: + for value in values: + result += sizeOfVarint(value) + of FieldType.SInt32: + for value in values: + result += sizeOfVarint(zigzagEncode(int32(value))) + of FieldType.SInt64: + for value in values: + result += sizeOfVarint(zigzagEncode(int64(value))) + else: + raise newException(Exception, "invalid fieldtype") + +proc sizeOfString*(s: string): uint64 = + result = sizeOfVarint(len(s).uint64) + len(s).uint64 + +proc sizeOfBytes*(s: bytes): uint64 = + result = sizeOfString(string(s)) + +proc sizeOfDouble*(value: float64): uint64 = + result = 8 + +proc sizeOfFloat*(value: float32): uint64 = + result = 4 + +proc sizeOfInt64*(value: int64): uint64 = + result = sizeOfVarint(value) + +proc sizeOfUInt64*(value: uint64): uint64 = + result = sizeOfVarint(value) + +proc sizeOfInt32*(value: int32): uint64 = + result = sizeOfVarint(value) + +proc sizeOfFixed64*(value: uint64): uint64 = + result = 8 + +proc sizeOfFixed32*(value: uint32): uint64 = + result = 4 + +proc sizeOfBool*(value: bool): uint64 = + result = sizeOfVarint(value) + +proc sizeOfUInt32*(value: uint32): uint64 = + result = sizeOfVarint(value) + +proc sizeOfSFixed32*(value: int32): uint64 = + result = 4 + +proc sizeOfSFixed64*(value: int64): uint64 = + result = 8 + +proc sizeOfSInt32*(value: int32): uint64 = + result = sizeOfVarint(zigzagEncode(value)) + +proc sizeOfSInt64*(value: int64): uint64 = + result = sizeOfVarint(zigzagEncode(value)) + +proc sizeOfEnum*[T](value: T): uint64 = + result = sizeOfUInt32(value.uint32) + +proc sizeOfLengthDelimited*(size: uint64): uint64 = + result = size + sizeOfVarint(size) + +proc sizeOfTag*(fieldNumber: int, wiretype: WireType): uint64 = + result = sizeOfUInt32(uint32(makeTag(fieldNumber, wiretype))) + +proc skipField*(stream: ProtobufStream, wiretype: WireType) = + case wiretype + of WireType.Varint: + discard readVarint(stream) + of WireType.Fixed64: + discard readFixed64(stream) + of WireType.Fixed32: + discard readFixed32(stream) + of WireType.LengthDelimited: + let size = readVarint(stream) + discard safeReadStr(stream, int(size)) + else: + raise newException(Exception, "unsupported wiretype: " & $wiretype) + +proc expectWireType*(actual: WireType, expected: varargs[WireType]) = + for exp in expected: + if actual == exp: + return + let message = "Got wiretype " & $actual & " but expected: " & + join(expected, ", ") + raise newException(UnexpectedWireTypeError, message) + +macro writeMessage*(stream: ProtobufStream, message: typed, fieldNumber: int): typed = + ## Write a message to a stream with tag and length. + let t = getTypeInst(message) + result = newStmtList( + newCall( + ident("writeTag"), + stream, + fieldNumber, + newDotExpr(ident("WireType"), ident("LengthDelimited")) + ), + newCall( + ident("writeVarint"), + stream, + newCall(ident("sizeOf" & $t), message) + ), + newCall( + ident("write" & $t), + stream, + message + ) + ) + +proc excl*(s: var IntSet, values: openArray[int]) = + ## Exclude multiple values from an IntSet. + for value in values: + excl(s, value) + +proc readLengthDelimited*(stream: ProtobufStream): string = + let size = int(readVarint(stream)) + result = safeReadStr(stream, size) + +proc readUnknownField*(stream: ProtobufStream, tag: Tag, + fields: var seq[UnknownField]) = + var field: UnknownField + + new(field) + field.fieldNumber = fieldNumber(tag) + field.wireType = wiretype(tag) + + case field.wiretype + of WireType.Varint: + field.vint = readVarint(stream) + of WireType.Fixed64: + field.fixed64 = readFixed64(stream) + of WireType.Fixed32: + field.fixed32 = readFixed32(stream) + of WireType.LengthDelimited: + let size = readVarint(stream) + field.data = safeReadStr(stream, int(size)) + else: + raise newException(Exception, "unsupported wiretype: " & $field.wiretype) + + add(fields, field) + +proc writeUnknownFields*(stream: ProtobufStream, fields: seq[UnknownField]) = + for field in fields: + case field.wiretype + of WireType.Varint: + writeTag(stream, field.fieldNumber, field.wireType) + writeVarint(stream, field.vint) + of WireType.Fixed64: + writeFixed64(stream, field.fixed64, field.fieldNumber) + of WireType.Fixed32: + writeFixed32(stream, field.fixed32, field.fieldNumber) + of WireType.LengthDelimited: + writeString(stream, field.data, field.fieldNumber) + else: + raise newException(Exception, "unsupported wiretype: " & $field.wiretype) + +proc discardUnknownFields*[T](message: T) = + message.unknownFields = @[] + +proc sizeOfUnknownField*(field: UnknownField): uint64 = + result = sizeOfTag(field.fieldNumber, field.wiretype) + case field.wiretype + of WireType.Varint: + result = result + sizeOfVarint(field.vint) + of WireType.Fixed64: + result = result + 8 + of WireType.Fixed32: + result = result + 4 + of WireType.LengthDelimited: + result = result + sizeOfLengthDelimited(uint64(len(field.data))) + else: + raise newException(Exception, "unsupported wiretype: " & $field.wiretype) diff --git a/nimpb/wkt/any_pb.nim b/nimpb/wkt/any_pb.nim new file mode 100644 index 0000000..f7613e0 --- /dev/null +++ b/nimpb/wkt/any_pb.nim @@ -0,0 +1,111 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb + +type + google_protobuf_Any* = ref google_protobuf_AnyObj + google_protobuf_AnyObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + type_url: string + value: bytes + +proc newgoogle_protobuf_Any*(): google_protobuf_Any +proc newgoogle_protobuf_Any*(data: string): google_protobuf_Any +proc writegoogle_protobuf_Any*(stream: ProtobufStream, message: google_protobuf_Any) +proc readgoogle_protobuf_Any*(stream: ProtobufStream): google_protobuf_Any +proc sizeOfgoogle_protobuf_Any*(message: google_protobuf_Any): uint64 + +proc newgoogle_protobuf_Any*(): google_protobuf_Any = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.type_url = "" + result.value = bytes("") + +proc cleartype_url*(message: google_protobuf_Any) = + message.type_url = "" + excl(message.hasField, [1]) + +proc hastype_url*(message: google_protobuf_Any): bool = + result = contains(message.hasField, 1) + +proc settype_url*(message: google_protobuf_Any, value: string) = + message.type_url = value + incl(message.hasField, 1) + +proc type_url*(message: google_protobuf_Any): string {.inline.} = + message.type_url + +proc `type_url=`*(message: google_protobuf_Any, value: string) {.inline.} = + settype_url(message, value) + +proc clearvalue*(message: google_protobuf_Any) = + message.value = bytes("") + excl(message.hasField, [2]) + +proc hasvalue*(message: google_protobuf_Any): bool = + result = contains(message.hasField, 2) + +proc setvalue*(message: google_protobuf_Any, value: bytes) = + message.value = value + incl(message.hasField, 2) + +proc value*(message: google_protobuf_Any): bytes {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_Any, value: bytes) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_Any*(message: google_protobuf_Any): uint64 = + if hastype_url(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.type_url) + if hasvalue(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfBytes(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Any*(stream: ProtobufStream, message: google_protobuf_Any) = + if hastype_url(message): + writeString(stream, message.type_url, 1) + if hasvalue(message): + writeBytes(stream, message.value, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Any*(stream: ProtobufStream): google_protobuf_Any = + result = newgoogle_protobuf_Any() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + settype_url(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setvalue(result, readBytes(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Any): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Any(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Any*(data: string): google_protobuf_Any = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Any(pbs) + + diff --git a/nimpb/wkt/api_pb.nim b/nimpb/wkt/api_pb.nim new file mode 100644 index 0000000..28f5b2b --- /dev/null +++ b/nimpb/wkt/api_pb.nim @@ -0,0 +1,664 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +import nimpb/wkt/source_context_pb +import nimpb/wkt/type_pb + +type + google_protobuf_Api* = ref google_protobuf_ApiObj + google_protobuf_ApiObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + methods: seq[google_protobuf_Method] + options: seq[google_protobuf_Option] + version: string + source_context: google_protobuf_SourceContext + mixins: seq[google_protobuf_Mixin] + syntax: google_protobuf_Syntax + google_protobuf_Method* = ref google_protobuf_MethodObj + google_protobuf_MethodObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + request_type_url: string + request_streaming: bool + response_type_url: string + response_streaming: bool + options: seq[google_protobuf_Option] + syntax: google_protobuf_Syntax + google_protobuf_Mixin* = ref google_protobuf_MixinObj + google_protobuf_MixinObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + root: string + +proc newgoogle_protobuf_Method*(): google_protobuf_Method +proc newgoogle_protobuf_Method*(data: string): google_protobuf_Method +proc writegoogle_protobuf_Method*(stream: ProtobufStream, message: google_protobuf_Method) +proc readgoogle_protobuf_Method*(stream: ProtobufStream): google_protobuf_Method +proc sizeOfgoogle_protobuf_Method*(message: google_protobuf_Method): uint64 +proc toJson*(message: google_protobuf_Method): JsonNode + +proc newgoogle_protobuf_Mixin*(): google_protobuf_Mixin +proc newgoogle_protobuf_Mixin*(data: string): google_protobuf_Mixin +proc writegoogle_protobuf_Mixin*(stream: ProtobufStream, message: google_protobuf_Mixin) +proc readgoogle_protobuf_Mixin*(stream: ProtobufStream): google_protobuf_Mixin +proc sizeOfgoogle_protobuf_Mixin*(message: google_protobuf_Mixin): uint64 +proc toJson*(message: google_protobuf_Mixin): JsonNode + +proc newgoogle_protobuf_Api*(): google_protobuf_Api +proc newgoogle_protobuf_Api*(data: string): google_protobuf_Api +proc writegoogle_protobuf_Api*(stream: ProtobufStream, message: google_protobuf_Api) +proc readgoogle_protobuf_Api*(stream: ProtobufStream): google_protobuf_Api +proc sizeOfgoogle_protobuf_Api*(message: google_protobuf_Api): uint64 +proc toJson*(message: google_protobuf_Api): JsonNode + +proc newgoogle_protobuf_Method*(): google_protobuf_Method = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.request_type_url = "" + result.request_streaming = false + result.response_type_url = "" + result.response_streaming = false + result.options = @[] + result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + +proc clearname*(message: google_protobuf_Method) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_Method, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_Method): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Method, value: string) {.inline.} = + setname(message, value) + +proc clearrequest_type_url*(message: google_protobuf_Method) = + message.request_type_url = "" + excl(message.hasField, [2]) + +proc hasrequest_type_url*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 2) + +proc setrequest_type_url*(message: google_protobuf_Method, value: string) = + message.request_type_url = value + incl(message.hasField, 2) + +proc request_type_url*(message: google_protobuf_Method): string {.inline.} = + message.request_type_url + +proc `request_type_url=`*(message: google_protobuf_Method, value: string) {.inline.} = + setrequest_type_url(message, value) + +proc clearrequest_streaming*(message: google_protobuf_Method) = + message.request_streaming = false + excl(message.hasField, [3]) + +proc hasrequest_streaming*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 3) + +proc setrequest_streaming*(message: google_protobuf_Method, value: bool) = + message.request_streaming = value + incl(message.hasField, 3) + +proc request_streaming*(message: google_protobuf_Method): bool {.inline.} = + message.request_streaming + +proc `request_streaming=`*(message: google_protobuf_Method, value: bool) {.inline.} = + setrequest_streaming(message, value) + +proc clearresponse_type_url*(message: google_protobuf_Method) = + message.response_type_url = "" + excl(message.hasField, [4]) + +proc hasresponse_type_url*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 4) + +proc setresponse_type_url*(message: google_protobuf_Method, value: string) = + message.response_type_url = value + incl(message.hasField, 4) + +proc response_type_url*(message: google_protobuf_Method): string {.inline.} = + message.response_type_url + +proc `response_type_url=`*(message: google_protobuf_Method, value: string) {.inline.} = + setresponse_type_url(message, value) + +proc clearresponse_streaming*(message: google_protobuf_Method) = + message.response_streaming = false + excl(message.hasField, [5]) + +proc hasresponse_streaming*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 5) + +proc setresponse_streaming*(message: google_protobuf_Method, value: bool) = + message.response_streaming = value + incl(message.hasField, 5) + +proc response_streaming*(message: google_protobuf_Method): bool {.inline.} = + message.response_streaming + +proc `response_streaming=`*(message: google_protobuf_Method, value: bool) {.inline.} = + setresponse_streaming(message, value) + +proc clearoptions*(message: google_protobuf_Method) = + message.options = @[] + excl(message.hasField, [6]) + +proc hasoptions*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 6) or (len(message.options) > 0) + +proc setoptions*(message: google_protobuf_Method, value: seq[google_protobuf_Option]) = + message.options = value + incl(message.hasField, 6) + +proc addoptions*(message: google_protobuf_Method, value: google_protobuf_Option) = + add(message.options, value) + incl(message.hasField, 6) + +proc options*(message: google_protobuf_Method): seq[google_protobuf_Option] {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_Method, value: seq[google_protobuf_Option]) {.inline.} = + setoptions(message, value) + +proc clearsyntax*(message: google_protobuf_Method) = + message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + excl(message.hasField, [7]) + +proc hassyntax*(message: google_protobuf_Method): bool = + result = contains(message.hasField, 7) + +proc setsyntax*(message: google_protobuf_Method, value: google_protobuf_Syntax) = + message.syntax = value + incl(message.hasField, 7) + +proc syntax*(message: google_protobuf_Method): google_protobuf_Syntax {.inline.} = + message.syntax + +proc `syntax=`*(message: google_protobuf_Method, value: google_protobuf_Syntax) {.inline.} = + setsyntax(message, value) + +proc sizeOfgoogle_protobuf_Method*(message: google_protobuf_Method): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasrequest_type_url(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfString(message.request_type_url) + if hasrequest_streaming(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfBool(message.request_streaming) + if hasresponse_type_url(message): + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfString(message.response_type_url) + if hasresponse_streaming(message): + result = result + sizeOfTag(5, WireType.Varint) + result = result + sizeOfBool(message.response_streaming) + for value in message.options: + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) + if hassyntax(message): + result = result + sizeOfTag(7, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Method*(stream: ProtobufStream, message: google_protobuf_Method) = + if hasname(message): + writeString(stream, message.name, 1) + if hasrequest_type_url(message): + writeString(stream, message.request_type_url, 2) + if hasrequest_streaming(message): + writeBool(stream, message.request_streaming, 3) + if hasresponse_type_url(message): + writeString(stream, message.response_type_url, 4) + if hasresponse_streaming(message): + writeBool(stream, message.response_streaming, 5) + for value in message.options: + writeMessage(stream, value, 6) + if hassyntax(message): + writeEnum(stream, message.syntax, 7) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Method*(stream: ProtobufStream): google_protobuf_Method = + result = newgoogle_protobuf_Method() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setrequest_type_url(result, readString(stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setrequest_streaming(result, readBool(stream)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + setresponse_type_url(result, readString(stream)) + of 5: + expectWireType(wireType, WireType.Varint) + setresponse_streaming(result, readBool(stream)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoptions(result, newgoogle_protobuf_Option(data)) + of 7: + expectWireType(wireType, WireType.Varint) + setsyntax(result, readEnum[google_protobuf_Syntax](stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Method): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasrequest_type_url(message): + result["requestTypeUrl"] = %message.request_type_url + if hasrequest_streaming(message): + result["requestStreaming"] = %message.request_streaming + if hasresponse_type_url(message): + result["responseTypeUrl"] = %message.response_type_url + if hasresponse_streaming(message): + result["responseStreaming"] = %message.response_streaming + if hasoptions(message): + let arr = newJArray() + for value in message.options: + add(arr, toJson(value)) + result["options"] = arr + if hassyntax(message): + result["syntax"] = %($message.syntax) + +proc serialize*(message: google_protobuf_Method): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Method(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Method*(data: string): google_protobuf_Method = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Method(pbs) + + +proc newgoogle_protobuf_Mixin*(): google_protobuf_Mixin = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.root = "" + +proc clearname*(message: google_protobuf_Mixin) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_Mixin): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_Mixin, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_Mixin): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Mixin, value: string) {.inline.} = + setname(message, value) + +proc clearroot*(message: google_protobuf_Mixin) = + message.root = "" + excl(message.hasField, [2]) + +proc hasroot*(message: google_protobuf_Mixin): bool = + result = contains(message.hasField, 2) + +proc setroot*(message: google_protobuf_Mixin, value: string) = + message.root = value + incl(message.hasField, 2) + +proc root*(message: google_protobuf_Mixin): string {.inline.} = + message.root + +proc `root=`*(message: google_protobuf_Mixin, value: string) {.inline.} = + setroot(message, value) + +proc sizeOfgoogle_protobuf_Mixin*(message: google_protobuf_Mixin): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasroot(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfString(message.root) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Mixin*(stream: ProtobufStream, message: google_protobuf_Mixin) = + if hasname(message): + writeString(stream, message.name, 1) + if hasroot(message): + writeString(stream, message.root, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Mixin*(stream: ProtobufStream): google_protobuf_Mixin = + result = newgoogle_protobuf_Mixin() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setroot(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Mixin): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasroot(message): + result["root"] = %message.root + +proc serialize*(message: google_protobuf_Mixin): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Mixin(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Mixin*(data: string): google_protobuf_Mixin = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Mixin(pbs) + + +proc newgoogle_protobuf_Api*(): google_protobuf_Api = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.methods = @[] + result.options = @[] + result.version = "" + result.source_context = nil + result.mixins = @[] + result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + +proc clearname*(message: google_protobuf_Api) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_Api, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_Api): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Api, value: string) {.inline.} = + setname(message, value) + +proc clearmethods*(message: google_protobuf_Api) = + message.methods = @[] + excl(message.hasField, [2]) + +proc hasmethods*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 2) or (len(message.methods) > 0) + +proc setmethods*(message: google_protobuf_Api, value: seq[google_protobuf_Method]) = + message.methods = value + incl(message.hasField, 2) + +proc addmethods*(message: google_protobuf_Api, value: google_protobuf_Method) = + add(message.methods, value) + incl(message.hasField, 2) + +proc methods*(message: google_protobuf_Api): seq[google_protobuf_Method] {.inline.} = + message.methods + +proc `methods=`*(message: google_protobuf_Api, value: seq[google_protobuf_Method]) {.inline.} = + setmethods(message, value) + +proc clearoptions*(message: google_protobuf_Api) = + message.options = @[] + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 3) or (len(message.options) > 0) + +proc setoptions*(message: google_protobuf_Api, value: seq[google_protobuf_Option]) = + message.options = value + incl(message.hasField, 3) + +proc addoptions*(message: google_protobuf_Api, value: google_protobuf_Option) = + add(message.options, value) + incl(message.hasField, 3) + +proc options*(message: google_protobuf_Api): seq[google_protobuf_Option] {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_Api, value: seq[google_protobuf_Option]) {.inline.} = + setoptions(message, value) + +proc clearversion*(message: google_protobuf_Api) = + message.version = "" + excl(message.hasField, [4]) + +proc hasversion*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 4) + +proc setversion*(message: google_protobuf_Api, value: string) = + message.version = value + incl(message.hasField, 4) + +proc version*(message: google_protobuf_Api): string {.inline.} = + message.version + +proc `version=`*(message: google_protobuf_Api, value: string) {.inline.} = + setversion(message, value) + +proc clearsource_context*(message: google_protobuf_Api) = + message.source_context = nil + excl(message.hasField, [5]) + +proc hassource_context*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 5) + +proc setsource_context*(message: google_protobuf_Api, value: google_protobuf_SourceContext) = + message.source_context = value + incl(message.hasField, 5) + +proc source_context*(message: google_protobuf_Api): google_protobuf_SourceContext {.inline.} = + message.source_context + +proc `source_context=`*(message: google_protobuf_Api, value: google_protobuf_SourceContext) {.inline.} = + setsource_context(message, value) + +proc clearmixins*(message: google_protobuf_Api) = + message.mixins = @[] + excl(message.hasField, [6]) + +proc hasmixins*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 6) or (len(message.mixins) > 0) + +proc setmixins*(message: google_protobuf_Api, value: seq[google_protobuf_Mixin]) = + message.mixins = value + incl(message.hasField, 6) + +proc addmixins*(message: google_protobuf_Api, value: google_protobuf_Mixin) = + add(message.mixins, value) + incl(message.hasField, 6) + +proc mixins*(message: google_protobuf_Api): seq[google_protobuf_Mixin] {.inline.} = + message.mixins + +proc `mixins=`*(message: google_protobuf_Api, value: seq[google_protobuf_Mixin]) {.inline.} = + setmixins(message, value) + +proc clearsyntax*(message: google_protobuf_Api) = + message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + excl(message.hasField, [7]) + +proc hassyntax*(message: google_protobuf_Api): bool = + result = contains(message.hasField, 7) + +proc setsyntax*(message: google_protobuf_Api, value: google_protobuf_Syntax) = + message.syntax = value + incl(message.hasField, 7) + +proc syntax*(message: google_protobuf_Api): google_protobuf_Syntax {.inline.} = + message.syntax + +proc `syntax=`*(message: google_protobuf_Api, value: google_protobuf_Syntax) {.inline.} = + setsyntax(message, value) + +proc sizeOfgoogle_protobuf_Api*(message: google_protobuf_Api): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + for value in message.methods: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Method(value)) + for value in message.options: + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) + if hasversion(message): + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfString(message.version) + if hassource_context(message): + result = result + sizeOfTag(5, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context)) + for value in message.mixins: + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Mixin(value)) + if hassyntax(message): + result = result + sizeOfTag(7, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Api*(stream: ProtobufStream, message: google_protobuf_Api) = + if hasname(message): + writeString(stream, message.name, 1) + for value in message.methods: + writeMessage(stream, value, 2) + for value in message.options: + writeMessage(stream, value, 3) + if hasversion(message): + writeString(stream, message.version, 4) + if hassource_context(message): + writeMessage(stream, message.source_context, 5) + for value in message.mixins: + writeMessage(stream, value, 6) + if hassyntax(message): + writeEnum(stream, message.syntax, 7) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Api*(stream: ProtobufStream): google_protobuf_Api = + result = newgoogle_protobuf_Api() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addmethods(result, newgoogle_protobuf_Method(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoptions(result, newgoogle_protobuf_Option(data)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + setversion(result, readString(stream)) + of 5: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setsource_context(result, newgoogle_protobuf_SourceContext(data)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addmixins(result, newgoogle_protobuf_Mixin(data)) + of 7: + expectWireType(wireType, WireType.Varint) + setsyntax(result, readEnum[google_protobuf_Syntax](stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Api): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasmethods(message): + let arr = newJArray() + for value in message.methods: + add(arr, toJson(value)) + result["methods"] = arr + if hasoptions(message): + let arr = newJArray() + for value in message.options: + add(arr, toJson(value)) + result["options"] = arr + if hasversion(message): + result["version"] = %message.version + if hassource_context(message): + result["sourceContext"] = toJson(message.source_context) + if hasmixins(message): + let arr = newJArray() + for value in message.mixins: + add(arr, toJson(value)) + result["mixins"] = arr + if hassyntax(message): + result["syntax"] = %($message.syntax) + +proc serialize*(message: google_protobuf_Api): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Api(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Api*(data: string): google_protobuf_Api = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Api(pbs) + + diff --git a/nimpb/wkt/duration_pb.nim b/nimpb/wkt/duration_pb.nim new file mode 100644 index 0000000..d15aeee --- /dev/null +++ b/nimpb/wkt/duration_pb.nim @@ -0,0 +1,112 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_Duration* = ref google_protobuf_DurationObj + google_protobuf_DurationObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + seconds: int64 + nanos: int32 + +proc newgoogle_protobuf_Duration*(): google_protobuf_Duration +proc newgoogle_protobuf_Duration*(data: string): google_protobuf_Duration +proc writegoogle_protobuf_Duration*(stream: ProtobufStream, message: google_protobuf_Duration) +proc readgoogle_protobuf_Duration*(stream: ProtobufStream): google_protobuf_Duration +proc sizeOfgoogle_protobuf_Duration*(message: google_protobuf_Duration): uint64 + +proc newgoogle_protobuf_Duration*(): google_protobuf_Duration = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.seconds = 0 + result.nanos = 0 + +proc clearseconds*(message: google_protobuf_Duration) = + message.seconds = 0 + excl(message.hasField, [1]) + +proc hasseconds*(message: google_protobuf_Duration): bool = + result = contains(message.hasField, 1) + +proc setseconds*(message: google_protobuf_Duration, value: int64) = + message.seconds = value + incl(message.hasField, 1) + +proc seconds*(message: google_protobuf_Duration): int64 {.inline.} = + message.seconds + +proc `seconds=`*(message: google_protobuf_Duration, value: int64) {.inline.} = + setseconds(message, value) + +proc clearnanos*(message: google_protobuf_Duration) = + message.nanos = 0 + excl(message.hasField, [2]) + +proc hasnanos*(message: google_protobuf_Duration): bool = + result = contains(message.hasField, 2) + +proc setnanos*(message: google_protobuf_Duration, value: int32) = + message.nanos = value + incl(message.hasField, 2) + +proc nanos*(message: google_protobuf_Duration): int32 {.inline.} = + message.nanos + +proc `nanos=`*(message: google_protobuf_Duration, value: int32) {.inline.} = + setnanos(message, value) + +proc sizeOfgoogle_protobuf_Duration*(message: google_protobuf_Duration): uint64 = + if hasseconds(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt64(message.seconds) + if hasnanos(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.nanos) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Duration*(stream: ProtobufStream, message: google_protobuf_Duration) = + if hasseconds(message): + writeInt64(stream, message.seconds, 1) + if hasnanos(message): + writeInt32(stream, message.nanos, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Duration*(stream: ProtobufStream): google_protobuf_Duration = + result = newgoogle_protobuf_Duration() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setseconds(result, readInt64(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setnanos(result, readInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Duration): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Duration(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Duration*(data: string): google_protobuf_Duration = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Duration(pbs) + + diff --git a/nimpb/wkt/empty_pb.nim b/nimpb/wkt/empty_pb.nim new file mode 100644 index 0000000..c53cb03 --- /dev/null +++ b/nimpb/wkt/empty_pb.nim @@ -0,0 +1,62 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_Empty* = ref google_protobuf_EmptyObj + google_protobuf_EmptyObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + +proc newgoogle_protobuf_Empty*(): google_protobuf_Empty +proc newgoogle_protobuf_Empty*(data: string): google_protobuf_Empty +proc writegoogle_protobuf_Empty*(stream: ProtobufStream, message: google_protobuf_Empty) +proc readgoogle_protobuf_Empty*(stream: ProtobufStream): google_protobuf_Empty +proc sizeOfgoogle_protobuf_Empty*(message: google_protobuf_Empty): uint64 +proc toJson*(message: google_protobuf_Empty): JsonNode + +proc newgoogle_protobuf_Empty*(): google_protobuf_Empty = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + +proc sizeOfgoogle_protobuf_Empty*(message: google_protobuf_Empty): uint64 = + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Empty*(stream: ProtobufStream, message: google_protobuf_Empty) = + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Empty*(stream: ProtobufStream): google_protobuf_Empty = + result = newgoogle_protobuf_Empty() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Empty): JsonNode = + result = newJObject() + +proc serialize*(message: google_protobuf_Empty): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Empty(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Empty*(data: string): google_protobuf_Empty = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Empty(pbs) + + diff --git a/nimpb/wkt/field_mask_pb.nim b/nimpb/wkt/field_mask_pb.nim new file mode 100644 index 0000000..e925416 --- /dev/null +++ b/nimpb/wkt/field_mask_pb.nim @@ -0,0 +1,89 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_FieldMask* = ref google_protobuf_FieldMaskObj + google_protobuf_FieldMaskObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + paths: seq[string] + +proc newgoogle_protobuf_FieldMask*(): google_protobuf_FieldMask +proc newgoogle_protobuf_FieldMask*(data: string): google_protobuf_FieldMask +proc writegoogle_protobuf_FieldMask*(stream: ProtobufStream, message: google_protobuf_FieldMask) +proc readgoogle_protobuf_FieldMask*(stream: ProtobufStream): google_protobuf_FieldMask +proc sizeOfgoogle_protobuf_FieldMask*(message: google_protobuf_FieldMask): uint64 + +proc newgoogle_protobuf_FieldMask*(): google_protobuf_FieldMask = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.paths = @[] + +proc clearpaths*(message: google_protobuf_FieldMask) = + message.paths = @[] + excl(message.hasField, [1]) + +proc haspaths*(message: google_protobuf_FieldMask): bool = + result = contains(message.hasField, 1) or (len(message.paths) > 0) + +proc setpaths*(message: google_protobuf_FieldMask, value: seq[string]) = + message.paths = value + incl(message.hasField, 1) + +proc addpaths*(message: google_protobuf_FieldMask, value: string) = + add(message.paths, value) + incl(message.hasField, 1) + +proc paths*(message: google_protobuf_FieldMask): seq[string] {.inline.} = + message.paths + +proc `paths=`*(message: google_protobuf_FieldMask, value: seq[string]) {.inline.} = + setpaths(message, value) + +proc sizeOfgoogle_protobuf_FieldMask*(message: google_protobuf_FieldMask): uint64 = + for value in message.paths: + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_FieldMask*(stream: ProtobufStream, message: google_protobuf_FieldMask) = + for value in message.paths: + writeString(stream, value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FieldMask*(stream: ProtobufStream): google_protobuf_FieldMask = + result = newgoogle_protobuf_FieldMask() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + addpaths(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FieldMask): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FieldMask(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FieldMask*(data: string): google_protobuf_FieldMask = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FieldMask(pbs) + + diff --git a/nimpb/wkt/source_context_pb.nim b/nimpb/wkt/source_context_pb.nim new file mode 100644 index 0000000..815da98 --- /dev/null +++ b/nimpb/wkt/source_context_pb.nim @@ -0,0 +1,91 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_SourceContext* = ref google_protobuf_SourceContextObj + google_protobuf_SourceContextObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + file_name: string + +proc newgoogle_protobuf_SourceContext*(): google_protobuf_SourceContext +proc newgoogle_protobuf_SourceContext*(data: string): google_protobuf_SourceContext +proc writegoogle_protobuf_SourceContext*(stream: ProtobufStream, message: google_protobuf_SourceContext) +proc readgoogle_protobuf_SourceContext*(stream: ProtobufStream): google_protobuf_SourceContext +proc sizeOfgoogle_protobuf_SourceContext*(message: google_protobuf_SourceContext): uint64 +proc toJson*(message: google_protobuf_SourceContext): JsonNode + +proc newgoogle_protobuf_SourceContext*(): google_protobuf_SourceContext = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.file_name = "" + +proc clearfile_name*(message: google_protobuf_SourceContext) = + message.file_name = "" + excl(message.hasField, [1]) + +proc hasfile_name*(message: google_protobuf_SourceContext): bool = + result = contains(message.hasField, 1) + +proc setfile_name*(message: google_protobuf_SourceContext, value: string) = + message.file_name = value + incl(message.hasField, 1) + +proc file_name*(message: google_protobuf_SourceContext): string {.inline.} = + message.file_name + +proc `file_name=`*(message: google_protobuf_SourceContext, value: string) {.inline.} = + setfile_name(message, value) + +proc sizeOfgoogle_protobuf_SourceContext*(message: google_protobuf_SourceContext): uint64 = + if hasfile_name(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.file_name) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_SourceContext*(stream: ProtobufStream, message: google_protobuf_SourceContext) = + if hasfile_name(message): + writeString(stream, message.file_name, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_SourceContext*(stream: ProtobufStream): google_protobuf_SourceContext = + result = newgoogle_protobuf_SourceContext() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setfile_name(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_SourceContext): JsonNode = + result = newJObject() + if hasfile_name(message): + result["fileName"] = %message.file_name + +proc serialize*(message: google_protobuf_SourceContext): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_SourceContext(pbs, message) + result = ss.data + +proc newgoogle_protobuf_SourceContext*(data: string): google_protobuf_SourceContext = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_SourceContext(pbs) + + diff --git a/nimpb/wkt/struct_pb.nim b/nimpb/wkt/struct_pb.nim new file mode 100644 index 0000000..2a38f6d --- /dev/null +++ b/nimpb/wkt/struct_pb.nim @@ -0,0 +1,440 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json +import tables +export tables + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_NullValue* {.pure.} = enum + NULL_VALUE = 0 + google_protobuf_Struct* = ref google_protobuf_StructObj + google_protobuf_StructObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + fields: TableRef[string, google_protobuf_Value] + google_protobuf_Value* = ref google_protobuf_ValueObj + google_protobuf_ValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + kind: google_protobuf_Value_kind_OneOf + + google_protobuf_Value_kind_OneOf* {.union.} = object + null_value: google_protobuf_NullValue + number_value: float64 + string_value: string + bool_value: bool + struct_value: google_protobuf_Struct + list_value: google_protobuf_ListValue + google_protobuf_ListValue* = ref google_protobuf_ListValueObj + google_protobuf_ListValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + values: seq[google_protobuf_Value] + +proc writegoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, key: string, value: google_protobuf_Value) +proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: TableRef[string, google_protobuf_Value]) +proc sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key: string, value: google_protobuf_Value): uint64 + +proc newgoogle_protobuf_Struct*(): google_protobuf_Struct +proc newgoogle_protobuf_Struct*(data: string): google_protobuf_Struct +proc writegoogle_protobuf_Struct*(stream: ProtobufStream, message: google_protobuf_Struct) +proc readgoogle_protobuf_Struct*(stream: ProtobufStream): google_protobuf_Struct +proc sizeOfgoogle_protobuf_Struct*(message: google_protobuf_Struct): uint64 + +proc newgoogle_protobuf_ListValue*(): google_protobuf_ListValue +proc newgoogle_protobuf_ListValue*(data: string): google_protobuf_ListValue +proc writegoogle_protobuf_ListValue*(stream: ProtobufStream, message: google_protobuf_ListValue) +proc readgoogle_protobuf_ListValue*(stream: ProtobufStream): google_protobuf_ListValue +proc sizeOfgoogle_protobuf_ListValue*(message: google_protobuf_ListValue): uint64 + +proc newgoogle_protobuf_Value*(): google_protobuf_Value +proc newgoogle_protobuf_Value*(data: string): google_protobuf_Value +proc writegoogle_protobuf_Value*(stream: ProtobufStream, message: google_protobuf_Value) +proc readgoogle_protobuf_Value*(stream: ProtobufStream): google_protobuf_Value +proc sizeOfgoogle_protobuf_Value*(message: google_protobuf_Value): uint64 + +proc sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key: string, value: google_protobuf_Value): uint64 = + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(key) + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Value(value)) + +proc writegoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, key: string, value: google_protobuf_Value) = + writeString(stream, key, 1) + writeMessage(stream, value, 2) + +proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: TableRef[string, google_protobuf_Value]) = + var + key: string + gotKey = false + value: google_protobuf_Value + gotValue = false + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 1: + key = readString(stream) + gotKey = true + of 2: + let + size = readVarint(stream) + data = safeReadStr(stream, int(size)) + pbs = newProtobufStream(newStringStream(data)) + value = readgoogle_protobuf_Value(pbs) + gotValue = true + else: skipField(stream, wireType) + if not gotKey: + raise newException(Exception, "missing key") + if not gotValue: + raise newException(Exception, "missing value") + tbl[key] = value + + +proc newgoogle_protobuf_Struct*(): google_protobuf_Struct = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.fields = newTable[string, google_protobuf_Value]() + +proc clearfields*(message: google_protobuf_Struct) = + message.fields = newTable[string, google_protobuf_Value]() + excl(message.hasField, [1]) + +proc hasfields*(message: google_protobuf_Struct): bool = + result = contains(message.hasField, 1) or (len(message.fields) > 0) + +proc setfields*(message: google_protobuf_Struct, value: TableRef[string, google_protobuf_Value]) = + message.fields = value + incl(message.hasField, 1) + +proc fields*(message: google_protobuf_Struct): TableRef[string, google_protobuf_Value] {.inline.} = + message.fields + +proc `fields=`*(message: google_protobuf_Struct, value: TableRef[string, google_protobuf_Value]) {.inline.} = + setfields(message, value) + +proc sizeOfgoogle_protobuf_Struct*(message: google_protobuf_Struct): uint64 = + if hasfields(message): + var sizeOfKV = 0'u64 + for key, value in message.fields: + sizeOfKV = sizeOfKV + sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key, value) + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfKV) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Struct*(stream: ProtobufStream, message: google_protobuf_Struct) = + for key, value in message.fields: + writeTag(stream, 1, WireType.LengthDelimited) + writeVarint(stream, sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key, value)) + writegoogle_protobuf_Struct_FieldsEntryKV(stream, key, value) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Struct*(stream: ProtobufStream): google_protobuf_Struct = + result = newgoogle_protobuf_Struct() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + let + size = readVarint(stream) + data = safeReadStr(stream, int(size)) + pbs = newProtobufStream(newStringStream(data)) + readgoogle_protobuf_Struct_FieldsEntryKV(pbs, result.fields) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Struct): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Struct(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Struct*(data: string): google_protobuf_Struct = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Struct(pbs) + + +proc newgoogle_protobuf_ListValue*(): google_protobuf_ListValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.values = @[] + +proc clearvalues*(message: google_protobuf_ListValue) = + message.values = @[] + excl(message.hasField, [1]) + +proc hasvalues*(message: google_protobuf_ListValue): bool = + result = contains(message.hasField, 1) or (len(message.values) > 0) + +proc setvalues*(message: google_protobuf_ListValue, value: seq[google_protobuf_Value]) = + message.values = value + incl(message.hasField, 1) + +proc addvalues*(message: google_protobuf_ListValue, value: google_protobuf_Value) = + add(message.values, value) + incl(message.hasField, 1) + +proc values*(message: google_protobuf_ListValue): seq[google_protobuf_Value] {.inline.} = + message.values + +proc `values=`*(message: google_protobuf_ListValue, value: seq[google_protobuf_Value]) {.inline.} = + setvalues(message, value) + +proc sizeOfgoogle_protobuf_ListValue*(message: google_protobuf_ListValue): uint64 = + for value in message.values: + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Value(value)) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_ListValue*(stream: ProtobufStream, message: google_protobuf_ListValue) = + for value in message.values: + writeMessage(stream, value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_ListValue*(stream: ProtobufStream): google_protobuf_ListValue = + result = newgoogle_protobuf_ListValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addvalues(result, newgoogle_protobuf_Value(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_ListValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_ListValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_ListValue*(data: string): google_protobuf_ListValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_ListValue(pbs) + + +proc newgoogle_protobuf_Value*(): google_protobuf_Value = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.kind.null_value = google_protobuf_NullValue.NULL_VALUE + result.kind.number_value = 0 + result.kind.string_value = "" + result.kind.bool_value = false + result.kind.struct_value = nil + result.kind.list_value = nil + +proc clearnull_value*(message: google_protobuf_Value) = + message.kind.null_value = google_protobuf_NullValue.NULL_VALUE + excl(message.hasField, [1, 2, 3, 4, 5, 6]) + +proc hasnull_value*(message: google_protobuf_Value): bool = + result = contains(message.hasField, 1) + +proc setnull_value*(message: google_protobuf_Value, value: google_protobuf_NullValue) = + message.kind.null_value = value + incl(message.hasField, 1) + excl(message.hasField, [2, 3, 4, 5, 6]) + +proc null_value*(message: google_protobuf_Value): google_protobuf_NullValue {.inline.} = + message.kind.null_value + +proc `null_value=`*(message: google_protobuf_Value, value: google_protobuf_NullValue) {.inline.} = + setnull_value(message, value) + +proc clearnumber_value*(message: google_protobuf_Value) = + message.kind.number_value = 0 + excl(message.hasField, [2, 1, 3, 4, 5, 6]) + +proc hasnumber_value*(message: google_protobuf_Value): bool = + result = contains(message.hasField, 2) + +proc setnumber_value*(message: google_protobuf_Value, value: float64) = + message.kind.number_value = value + incl(message.hasField, 2) + excl(message.hasField, [1, 3, 4, 5, 6]) + +proc number_value*(message: google_protobuf_Value): float64 {.inline.} = + message.kind.number_value + +proc `number_value=`*(message: google_protobuf_Value, value: float64) {.inline.} = + setnumber_value(message, value) + +proc clearstring_value*(message: google_protobuf_Value) = + message.kind.string_value = "" + excl(message.hasField, [3, 1, 2, 4, 5, 6]) + +proc hasstring_value*(message: google_protobuf_Value): bool = + result = contains(message.hasField, 3) + +proc setstring_value*(message: google_protobuf_Value, value: string) = + message.kind.string_value = value + incl(message.hasField, 3) + excl(message.hasField, [1, 2, 4, 5, 6]) + +proc string_value*(message: google_protobuf_Value): string {.inline.} = + message.kind.string_value + +proc `string_value=`*(message: google_protobuf_Value, value: string) {.inline.} = + setstring_value(message, value) + +proc clearbool_value*(message: google_protobuf_Value) = + message.kind.bool_value = false + excl(message.hasField, [4, 1, 2, 3, 5, 6]) + +proc hasbool_value*(message: google_protobuf_Value): bool = + result = contains(message.hasField, 4) + +proc setbool_value*(message: google_protobuf_Value, value: bool) = + message.kind.bool_value = value + incl(message.hasField, 4) + excl(message.hasField, [1, 2, 3, 5, 6]) + +proc bool_value*(message: google_protobuf_Value): bool {.inline.} = + message.kind.bool_value + +proc `bool_value=`*(message: google_protobuf_Value, value: bool) {.inline.} = + setbool_value(message, value) + +proc clearstruct_value*(message: google_protobuf_Value) = + message.kind.struct_value = nil + excl(message.hasField, [5, 1, 2, 3, 4, 6]) + +proc hasstruct_value*(message: google_protobuf_Value): bool = + result = contains(message.hasField, 5) + +proc setstruct_value*(message: google_protobuf_Value, value: google_protobuf_Struct) = + message.kind.struct_value = value + incl(message.hasField, 5) + excl(message.hasField, [1, 2, 3, 4, 6]) + +proc struct_value*(message: google_protobuf_Value): google_protobuf_Struct {.inline.} = + message.kind.struct_value + +proc `struct_value=`*(message: google_protobuf_Value, value: google_protobuf_Struct) {.inline.} = + setstruct_value(message, value) + +proc clearlist_value*(message: google_protobuf_Value) = + message.kind.list_value = nil + excl(message.hasField, [6, 1, 2, 3, 4, 5]) + +proc haslist_value*(message: google_protobuf_Value): bool = + result = contains(message.hasField, 6) + +proc setlist_value*(message: google_protobuf_Value, value: google_protobuf_ListValue) = + message.kind.list_value = value + incl(message.hasField, 6) + excl(message.hasField, [1, 2, 3, 4, 5]) + +proc list_value*(message: google_protobuf_Value): google_protobuf_ListValue {.inline.} = + message.kind.list_value + +proc `list_value=`*(message: google_protobuf_Value, value: google_protobuf_ListValue) {.inline.} = + setlist_value(message, value) + +proc sizeOfgoogle_protobuf_Value*(message: google_protobuf_Value): uint64 = + if hasnull_value(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_NullValue](message.kind.null_value) + if hasnumber_value(message): + result = result + sizeOfTag(2, WireType.Fixed64) + result = result + sizeOfDouble(message.kind.number_value) + if hasstring_value(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfString(message.kind.string_value) + if hasbool_value(message): + result = result + sizeOfTag(4, WireType.Varint) + result = result + sizeOfBool(message.kind.bool_value) + if hasstruct_value(message): + result = result + sizeOfTag(5, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Struct(message.kind.struct_value)) + if haslist_value(message): + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_ListValue(message.kind.list_value)) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Value*(stream: ProtobufStream, message: google_protobuf_Value) = + if hasnull_value(message): + writeEnum(stream, message.kind.null_value, 1) + if hasnumber_value(message): + writeDouble(stream, message.kind.number_value, 2) + if hasstring_value(message): + writeString(stream, message.kind.string_value, 3) + if hasbool_value(message): + writeBool(stream, message.kind.bool_value, 4) + if hasstruct_value(message): + writeMessage(stream, message.kind.struct_value, 5) + if haslist_value(message): + writeMessage(stream, message.kind.list_value, 6) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Value*(stream: ProtobufStream): google_protobuf_Value = + result = newgoogle_protobuf_Value() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setnull_value(result, readEnum[google_protobuf_NullValue](stream)) + of 2: + expectWireType(wireType, WireType.Fixed64) + setnumber_value(result, readDouble(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + setstring_value(result, readString(stream)) + of 4: + expectWireType(wireType, WireType.Varint) + setbool_value(result, readBool(stream)) + of 5: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setstruct_value(result, newgoogle_protobuf_Struct(data)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setlist_value(result, newgoogle_protobuf_ListValue(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Value): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Value(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Value*(data: string): google_protobuf_Value = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Value(pbs) + + diff --git a/nimpb/wkt/timestamp_pb.nim b/nimpb/wkt/timestamp_pb.nim new file mode 100644 index 0000000..5f00154 --- /dev/null +++ b/nimpb/wkt/timestamp_pb.nim @@ -0,0 +1,112 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_Timestamp* = ref google_protobuf_TimestampObj + google_protobuf_TimestampObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + seconds: int64 + nanos: int32 + +proc newgoogle_protobuf_Timestamp*(): google_protobuf_Timestamp +proc newgoogle_protobuf_Timestamp*(data: string): google_protobuf_Timestamp +proc writegoogle_protobuf_Timestamp*(stream: ProtobufStream, message: google_protobuf_Timestamp) +proc readgoogle_protobuf_Timestamp*(stream: ProtobufStream): google_protobuf_Timestamp +proc sizeOfgoogle_protobuf_Timestamp*(message: google_protobuf_Timestamp): uint64 + +proc newgoogle_protobuf_Timestamp*(): google_protobuf_Timestamp = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.seconds = 0 + result.nanos = 0 + +proc clearseconds*(message: google_protobuf_Timestamp) = + message.seconds = 0 + excl(message.hasField, [1]) + +proc hasseconds*(message: google_protobuf_Timestamp): bool = + result = contains(message.hasField, 1) + +proc setseconds*(message: google_protobuf_Timestamp, value: int64) = + message.seconds = value + incl(message.hasField, 1) + +proc seconds*(message: google_protobuf_Timestamp): int64 {.inline.} = + message.seconds + +proc `seconds=`*(message: google_protobuf_Timestamp, value: int64) {.inline.} = + setseconds(message, value) + +proc clearnanos*(message: google_protobuf_Timestamp) = + message.nanos = 0 + excl(message.hasField, [2]) + +proc hasnanos*(message: google_protobuf_Timestamp): bool = + result = contains(message.hasField, 2) + +proc setnanos*(message: google_protobuf_Timestamp, value: int32) = + message.nanos = value + incl(message.hasField, 2) + +proc nanos*(message: google_protobuf_Timestamp): int32 {.inline.} = + message.nanos + +proc `nanos=`*(message: google_protobuf_Timestamp, value: int32) {.inline.} = + setnanos(message, value) + +proc sizeOfgoogle_protobuf_Timestamp*(message: google_protobuf_Timestamp): uint64 = + if hasseconds(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt64(message.seconds) + if hasnanos(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.nanos) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Timestamp*(stream: ProtobufStream, message: google_protobuf_Timestamp) = + if hasseconds(message): + writeInt64(stream, message.seconds, 1) + if hasnanos(message): + writeInt32(stream, message.nanos, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Timestamp*(stream: ProtobufStream): google_protobuf_Timestamp = + result = newgoogle_protobuf_Timestamp() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setseconds(result, readInt64(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setnanos(result, readInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Timestamp): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Timestamp(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Timestamp*(data: string): google_protobuf_Timestamp = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Timestamp(pbs) + + diff --git a/nimpb/wkt/type_pb.nim b/nimpb/wkt/type_pb.nim new file mode 100644 index 0000000..efb7d26 --- /dev/null +++ b/nimpb/wkt/type_pb.nim @@ -0,0 +1,1109 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +import nimpb/wkt/any_pb +import nimpb/wkt/source_context_pb + +type + google_protobuf_Syntax* {.pure.} = enum + SYNTAX_PROTO2 = 0 + SYNTAX_PROTO3 = 1 + google_protobuf_Field_Kind* {.pure.} = enum + TYPE_UNKNOWN = 0 + TYPE_DOUBLE = 1 + TYPE_FLOAT = 2 + TYPE_INT64 = 3 + TYPE_UINT64 = 4 + TYPE_INT32 = 5 + TYPE_FIXED64 = 6 + TYPE_FIXED32 = 7 + TYPE_BOOL = 8 + TYPE_STRING = 9 + TYPE_GROUP = 10 + TYPE_MESSAGE = 11 + TYPE_BYTES = 12 + TYPE_UINT32 = 13 + TYPE_ENUM = 14 + TYPE_SFIXED32 = 15 + TYPE_SFIXED64 = 16 + TYPE_SINT32 = 17 + TYPE_SINT64 = 18 + google_protobuf_Field_Cardinality* {.pure.} = enum + CARDINALITY_UNKNOWN = 0 + CARDINALITY_OPTIONAL = 1 + CARDINALITY_REQUIRED = 2 + CARDINALITY_REPEATED = 3 + google_protobuf_Type* = ref google_protobuf_TypeObj + google_protobuf_TypeObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + fields: seq[google_protobuf_Field] + oneofs: seq[string] + options: seq[google_protobuf_Option] + source_context: google_protobuf_SourceContext + syntax: google_protobuf_Syntax + google_protobuf_Field* = ref google_protobuf_FieldObj + google_protobuf_FieldObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + kind: google_protobuf_Field_Kind + cardinality: google_protobuf_Field_Cardinality + number: int32 + name: string + type_url: string + oneof_index: int32 + packed: bool + options: seq[google_protobuf_Option] + json_name: string + default_value: string + google_protobuf_Enum* = ref google_protobuf_EnumObj + google_protobuf_EnumObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + enumvalue: seq[google_protobuf_EnumValue] + options: seq[google_protobuf_Option] + source_context: google_protobuf_SourceContext + syntax: google_protobuf_Syntax + google_protobuf_EnumValue* = ref google_protobuf_EnumValueObj + google_protobuf_EnumValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + number: int32 + options: seq[google_protobuf_Option] + google_protobuf_Option* = ref google_protobuf_OptionObj + google_protobuf_OptionObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + value: google_protobuf_Any + +proc newgoogle_protobuf_Option*(): google_protobuf_Option +proc newgoogle_protobuf_Option*(data: string): google_protobuf_Option +proc writegoogle_protobuf_Option*(stream: ProtobufStream, message: google_protobuf_Option) +proc readgoogle_protobuf_Option*(stream: ProtobufStream): google_protobuf_Option +proc sizeOfgoogle_protobuf_Option*(message: google_protobuf_Option): uint64 +proc toJson*(message: google_protobuf_Option): JsonNode + +proc newgoogle_protobuf_Field*(): google_protobuf_Field +proc newgoogle_protobuf_Field*(data: string): google_protobuf_Field +proc writegoogle_protobuf_Field*(stream: ProtobufStream, message: google_protobuf_Field) +proc readgoogle_protobuf_Field*(stream: ProtobufStream): google_protobuf_Field +proc sizeOfgoogle_protobuf_Field*(message: google_protobuf_Field): uint64 +proc toJson*(message: google_protobuf_Field): JsonNode + +proc newgoogle_protobuf_Type*(): google_protobuf_Type +proc newgoogle_protobuf_Type*(data: string): google_protobuf_Type +proc writegoogle_protobuf_Type*(stream: ProtobufStream, message: google_protobuf_Type) +proc readgoogle_protobuf_Type*(stream: ProtobufStream): google_protobuf_Type +proc sizeOfgoogle_protobuf_Type*(message: google_protobuf_Type): uint64 +proc toJson*(message: google_protobuf_Type): JsonNode + +proc newgoogle_protobuf_EnumValue*(): google_protobuf_EnumValue +proc newgoogle_protobuf_EnumValue*(data: string): google_protobuf_EnumValue +proc writegoogle_protobuf_EnumValue*(stream: ProtobufStream, message: google_protobuf_EnumValue) +proc readgoogle_protobuf_EnumValue*(stream: ProtobufStream): google_protobuf_EnumValue +proc sizeOfgoogle_protobuf_EnumValue*(message: google_protobuf_EnumValue): uint64 +proc toJson*(message: google_protobuf_EnumValue): JsonNode + +proc newgoogle_protobuf_Enum*(): google_protobuf_Enum +proc newgoogle_protobuf_Enum*(data: string): google_protobuf_Enum +proc writegoogle_protobuf_Enum*(stream: ProtobufStream, message: google_protobuf_Enum) +proc readgoogle_protobuf_Enum*(stream: ProtobufStream): google_protobuf_Enum +proc sizeOfgoogle_protobuf_Enum*(message: google_protobuf_Enum): uint64 +proc toJson*(message: google_protobuf_Enum): JsonNode + +proc newgoogle_protobuf_Option*(): google_protobuf_Option = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.value = nil + +proc clearname*(message: google_protobuf_Option) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_Option): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_Option, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_Option): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Option, value: string) {.inline.} = + setname(message, value) + +proc clearvalue*(message: google_protobuf_Option) = + message.value = nil + excl(message.hasField, [2]) + +proc hasvalue*(message: google_protobuf_Option): bool = + result = contains(message.hasField, 2) + +proc setvalue*(message: google_protobuf_Option, value: google_protobuf_Any) = + message.value = value + incl(message.hasField, 2) + +proc value*(message: google_protobuf_Option): google_protobuf_Any {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_Option, value: google_protobuf_Any) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_Option*(message: google_protobuf_Option): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasvalue(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Any(message.value)) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Option*(stream: ProtobufStream, message: google_protobuf_Option) = + if hasname(message): + writeString(stream, message.name, 1) + if hasvalue(message): + writeMessage(stream, message.value, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Option*(stream: ProtobufStream): google_protobuf_Option = + result = newgoogle_protobuf_Option() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setvalue(result, newgoogle_protobuf_Any(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Option): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasvalue(message): + result["value"] = toJson(message.value) + +proc serialize*(message: google_protobuf_Option): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Option(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Option*(data: string): google_protobuf_Option = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Option(pbs) + + +proc newgoogle_protobuf_Field*(): google_protobuf_Field = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.kind = google_protobuf_Field_Kind.TYPE_UNKNOWN + result.cardinality = google_protobuf_Field_Cardinality.CARDINALITY_UNKNOWN + result.number = 0 + result.name = "" + result.type_url = "" + result.oneof_index = 0 + result.packed = false + result.options = @[] + result.json_name = "" + result.default_value = "" + +proc clearkind*(message: google_protobuf_Field) = + message.kind = google_protobuf_Field_Kind.TYPE_UNKNOWN + excl(message.hasField, [1]) + +proc haskind*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 1) + +proc setkind*(message: google_protobuf_Field, value: google_protobuf_Field_Kind) = + message.kind = value + incl(message.hasField, 1) + +proc kind*(message: google_protobuf_Field): google_protobuf_Field_Kind {.inline.} = + message.kind + +proc `kind=`*(message: google_protobuf_Field, value: google_protobuf_Field_Kind) {.inline.} = + setkind(message, value) + +proc clearcardinality*(message: google_protobuf_Field) = + message.cardinality = google_protobuf_Field_Cardinality.CARDINALITY_UNKNOWN + excl(message.hasField, [2]) + +proc hascardinality*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 2) + +proc setcardinality*(message: google_protobuf_Field, value: google_protobuf_Field_Cardinality) = + message.cardinality = value + incl(message.hasField, 2) + +proc cardinality*(message: google_protobuf_Field): google_protobuf_Field_Cardinality {.inline.} = + message.cardinality + +proc `cardinality=`*(message: google_protobuf_Field, value: google_protobuf_Field_Cardinality) {.inline.} = + setcardinality(message, value) + +proc clearnumber*(message: google_protobuf_Field) = + message.number = 0 + excl(message.hasField, [3]) + +proc hasnumber*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 3) + +proc setnumber*(message: google_protobuf_Field, value: int32) = + message.number = value + incl(message.hasField, 3) + +proc number*(message: google_protobuf_Field): int32 {.inline.} = + message.number + +proc `number=`*(message: google_protobuf_Field, value: int32) {.inline.} = + setnumber(message, value) + +proc clearname*(message: google_protobuf_Field) = + message.name = "" + excl(message.hasField, [4]) + +proc hasname*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 4) + +proc setname*(message: google_protobuf_Field, value: string) = + message.name = value + incl(message.hasField, 4) + +proc name*(message: google_protobuf_Field): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Field, value: string) {.inline.} = + setname(message, value) + +proc cleartype_url*(message: google_protobuf_Field) = + message.type_url = "" + excl(message.hasField, [6]) + +proc hastype_url*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 6) + +proc settype_url*(message: google_protobuf_Field, value: string) = + message.type_url = value + incl(message.hasField, 6) + +proc type_url*(message: google_protobuf_Field): string {.inline.} = + message.type_url + +proc `type_url=`*(message: google_protobuf_Field, value: string) {.inline.} = + settype_url(message, value) + +proc clearoneof_index*(message: google_protobuf_Field) = + message.oneof_index = 0 + excl(message.hasField, [7]) + +proc hasoneof_index*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 7) + +proc setoneof_index*(message: google_protobuf_Field, value: int32) = + message.oneof_index = value + incl(message.hasField, 7) + +proc oneof_index*(message: google_protobuf_Field): int32 {.inline.} = + message.oneof_index + +proc `oneof_index=`*(message: google_protobuf_Field, value: int32) {.inline.} = + setoneof_index(message, value) + +proc clearpacked*(message: google_protobuf_Field) = + message.packed = false + excl(message.hasField, [8]) + +proc haspacked*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 8) + +proc setpacked*(message: google_protobuf_Field, value: bool) = + message.packed = value + incl(message.hasField, 8) + +proc packed*(message: google_protobuf_Field): bool {.inline.} = + message.packed + +proc `packed=`*(message: google_protobuf_Field, value: bool) {.inline.} = + setpacked(message, value) + +proc clearoptions*(message: google_protobuf_Field) = + message.options = @[] + excl(message.hasField, [9]) + +proc hasoptions*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 9) or (len(message.options) > 0) + +proc setoptions*(message: google_protobuf_Field, value: seq[google_protobuf_Option]) = + message.options = value + incl(message.hasField, 9) + +proc addoptions*(message: google_protobuf_Field, value: google_protobuf_Option) = + add(message.options, value) + incl(message.hasField, 9) + +proc options*(message: google_protobuf_Field): seq[google_protobuf_Option] {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_Field, value: seq[google_protobuf_Option]) {.inline.} = + setoptions(message, value) + +proc clearjson_name*(message: google_protobuf_Field) = + message.json_name = "" + excl(message.hasField, [10]) + +proc hasjson_name*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 10) + +proc setjson_name*(message: google_protobuf_Field, value: string) = + message.json_name = value + incl(message.hasField, 10) + +proc json_name*(message: google_protobuf_Field): string {.inline.} = + message.json_name + +proc `json_name=`*(message: google_protobuf_Field, value: string) {.inline.} = + setjson_name(message, value) + +proc cleardefault_value*(message: google_protobuf_Field) = + message.default_value = "" + excl(message.hasField, [11]) + +proc hasdefault_value*(message: google_protobuf_Field): bool = + result = contains(message.hasField, 11) + +proc setdefault_value*(message: google_protobuf_Field, value: string) = + message.default_value = value + incl(message.hasField, 11) + +proc default_value*(message: google_protobuf_Field): string {.inline.} = + message.default_value + +proc `default_value=`*(message: google_protobuf_Field, value: string) {.inline.} = + setdefault_value(message, value) + +proc sizeOfgoogle_protobuf_Field*(message: google_protobuf_Field): uint64 = + if haskind(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_Field_Kind](message.kind) + if hascardinality(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_Field_Cardinality](message.cardinality) + if hasnumber(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfInt32(message.number) + if hasname(message): + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hastype_url(message): + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfString(message.type_url) + if hasoneof_index(message): + result = result + sizeOfTag(7, WireType.Varint) + result = result + sizeOfInt32(message.oneof_index) + if haspacked(message): + result = result + sizeOfTag(8, WireType.Varint) + result = result + sizeOfBool(message.packed) + for value in message.options: + result = result + sizeOfTag(9, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) + if hasjson_name(message): + result = result + sizeOfTag(10, WireType.LengthDelimited) + result = result + sizeOfString(message.json_name) + if hasdefault_value(message): + result = result + sizeOfTag(11, WireType.LengthDelimited) + result = result + sizeOfString(message.default_value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Field*(stream: ProtobufStream, message: google_protobuf_Field) = + if haskind(message): + writeEnum(stream, message.kind, 1) + if hascardinality(message): + writeEnum(stream, message.cardinality, 2) + if hasnumber(message): + writeInt32(stream, message.number, 3) + if hasname(message): + writeString(stream, message.name, 4) + if hastype_url(message): + writeString(stream, message.type_url, 6) + if hasoneof_index(message): + writeInt32(stream, message.oneof_index, 7) + if haspacked(message): + writeBool(stream, message.packed, 8) + for value in message.options: + writeMessage(stream, value, 9) + if hasjson_name(message): + writeString(stream, message.json_name, 10) + if hasdefault_value(message): + writeString(stream, message.default_value, 11) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Field*(stream: ProtobufStream): google_protobuf_Field = + result = newgoogle_protobuf_Field() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setkind(result, readEnum[google_protobuf_Field_Kind](stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setcardinality(result, readEnum[google_protobuf_Field_Cardinality](stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setnumber(result, readInt32(stream)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + settype_url(result, readString(stream)) + of 7: + expectWireType(wireType, WireType.Varint) + setoneof_index(result, readInt32(stream)) + of 8: + expectWireType(wireType, WireType.Varint) + setpacked(result, readBool(stream)) + of 9: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoptions(result, newgoogle_protobuf_Option(data)) + of 10: + expectWireType(wireType, WireType.LengthDelimited) + setjson_name(result, readString(stream)) + of 11: + expectWireType(wireType, WireType.LengthDelimited) + setdefault_value(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Field): JsonNode = + result = newJObject() + if haskind(message): + result["kind"] = %($message.kind) + if hascardinality(message): + result["cardinality"] = %($message.cardinality) + if hasnumber(message): + result["number"] = %message.number + if hasname(message): + result["name"] = %message.name + if hastype_url(message): + result["typeUrl"] = %message.type_url + if hasoneof_index(message): + result["oneofIndex"] = %message.oneof_index + if haspacked(message): + result["packed"] = %message.packed + if hasoptions(message): + let arr = newJArray() + for value in message.options: + add(arr, toJson(value)) + result["options"] = arr + if hasjson_name(message): + result["jsonName"] = %message.json_name + if hasdefault_value(message): + result["defaultValue"] = %message.default_value + +proc serialize*(message: google_protobuf_Field): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Field(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Field*(data: string): google_protobuf_Field = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Field(pbs) + + +proc newgoogle_protobuf_Type*(): google_protobuf_Type = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.fields = @[] + result.oneofs = @[] + result.options = @[] + result.source_context = nil + result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + +proc clearname*(message: google_protobuf_Type) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_Type): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_Type, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_Type): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Type, value: string) {.inline.} = + setname(message, value) + +proc clearfields*(message: google_protobuf_Type) = + message.fields = @[] + excl(message.hasField, [2]) + +proc hasfields*(message: google_protobuf_Type): bool = + result = contains(message.hasField, 2) or (len(message.fields) > 0) + +proc setfields*(message: google_protobuf_Type, value: seq[google_protobuf_Field]) = + message.fields = value + incl(message.hasField, 2) + +proc addfields*(message: google_protobuf_Type, value: google_protobuf_Field) = + add(message.fields, value) + incl(message.hasField, 2) + +proc fields*(message: google_protobuf_Type): seq[google_protobuf_Field] {.inline.} = + message.fields + +proc `fields=`*(message: google_protobuf_Type, value: seq[google_protobuf_Field]) {.inline.} = + setfields(message, value) + +proc clearoneofs*(message: google_protobuf_Type) = + message.oneofs = @[] + excl(message.hasField, [3]) + +proc hasoneofs*(message: google_protobuf_Type): bool = + result = contains(message.hasField, 3) or (len(message.oneofs) > 0) + +proc setoneofs*(message: google_protobuf_Type, value: seq[string]) = + message.oneofs = value + incl(message.hasField, 3) + +proc addoneofs*(message: google_protobuf_Type, value: string) = + add(message.oneofs, value) + incl(message.hasField, 3) + +proc oneofs*(message: google_protobuf_Type): seq[string] {.inline.} = + message.oneofs + +proc `oneofs=`*(message: google_protobuf_Type, value: seq[string]) {.inline.} = + setoneofs(message, value) + +proc clearoptions*(message: google_protobuf_Type) = + message.options = @[] + excl(message.hasField, [4]) + +proc hasoptions*(message: google_protobuf_Type): bool = + result = contains(message.hasField, 4) or (len(message.options) > 0) + +proc setoptions*(message: google_protobuf_Type, value: seq[google_protobuf_Option]) = + message.options = value + incl(message.hasField, 4) + +proc addoptions*(message: google_protobuf_Type, value: google_protobuf_Option) = + add(message.options, value) + incl(message.hasField, 4) + +proc options*(message: google_protobuf_Type): seq[google_protobuf_Option] {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_Type, value: seq[google_protobuf_Option]) {.inline.} = + setoptions(message, value) + +proc clearsource_context*(message: google_protobuf_Type) = + message.source_context = nil + excl(message.hasField, [5]) + +proc hassource_context*(message: google_protobuf_Type): bool = + result = contains(message.hasField, 5) + +proc setsource_context*(message: google_protobuf_Type, value: google_protobuf_SourceContext) = + message.source_context = value + incl(message.hasField, 5) + +proc source_context*(message: google_protobuf_Type): google_protobuf_SourceContext {.inline.} = + message.source_context + +proc `source_context=`*(message: google_protobuf_Type, value: google_protobuf_SourceContext) {.inline.} = + setsource_context(message, value) + +proc clearsyntax*(message: google_protobuf_Type) = + message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + excl(message.hasField, [6]) + +proc hassyntax*(message: google_protobuf_Type): bool = + result = contains(message.hasField, 6) + +proc setsyntax*(message: google_protobuf_Type, value: google_protobuf_Syntax) = + message.syntax = value + incl(message.hasField, 6) + +proc syntax*(message: google_protobuf_Type): google_protobuf_Syntax {.inline.} = + message.syntax + +proc `syntax=`*(message: google_protobuf_Type, value: google_protobuf_Syntax) {.inline.} = + setsyntax(message, value) + +proc sizeOfgoogle_protobuf_Type*(message: google_protobuf_Type): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + for value in message.fields: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Field(value)) + for value in message.oneofs: + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfString(value) + for value in message.options: + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) + if hassource_context(message): + result = result + sizeOfTag(5, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context)) + if hassyntax(message): + result = result + sizeOfTag(6, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Type*(stream: ProtobufStream, message: google_protobuf_Type) = + if hasname(message): + writeString(stream, message.name, 1) + for value in message.fields: + writeMessage(stream, value, 2) + for value in message.oneofs: + writeString(stream, value, 3) + for value in message.options: + writeMessage(stream, value, 4) + if hassource_context(message): + writeMessage(stream, message.source_context, 5) + if hassyntax(message): + writeEnum(stream, message.syntax, 6) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Type*(stream: ProtobufStream): google_protobuf_Type = + result = newgoogle_protobuf_Type() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addfields(result, newgoogle_protobuf_Field(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + addoneofs(result, readString(stream)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoptions(result, newgoogle_protobuf_Option(data)) + of 5: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setsource_context(result, newgoogle_protobuf_SourceContext(data)) + of 6: + expectWireType(wireType, WireType.Varint) + setsyntax(result, readEnum[google_protobuf_Syntax](stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Type): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasfields(message): + let arr = newJArray() + for value in message.fields: + add(arr, toJson(value)) + result["fields"] = arr + if hasoneofs(message): + let arr = newJArray() + for value in message.oneofs: + add(arr, %value) + result["oneofs"] = arr + if hasoptions(message): + let arr = newJArray() + for value in message.options: + add(arr, toJson(value)) + result["options"] = arr + if hassource_context(message): + result["sourceContext"] = toJson(message.source_context) + if hassyntax(message): + result["syntax"] = %($message.syntax) + +proc serialize*(message: google_protobuf_Type): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Type(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Type*(data: string): google_protobuf_Type = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Type(pbs) + + +proc newgoogle_protobuf_EnumValue*(): google_protobuf_EnumValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.number = 0 + result.options = @[] + +proc clearname*(message: google_protobuf_EnumValue) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_EnumValue): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_EnumValue, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_EnumValue): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_EnumValue, value: string) {.inline.} = + setname(message, value) + +proc clearnumber*(message: google_protobuf_EnumValue) = + message.number = 0 + excl(message.hasField, [2]) + +proc hasnumber*(message: google_protobuf_EnumValue): bool = + result = contains(message.hasField, 2) + +proc setnumber*(message: google_protobuf_EnumValue, value: int32) = + message.number = value + incl(message.hasField, 2) + +proc number*(message: google_protobuf_EnumValue): int32 {.inline.} = + message.number + +proc `number=`*(message: google_protobuf_EnumValue, value: int32) {.inline.} = + setnumber(message, value) + +proc clearoptions*(message: google_protobuf_EnumValue) = + message.options = @[] + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_EnumValue): bool = + result = contains(message.hasField, 3) or (len(message.options) > 0) + +proc setoptions*(message: google_protobuf_EnumValue, value: seq[google_protobuf_Option]) = + message.options = value + incl(message.hasField, 3) + +proc addoptions*(message: google_protobuf_EnumValue, value: google_protobuf_Option) = + add(message.options, value) + incl(message.hasField, 3) + +proc options*(message: google_protobuf_EnumValue): seq[google_protobuf_Option] {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_EnumValue, value: seq[google_protobuf_Option]) {.inline.} = + setoptions(message, value) + +proc sizeOfgoogle_protobuf_EnumValue*(message: google_protobuf_EnumValue): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasnumber(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.number) + for value in message.options: + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_EnumValue*(stream: ProtobufStream, message: google_protobuf_EnumValue) = + if hasname(message): + writeString(stream, message.name, 1) + if hasnumber(message): + writeInt32(stream, message.number, 2) + for value in message.options: + writeMessage(stream, value, 3) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_EnumValue*(stream: ProtobufStream): google_protobuf_EnumValue = + result = newgoogle_protobuf_EnumValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setnumber(result, readInt32(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoptions(result, newgoogle_protobuf_Option(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_EnumValue): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasnumber(message): + result["number"] = %message.number + if hasoptions(message): + let arr = newJArray() + for value in message.options: + add(arr, toJson(value)) + result["options"] = arr + +proc serialize*(message: google_protobuf_EnumValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_EnumValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_EnumValue*(data: string): google_protobuf_EnumValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_EnumValue(pbs) + + +proc newgoogle_protobuf_Enum*(): google_protobuf_Enum = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.enumvalue = @[] + result.options = @[] + result.source_context = nil + result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + +proc clearname*(message: google_protobuf_Enum) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_Enum): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_Enum, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_Enum): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_Enum, value: string) {.inline.} = + setname(message, value) + +proc clearenumvalue*(message: google_protobuf_Enum) = + message.enumvalue = @[] + excl(message.hasField, [2]) + +proc hasenumvalue*(message: google_protobuf_Enum): bool = + result = contains(message.hasField, 2) or (len(message.enumvalue) > 0) + +proc setenumvalue*(message: google_protobuf_Enum, value: seq[google_protobuf_EnumValue]) = + message.enumvalue = value + incl(message.hasField, 2) + +proc addenumvalue*(message: google_protobuf_Enum, value: google_protobuf_EnumValue) = + add(message.enumvalue, value) + incl(message.hasField, 2) + +proc enumvalue*(message: google_protobuf_Enum): seq[google_protobuf_EnumValue] {.inline.} = + message.enumvalue + +proc `enumvalue=`*(message: google_protobuf_Enum, value: seq[google_protobuf_EnumValue]) {.inline.} = + setenumvalue(message, value) + +proc clearoptions*(message: google_protobuf_Enum) = + message.options = @[] + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_Enum): bool = + result = contains(message.hasField, 3) or (len(message.options) > 0) + +proc setoptions*(message: google_protobuf_Enum, value: seq[google_protobuf_Option]) = + message.options = value + incl(message.hasField, 3) + +proc addoptions*(message: google_protobuf_Enum, value: google_protobuf_Option) = + add(message.options, value) + incl(message.hasField, 3) + +proc options*(message: google_protobuf_Enum): seq[google_protobuf_Option] {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_Enum, value: seq[google_protobuf_Option]) {.inline.} = + setoptions(message, value) + +proc clearsource_context*(message: google_protobuf_Enum) = + message.source_context = nil + excl(message.hasField, [4]) + +proc hassource_context*(message: google_protobuf_Enum): bool = + result = contains(message.hasField, 4) + +proc setsource_context*(message: google_protobuf_Enum, value: google_protobuf_SourceContext) = + message.source_context = value + incl(message.hasField, 4) + +proc source_context*(message: google_protobuf_Enum): google_protobuf_SourceContext {.inline.} = + message.source_context + +proc `source_context=`*(message: google_protobuf_Enum, value: google_protobuf_SourceContext) {.inline.} = + setsource_context(message, value) + +proc clearsyntax*(message: google_protobuf_Enum) = + message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 + excl(message.hasField, [5]) + +proc hassyntax*(message: google_protobuf_Enum): bool = + result = contains(message.hasField, 5) + +proc setsyntax*(message: google_protobuf_Enum, value: google_protobuf_Syntax) = + message.syntax = value + incl(message.hasField, 5) + +proc syntax*(message: google_protobuf_Enum): google_protobuf_Syntax {.inline.} = + message.syntax + +proc `syntax=`*(message: google_protobuf_Enum, value: google_protobuf_Syntax) {.inline.} = + setsyntax(message, value) + +proc sizeOfgoogle_protobuf_Enum*(message: google_protobuf_Enum): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + for value in message.enumvalue: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumValue(value)) + for value in message.options: + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) + if hassource_context(message): + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context)) + if hassyntax(message): + result = result + sizeOfTag(5, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Enum*(stream: ProtobufStream, message: google_protobuf_Enum) = + if hasname(message): + writeString(stream, message.name, 1) + for value in message.enumvalue: + writeMessage(stream, value, 2) + for value in message.options: + writeMessage(stream, value, 3) + if hassource_context(message): + writeMessage(stream, message.source_context, 4) + if hassyntax(message): + writeEnum(stream, message.syntax, 5) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Enum*(stream: ProtobufStream): google_protobuf_Enum = + result = newgoogle_protobuf_Enum() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addenumvalue(result, newgoogle_protobuf_EnumValue(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoptions(result, newgoogle_protobuf_Option(data)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setsource_context(result, newgoogle_protobuf_SourceContext(data)) + of 5: + expectWireType(wireType, WireType.Varint) + setsyntax(result, readEnum[google_protobuf_Syntax](stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc toJson*(message: google_protobuf_Enum): JsonNode = + result = newJObject() + if hasname(message): + result["name"] = %message.name + if hasenumvalue(message): + let arr = newJArray() + for value in message.enumvalue: + add(arr, toJson(value)) + result["enumvalue"] = arr + if hasoptions(message): + let arr = newJArray() + for value in message.options: + add(arr, toJson(value)) + result["options"] = arr + if hassource_context(message): + result["sourceContext"] = toJson(message.source_context) + if hassyntax(message): + result["syntax"] = %($message.syntax) + +proc serialize*(message: google_protobuf_Enum): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Enum(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Enum*(data: string): google_protobuf_Enum = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Enum(pbs) + + diff --git a/nimpb/wkt/wrappers_pb.nim b/nimpb/wkt/wrappers_pb.nim new file mode 100644 index 0000000..d1b5f80 --- /dev/null +++ b/nimpb/wkt/wrappers_pb.nim @@ -0,0 +1,677 @@ +# Generated by protoc_gen_nim. Do not edit! + +import base64 +import intsets +import json + +import nimpb/nimpb +import nimpb/json as nimpb_json + +type + google_protobuf_DoubleValue* = ref google_protobuf_DoubleValueObj + google_protobuf_DoubleValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: float64 + google_protobuf_FloatValue* = ref google_protobuf_FloatValueObj + google_protobuf_FloatValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: float32 + google_protobuf_Int64Value* = ref google_protobuf_Int64ValueObj + google_protobuf_Int64ValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: int64 + google_protobuf_UInt64Value* = ref google_protobuf_UInt64ValueObj + google_protobuf_UInt64ValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: uint64 + google_protobuf_Int32Value* = ref google_protobuf_Int32ValueObj + google_protobuf_Int32ValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: int32 + google_protobuf_UInt32Value* = ref google_protobuf_UInt32ValueObj + google_protobuf_UInt32ValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: uint32 + google_protobuf_BoolValue* = ref google_protobuf_BoolValueObj + google_protobuf_BoolValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: bool + google_protobuf_StringValue* = ref google_protobuf_StringValueObj + google_protobuf_StringValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: string + google_protobuf_BytesValue* = ref google_protobuf_BytesValueObj + google_protobuf_BytesValueObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + value: bytes + +proc newgoogle_protobuf_Int32Value*(): google_protobuf_Int32Value +proc newgoogle_protobuf_Int32Value*(data: string): google_protobuf_Int32Value +proc writegoogle_protobuf_Int32Value*(stream: ProtobufStream, message: google_protobuf_Int32Value) +proc readgoogle_protobuf_Int32Value*(stream: ProtobufStream): google_protobuf_Int32Value +proc sizeOfgoogle_protobuf_Int32Value*(message: google_protobuf_Int32Value): uint64 + +proc newgoogle_protobuf_Int64Value*(): google_protobuf_Int64Value +proc newgoogle_protobuf_Int64Value*(data: string): google_protobuf_Int64Value +proc writegoogle_protobuf_Int64Value*(stream: ProtobufStream, message: google_protobuf_Int64Value) +proc readgoogle_protobuf_Int64Value*(stream: ProtobufStream): google_protobuf_Int64Value +proc sizeOfgoogle_protobuf_Int64Value*(message: google_protobuf_Int64Value): uint64 + +proc newgoogle_protobuf_DoubleValue*(): google_protobuf_DoubleValue +proc newgoogle_protobuf_DoubleValue*(data: string): google_protobuf_DoubleValue +proc writegoogle_protobuf_DoubleValue*(stream: ProtobufStream, message: google_protobuf_DoubleValue) +proc readgoogle_protobuf_DoubleValue*(stream: ProtobufStream): google_protobuf_DoubleValue +proc sizeOfgoogle_protobuf_DoubleValue*(message: google_protobuf_DoubleValue): uint64 + +proc newgoogle_protobuf_StringValue*(): google_protobuf_StringValue +proc newgoogle_protobuf_StringValue*(data: string): google_protobuf_StringValue +proc writegoogle_protobuf_StringValue*(stream: ProtobufStream, message: google_protobuf_StringValue) +proc readgoogle_protobuf_StringValue*(stream: ProtobufStream): google_protobuf_StringValue +proc sizeOfgoogle_protobuf_StringValue*(message: google_protobuf_StringValue): uint64 + +proc newgoogle_protobuf_BoolValue*(): google_protobuf_BoolValue +proc newgoogle_protobuf_BoolValue*(data: string): google_protobuf_BoolValue +proc writegoogle_protobuf_BoolValue*(stream: ProtobufStream, message: google_protobuf_BoolValue) +proc readgoogle_protobuf_BoolValue*(stream: ProtobufStream): google_protobuf_BoolValue +proc sizeOfgoogle_protobuf_BoolValue*(message: google_protobuf_BoolValue): uint64 + +proc newgoogle_protobuf_BytesValue*(): google_protobuf_BytesValue +proc newgoogle_protobuf_BytesValue*(data: string): google_protobuf_BytesValue +proc writegoogle_protobuf_BytesValue*(stream: ProtobufStream, message: google_protobuf_BytesValue) +proc readgoogle_protobuf_BytesValue*(stream: ProtobufStream): google_protobuf_BytesValue +proc sizeOfgoogle_protobuf_BytesValue*(message: google_protobuf_BytesValue): uint64 + +proc newgoogle_protobuf_FloatValue*(): google_protobuf_FloatValue +proc newgoogle_protobuf_FloatValue*(data: string): google_protobuf_FloatValue +proc writegoogle_protobuf_FloatValue*(stream: ProtobufStream, message: google_protobuf_FloatValue) +proc readgoogle_protobuf_FloatValue*(stream: ProtobufStream): google_protobuf_FloatValue +proc sizeOfgoogle_protobuf_FloatValue*(message: google_protobuf_FloatValue): uint64 + +proc newgoogle_protobuf_UInt64Value*(): google_protobuf_UInt64Value +proc newgoogle_protobuf_UInt64Value*(data: string): google_protobuf_UInt64Value +proc writegoogle_protobuf_UInt64Value*(stream: ProtobufStream, message: google_protobuf_UInt64Value) +proc readgoogle_protobuf_UInt64Value*(stream: ProtobufStream): google_protobuf_UInt64Value +proc sizeOfgoogle_protobuf_UInt64Value*(message: google_protobuf_UInt64Value): uint64 + +proc newgoogle_protobuf_UInt32Value*(): google_protobuf_UInt32Value +proc newgoogle_protobuf_UInt32Value*(data: string): google_protobuf_UInt32Value +proc writegoogle_protobuf_UInt32Value*(stream: ProtobufStream, message: google_protobuf_UInt32Value) +proc readgoogle_protobuf_UInt32Value*(stream: ProtobufStream): google_protobuf_UInt32Value +proc sizeOfgoogle_protobuf_UInt32Value*(message: google_protobuf_UInt32Value): uint64 + +proc newgoogle_protobuf_Int32Value*(): google_protobuf_Int32Value = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = 0 + +proc clearvalue*(message: google_protobuf_Int32Value) = + message.value = 0 + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_Int32Value): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_Int32Value, value: int32) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_Int32Value): int32 {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_Int32Value, value: int32) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_Int32Value*(message: google_protobuf_Int32Value): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt32(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Int32Value*(stream: ProtobufStream, message: google_protobuf_Int32Value) = + if hasvalue(message): + writeInt32(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Int32Value*(stream: ProtobufStream): google_protobuf_Int32Value = + result = newgoogle_protobuf_Int32Value() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setvalue(result, readInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Int32Value): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Int32Value(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Int32Value*(data: string): google_protobuf_Int32Value = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Int32Value(pbs) + + +proc newgoogle_protobuf_Int64Value*(): google_protobuf_Int64Value = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = 0 + +proc clearvalue*(message: google_protobuf_Int64Value) = + message.value = 0 + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_Int64Value): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_Int64Value, value: int64) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_Int64Value): int64 {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_Int64Value, value: int64) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_Int64Value*(message: google_protobuf_Int64Value): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt64(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_Int64Value*(stream: ProtobufStream, message: google_protobuf_Int64Value) = + if hasvalue(message): + writeInt64(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_Int64Value*(stream: ProtobufStream): google_protobuf_Int64Value = + result = newgoogle_protobuf_Int64Value() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setvalue(result, readInt64(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_Int64Value): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_Int64Value(pbs, message) + result = ss.data + +proc newgoogle_protobuf_Int64Value*(data: string): google_protobuf_Int64Value = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_Int64Value(pbs) + + +proc newgoogle_protobuf_DoubleValue*(): google_protobuf_DoubleValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = 0 + +proc clearvalue*(message: google_protobuf_DoubleValue) = + message.value = 0 + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_DoubleValue): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_DoubleValue, value: float64) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_DoubleValue): float64 {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_DoubleValue, value: float64) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_DoubleValue*(message: google_protobuf_DoubleValue): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Fixed64) + result = result + sizeOfDouble(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_DoubleValue*(stream: ProtobufStream, message: google_protobuf_DoubleValue) = + if hasvalue(message): + writeDouble(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_DoubleValue*(stream: ProtobufStream): google_protobuf_DoubleValue = + result = newgoogle_protobuf_DoubleValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Fixed64) + setvalue(result, readDouble(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_DoubleValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_DoubleValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_DoubleValue*(data: string): google_protobuf_DoubleValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_DoubleValue(pbs) + + +proc newgoogle_protobuf_StringValue*(): google_protobuf_StringValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = "" + +proc clearvalue*(message: google_protobuf_StringValue) = + message.value = "" + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_StringValue): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_StringValue, value: string) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_StringValue): string {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_StringValue, value: string) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_StringValue*(message: google_protobuf_StringValue): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_StringValue*(stream: ProtobufStream, message: google_protobuf_StringValue) = + if hasvalue(message): + writeString(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_StringValue*(stream: ProtobufStream): google_protobuf_StringValue = + result = newgoogle_protobuf_StringValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setvalue(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_StringValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_StringValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_StringValue*(data: string): google_protobuf_StringValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_StringValue(pbs) + + +proc newgoogle_protobuf_BoolValue*(): google_protobuf_BoolValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = false + +proc clearvalue*(message: google_protobuf_BoolValue) = + message.value = false + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_BoolValue): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_BoolValue, value: bool) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_BoolValue): bool {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_BoolValue, value: bool) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_BoolValue*(message: google_protobuf_BoolValue): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfBool(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_BoolValue*(stream: ProtobufStream, message: google_protobuf_BoolValue) = + if hasvalue(message): + writeBool(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_BoolValue*(stream: ProtobufStream): google_protobuf_BoolValue = + result = newgoogle_protobuf_BoolValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setvalue(result, readBool(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_BoolValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_BoolValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_BoolValue*(data: string): google_protobuf_BoolValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_BoolValue(pbs) + + +proc newgoogle_protobuf_BytesValue*(): google_protobuf_BytesValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = bytes("") + +proc clearvalue*(message: google_protobuf_BytesValue) = + message.value = bytes("") + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_BytesValue): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_BytesValue, value: bytes) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_BytesValue): bytes {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_BytesValue, value: bytes) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_BytesValue*(message: google_protobuf_BytesValue): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfBytes(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_BytesValue*(stream: ProtobufStream, message: google_protobuf_BytesValue) = + if hasvalue(message): + writeBytes(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_BytesValue*(stream: ProtobufStream): google_protobuf_BytesValue = + result = newgoogle_protobuf_BytesValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setvalue(result, readBytes(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_BytesValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_BytesValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_BytesValue*(data: string): google_protobuf_BytesValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_BytesValue(pbs) + + +proc newgoogle_protobuf_FloatValue*(): google_protobuf_FloatValue = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = 0 + +proc clearvalue*(message: google_protobuf_FloatValue) = + message.value = 0 + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_FloatValue): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_FloatValue, value: float32) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_FloatValue): float32 {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_FloatValue, value: float32) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_FloatValue*(message: google_protobuf_FloatValue): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Fixed32) + result = result + sizeOfFloat(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_FloatValue*(stream: ProtobufStream, message: google_protobuf_FloatValue) = + if hasvalue(message): + writeFloat(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FloatValue*(stream: ProtobufStream): google_protobuf_FloatValue = + result = newgoogle_protobuf_FloatValue() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Fixed32) + setvalue(result, readFloat(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FloatValue): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FloatValue(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FloatValue*(data: string): google_protobuf_FloatValue = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FloatValue(pbs) + + +proc newgoogle_protobuf_UInt64Value*(): google_protobuf_UInt64Value = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = 0 + +proc clearvalue*(message: google_protobuf_UInt64Value) = + message.value = 0 + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_UInt64Value): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_UInt64Value, value: uint64) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_UInt64Value): uint64 {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_UInt64Value, value: uint64) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_UInt64Value*(message: google_protobuf_UInt64Value): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfUInt64(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_UInt64Value*(stream: ProtobufStream, message: google_protobuf_UInt64Value) = + if hasvalue(message): + writeUInt64(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_UInt64Value*(stream: ProtobufStream): google_protobuf_UInt64Value = + result = newgoogle_protobuf_UInt64Value() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setvalue(result, readUInt64(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_UInt64Value): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_UInt64Value(pbs, message) + result = ss.data + +proc newgoogle_protobuf_UInt64Value*(data: string): google_protobuf_UInt64Value = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_UInt64Value(pbs) + + +proc newgoogle_protobuf_UInt32Value*(): google_protobuf_UInt32Value = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.value = 0 + +proc clearvalue*(message: google_protobuf_UInt32Value) = + message.value = 0 + excl(message.hasField, [1]) + +proc hasvalue*(message: google_protobuf_UInt32Value): bool = + result = contains(message.hasField, 1) + +proc setvalue*(message: google_protobuf_UInt32Value, value: uint32) = + message.value = value + incl(message.hasField, 1) + +proc value*(message: google_protobuf_UInt32Value): uint32 {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_UInt32Value, value: uint32) {.inline.} = + setvalue(message, value) + +proc sizeOfgoogle_protobuf_UInt32Value*(message: google_protobuf_UInt32Value): uint64 = + if hasvalue(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfUInt32(message.value) + for field in message.unknownFields: + result = result + sizeOfUnknownField(field) + +proc writegoogle_protobuf_UInt32Value*(stream: ProtobufStream, message: google_protobuf_UInt32Value) = + if hasvalue(message): + writeUInt32(stream, message.value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_UInt32Value*(stream: ProtobufStream): google_protobuf_UInt32Value = + result = newgoogle_protobuf_UInt32Value() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setvalue(result, readUInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_UInt32Value): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_UInt32Value(pbs, message) + result = ss.data + +proc newgoogle_protobuf_UInt32Value*(data: string): google_protobuf_UInt32Value = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_UInt32Value(pbs) + + diff --git a/src/nimpb/json.nim b/src/nimpb/json.nim deleted file mode 100644 index 28cd0f5..0000000 --- a/src/nimpb/json.nim +++ /dev/null @@ -1,209 +0,0 @@ -import base64 -import math -import std/json -import strutils -import times - -import nimpb - -import wkt/duration_pb -import wkt/timestamp_pb -import wkt/wrappers_pb -import wkt/field_mask_pb -import wkt/struct_pb -import wkt/any_pb - -proc `%`*(u: uint32): JsonNode = - newJFloat(float(u)) - -proc `%`*(b: bytes): JsonNode = - result = newJString(base64.encode(string(b), newLine="")) - -proc toJson*(value: float): JsonNode = - case classify(value) - of fcNan: result = %"NaN" - of fcInf: result = %"Infinity" - of fcNegInf: result = %"-Infinity" - else: result = %value - -proc toJson*(value: float32): JsonNode = - case classify(value) - of fcNan: result = %"NaN" - of fcInf: result = %"Infinity" - of fcNegInf: result = %"-Infinity" - else: result = %value - -proc toJson*(value: int64): JsonNode = - newJString($value) - -proc toJson*(value: uint64): JsonNode = - newJString($value) - -proc toJson*(message: google_protobuf_DoubleValue): JsonNode = - if hasValue(message): - result = toJson(message.value) - else: - result = newJNull() - -proc toJson*(message: google_protobuf_FloatValue): JsonNode = - if hasValue(message): - result = toJson(message.value) - else: - result = newJNull() - -proc toJson*(message: google_protobuf_Int64Value): JsonNode = - if hasValue(message): - result = toJson(message.value) - else: - result = newJNull() - -proc toJson*(message: google_protobuf_UInt64Value): JsonNode = - if hasValue(message): - result = toJson(message.value) - else: - result = newJNull() - -proc toJson*(message: google_protobuf_Int32Value): JsonNode = - if hasValue(message): - result = %message.value - else: - result = newJNull() - -proc toJson*(message: google_protobuf_UInt32Value): JsonNode = - if hasValue(message): - result = %message.value - else: - result = newJNull() - -proc toJson*(message: google_protobuf_BoolValue): JsonNode = - if hasValue(message): - result = %message.value - else: - result = newJNull() - -proc toJson*(message: google_protobuf_StringValue): JsonNode = - if hasValue(message): - result = %message.value - else: - result = newJNull() - -proc toJson*(message: google_protobuf_BytesValue): JsonNode = - if hasValue(message): - result = %message.value - else: - result = newJNull() - -proc toJson*(message: google_protobuf_Duration): JsonNode = - if (message.seconds < -315_576_000_000'i64) or - (message.seconds > 315_576_000_000'i64): - raise newException(ValueError, "seconds out of bounds") - - if (message.nanos < -999_999_999'i32) or - (message.nanos > 999_999_999'i32): - raise newException(ValueError, "nanos out of bounds") - - if message.seconds != 0: - if sgn(message.seconds) != sgn(message.nanos): - raise newException(ValueError, "different sign for seconds and nanos") - - var s = $message.seconds - - if message.nanos != 0: - add(s, ".") - add(s, intToStr(message.nanos, 9)) - removeSuffix(s, '0') - - add(s, "s") - - result = %s - -proc toJson*(message: google_protobuf_Timestamp): JsonNode = - let t = utc(fromUnix(message.seconds)) - - if t.year < 1 or t.year > 9999: - raise newException(ValueError, "invalid timestamp") - - var s = format(t, "yyyy-MM-dd'T'HH:mm:ss") - if message.nanos != 0: - add(s, ".") - add(s, intToStr(message.nanos, 9)) - removeSuffix(s, '0') - add(s, "Z") - result = %s - -proc toJson*(message: google_protobuf_FieldMask): JsonNode = - %join(message.paths, ",") - -proc toJson*(message: google_protobuf_Value): JsonNode - -proc toJson*(message: google_protobuf_Struct): JsonNode = - result = newJObject() - for key, value in message.fields: - result[key] = toJson(value) - -proc toJson*(message: google_protobuf_ListValue): JsonNode - -proc toJson*(message: google_protobuf_Value): JsonNode = - if hasNullValue(message): - result = newJNull() - elif hasNumberValue(message): - result = toJson(message.numberValue) - elif hasStringValue(message): - result = %message.stringValue - elif hasBoolValue(message): - result = %message.boolValue - elif hasStructValue(message): - result = toJson(message.structValue) - elif hasListValue(message): - result = toJson(message.listValue) - else: - raise newException(ValueError, "no field set") - -proc toJson*(message: google_protobuf_NullValue): JsonNode = - newJNull() - -proc toJson*(message: google_protobuf_ListValue): JsonNode = - result = newJArray() - for value in message.values: - add(result, toJson(value)) - -proc toJson*(message: google_protobuf_Any): JsonNode = - case message.typeUrl - of "type.googleapis.com/google.protobuf.Duration": - let duration = newGoogleProtobufDuration(string(message.value)) - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = toJson(duration) - of "type.googleapis.com/google.protobuf.Empty": - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = newJObject() - of "type.googleapis.com/google.protobuf.FieldMask": - let mask = newGoogleProtobufFieldMask(string(message.value)) - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = toJson(mask) - of "type.googleapis.com/google.protobuf.Struct": - let struct = newGoogleProtobufStruct(string(message.value)) - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = toJson(struct) - of "type.googleapis.com/google.protobuf.Value": - let value = newGoogleProtobufValue(string(message.value)) - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = toJson(value) - of "type.googleapis.com/google.protobuf.ListValue": - let lst = newGoogleProtobufListValue(string(message.value)) - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = toJson(lst) - of "type.googleapis.com/google.protobuf.Timestamp": - let value = newGoogleProtobufTimestamp(string(message.value)) - result = newJObject() - result["@type"] = %message.typeUrl - result["value"] = toJson(value) - else: - result = newJObject() - result["typeUrl"] = %message.typeUrl - result["value"] = %message.value diff --git a/src/nimpb/nimpb.nim b/src/nimpb/nimpb.nim deleted file mode 100644 index 4363c7d..0000000 --- a/src/nimpb/nimpb.nim +++ /dev/null @@ -1,605 +0,0 @@ -import endians -import intsets -import macros -import streams -import strutils - -export streams - -const - MaximumVarintBytes = 10 - WireTypeBits = 3 - WireTypeMask = (1 shl WireTypeBits) - 1 - -type - ProtobufStreamObj* = object of StreamObj - stream: Stream - - ProtobufStream* = ref ProtobufStreamObj - - Tag* = distinct uint32 - - ParseError* = object of Exception - - InvalidFieldNumberError* = object of ParseError - - UnexpectedWireTypeError* = object of ParseError - - bytes* = distinct string - - WireType* {.pure.} = enum - Varint = 0 - Fixed64 = 1 - LengthDelimited = 2 - StartGroup = 3 - EndGroup = 4 - Fixed32 = 5 - - FieldType* {.pure.} = enum - Double = 1 - Float - Int64 - UInt64 - Int32 - Fixed64 - Fixed32 - Bool - String - Group - Message - Bytes - UInt32 - Enum - SFixed32 - SFixed64 - SInt32 - SInt64 - - UnknownField* = ref UnknownFieldObj - UnknownFieldObj* = object - fieldNumber: int - case wiretype: WireType - of WireType.Varint: - vint: uint64 - of WireType.Fixed64: - fixed64: uint64 - of WireType.LengthDelimited: - data: string - of WireType.Fixed32: - fixed32: uint32 - else: - discard - -proc wiretype*(ft: FieldType): WireType = - case ft - of FieldType.Double: result = WireType.Fixed64 - of FieldType.Float: result = WireType.Fixed32 - of FieldType.Int64: result = WireType.Varint - of FieldType.UInt64: result = WireType.Varint - of FieldType.Int32: result = WireType.Varint - of FieldType.Fixed64: result = WireType.Fixed64 - of FieldType.Fixed32: result = WireType.Fixed32 - of FieldType.Bool: result = WireType.Varint - of FieldType.String: result = WireType.LengthDelimited - of FieldType.Group: result = WireType.LengthDelimited # ??? - of FieldType.Message: result = WireType.LengthDelimited - of FieldType.Bytes: result = WireType.LengthDelimited - of FieldType.UInt32: result = WireType.Varint - of FieldType.Enum: result = WireType.Varint - of FieldType.SFixed32: result = WireType.Fixed32 - of FieldType.SFixed64: result = WireType.Fixed64 - of FieldType.SInt32: result = WireType.Varint - of FieldType.SInt64: result = WireType.Varint - -proc isNumeric*(wiretype: WireType): bool = - case wiretype - of WireType.Varint: result = true - of WireType.Fixed64: result = true - of WireType.Fixed32: result = true - else: result = false - -proc isNumeric*(ft: FieldType): bool = - result = isNumeric(wiretype(ft)) - -proc pbClose(s: Stream) = - close(ProtobufStream(s).stream) - ProtobufStream(s).stream = nil - -proc pbAtEnd(s: Stream): bool = - result = atEnd(ProtobufStream(s).stream) - -proc pbSetPosition(s: Stream, pos: int) = - setPosition(ProtobufStream(s).stream, pos) - -proc pbGetPosition(s: Stream): int = - result = getPosition(ProtobufStream(s).stream) - -proc pbReadData(s: Stream, buffer: pointer, bufLen: int): int = - result = readData(ProtobufStream(s).stream, buffer, bufLen) - -proc pbPeekData(s: Stream, buffer: pointer, bufLen: int): int = - result = peekData(ProtobufStream(s).stream, buffer, bufLen) - -proc pbWriteData(s: Stream, buffer: pointer, bufLen: int) = - writeData(ProtobufStream(s).stream, buffer, bufLen) - -proc pbFlush(s: Stream) = - flush(ProtobufStream(s).stream) - -proc newProtobufStream*(stream: Stream): ProtobufStream = - new(result) - - result.closeImpl = pbClose - result.atEndImpl = pbAtEnd - result.setPositionImpl = pbSetPosition - result.getPositionImpl = pbGetPosition - result.readDataImpl = pbReadData - result.peekDataImpl = pbPeekData - result.writeDataImpl = pbWriteData - result.flushImpl = pbFlush - - result.stream = stream - -proc readByte(stream: ProtobufStream): byte = - result = readInt8(stream).byte - -proc writeByte(stream: ProtobufStream, b: byte) = - var x: byte - shallowCopy(x, b) - writeData(stream, addr(x), sizeof(x)) - -proc readVarint*(stream: ProtobufStream): uint64 = - var - count = 0 - - result = 0 - - while true: - if count == MaximumVarintBytes: - raise newException(Exception, "invalid varint (<= 10 bytes)") - - let b = readByte(stream) - - result = result or ((b.uint64 and 0x7f) shl (7 * count)) - - inc(count) - - if (b and 0x80) == 0: - break - -proc writeVarint*(stream: ProtobufStream, n: uint64) = - var value = n - while value >= 0x80'u64: - writeByte(stream, (value or 0x80).byte) - value = value shr 7 - writeByte(stream, value.byte) - -proc zigzagEncode*(n: int32): uint32 = - let x = cast[uint32](n) - let a = cast[int32](x shl 1) - let b = -cast[int32](x shr 31) - result = uint32(a xor b) - -proc zigzagDecode*(n: uint32): int32 = - let a = int32(n shr 1) - let b = -int32(n and 1) - result = a xor b - -proc zigzagEncode*(n: int64): uint64 = - let x = cast[uint64](n) - let a = cast[int64](x shl 1) - let b = -cast[int64](x shr 63) - result = uint64(a xor b) - -proc zigzagDecode*(n: uint64): int64 = - let a = int64(n shr 1) - let b = -int64(n and 1) - result = a xor b - -template makeTag*(fieldNumber: int, wireType: WireType): Tag = - ((fieldNumber shl 3).uint32 or wireType.uint32).Tag - -template wireType*(tag: Tag): WireType = - (tag.uint32 and WireTypeMask).WireType - -template fieldNumber*(tag: Tag): int = - (tag.uint32 shr 3).int - -proc writeTag*(stream: ProtobufStream, tag: Tag) = - writeVarint(stream, tag.uint32) - -proc writeTag*(stream: ProtobufStream, fieldNumber: int, wireType: WireType) = - writeTag(stream, makeTag(fieldNumber, wireType)) - -proc readTag*(stream: ProtobufStream): Tag = - result = readVarint(stream).Tag - -proc writeInt32*(stream: ProtobufStream, n: int32) = - writeVarint(stream, n.uint64) - -proc writeInt32*(stream: ProtobufStream, n: int32, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeInt32(stream, n) - -proc readInt32*(stream: ProtobufStream): int32 = - result = readVarint(stream).int32 - -proc writeSInt32*(stream: ProtobufStream, n: int32) = - writeVarint(stream, zigzagEncode(n)) - -proc writeSInt32*(stream: ProtobufStream, n: int32, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeVarint(stream, zigzagEncode(n)) - -proc readSInt32*(stream: ProtobufStream): int32 = - result = zigzagDecode(readVarint(stream).uint32) - -proc writeUInt32*(stream: ProtobufStream, n: uint32) = - writeVarint(stream, n) - -proc writeUInt32*(stream: ProtobufStream, n: uint32, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeVarint(stream, n) - -proc readUInt32*(stream: ProtobufStream): uint32 = - result = readVarint(stream).uint32 - -proc writeInt64*(stream: ProtobufStream, n: int64) = - writeVarint(stream, n.uint64) - -proc writeInt64*(stream: ProtobufStream, n: int64, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeVarint(stream, n.uint64) - -proc readInt64*(stream: ProtobufStream): int64 = - result = readVarint(stream).int64 - -proc writeSInt64*(stream: ProtobufStream, n: int64) = - writeVarint(stream, zigzagEncode(n)) - -proc writeSInt64*(stream: ProtobufStream, n: int64, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeVarint(stream, zigzagEncode(n)) - -proc readSInt64*(stream: ProtobufStream): int64 = - result = zigzagDecode(readVarint(stream)) - -proc writeUInt64*(stream: ProtobufStream, n: uint64) = - writeVarint(stream, n) - -proc writeUInt64*(stream: ProtobufStream, n: uint64, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeVarint(stream, n) - -proc readUInt64*(stream: ProtobufStream): uint64 = - result = readVarint(stream) - -proc writeBool*(stream: ProtobufStream, value: bool) = - writeVarint(stream, value.uint32) - -proc writeBool*(stream: ProtobufStream, n: bool, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeVarint(stream, n.uint32) - -proc readBool*(stream: ProtobufStream): bool = - result = readVarint(stream).bool - -proc writeFixed64*(stream: ProtobufStream, value: uint64) = - var - input = value - output: uint64 - - littleEndian64(addr(output), addr(input)) - - write(stream, output) - -proc writeFixed64*(stream: ProtobufStream, n: uint64, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Fixed64) - writeFixed64(stream, n) - -proc readFixed64*(stream: ProtobufStream): uint64 = - var tmp: uint64 - if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): - raise newException(IOError, "cannot read from stream") - littleEndian64(addr(result), addr(tmp)) - -proc writeSFixed64*(stream: ProtobufStream, value: int64) = - writeFixed64(stream, cast[uint64](value)) - -proc writeSFixed64*(stream: ProtobufStream, value: int64, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Fixed64) - writeSFixed64(stream, value) - -proc readSFixed64*(stream: ProtobufStream): int64 = - result = cast[int64](readFixed64(stream)) - -proc writeDouble*(stream: ProtobufStream, value: float64) = - var - input = value - output: float64 - - littleEndian64(addr(output), addr(input)) - - write(stream, output) - -proc writeDouble*(stream: ProtobufStream, value: float64, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Fixed64) - writeDouble(stream, value) - -proc readDouble*(stream: ProtobufStream): float64 = - var tmp: uint64 - if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): - raise newException(IOError, "cannot read from stream") - littleEndian64(addr(result), addr(tmp)) - -proc writeFixed32*(stream: ProtobufStream, value: uint32) = - var - input = value - output: uint32 - - littleEndian32(addr(output), addr(input)) - - write(stream, output) - -proc writeFixed32*(stream: ProtobufStream, value: uint32, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Fixed32) - writeFixed32(stream, value) - -proc readFixed32*(stream: ProtobufStream): uint32 = - var tmp: uint32 - if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): - raise newException(IOError, "cannot read from stream") - littleEndian32(addr(result), addr(tmp)) - -proc writeSFixed32*(stream: ProtobufStream, value: int32) = - writeFixed32(stream, cast[uint32](value)) - -proc writeSFixed32*(stream: ProtobufStream, value: int32, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Fixed32) - writeSFixed32(stream, value) - -proc readSFixed32*(stream: ProtobufStream): int32 = - result = cast[int32](readFixed32(stream)) - -proc writeFloat*(stream: ProtobufStream, value: float32) = - var - input = value - output: float32 - - littleEndian32(addr(output), addr(input)) - - write(stream, output) - -proc writeFloat*(stream: ProtobufStream, value: float32, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Fixed32) - writeFloat(stream, value) - -proc readFloat*(stream: ProtobufStream): float32 = - var tmp: float32 - if readData(stream, addr(tmp), sizeof(tmp)) != sizeof(tmp): - raise newException(IOError, "cannot read from stream") - littleEndian32(addr(result), addr(tmp)) - -proc writeString*(stream: ProtobufStream, s: string) = - writeUInt64(stream, len(s).uint64) - write(stream, s) - -proc writeString*(stream: ProtobufStream, s: string, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.LengthDelimited) - writeString(stream, s) - -proc writeBytes*(stream: ProtobufStream, s: bytes) = - writeString(stream, string(s)) - -proc writeBytes*(stream: ProtobufStream, s: bytes, fieldNumber: int) = - writeString(stream, string(s), fieldNumber) - -proc safeReadStr*(stream: Stream, size: int): string = - result = newString(size) - if readData(stream, addr(result[0]), size) != size: - raise newException(IOError, "cannot read from stream") - -proc readString*(stream: ProtobufStream): string = - let size = int(readUInt64(stream)) - result = safeReadStr(stream, size) - -proc readBytes*(stream: ProtobufStream): bytes = - bytes(readString(stream)) - -proc readEnum*[T](stream: ProtobufStream): T = - result = T(readUInt32(stream)) - -proc writeEnum*[T](stream: ProtobufStream, value: T) = - writeUInt32(stream, uint32(value)) - -proc writeEnum*[T](stream: ProtobufStream, value: T, fieldNumber: int) = - writeTag(stream, fieldNumber, WireType.Varint) - writeUInt32(stream, uint32(value)) - -proc sizeOfVarint[T](value: T): uint64 = - var tmp = uint64(value) - while tmp >= 0x80'u64: - tmp = tmp shr 7 - inc(result) - inc(result) - -proc packedFieldSize*[T](values: seq[T], fieldtype: FieldType): uint64 = - case fieldtype - of FieldType.Fixed64, FieldType.SFixed64, FieldType.Double: - result = uint64(len(values)) * 8 - of FieldType.Fixed32, FieldType.SFixed32, FieldType.Float: - result = uint64(len(values)) * 4 - of FieldType.Int64, FieldType.UInt64, FieldType.Int32, FieldType.Bool, - FieldType.UInt32, FieldType.Enum: - for value in values: - result += sizeOfVarint(value) - of FieldType.SInt32: - for value in values: - result += sizeOfVarint(zigzagEncode(int32(value))) - of FieldType.SInt64: - for value in values: - result += sizeOfVarint(zigzagEncode(int64(value))) - else: - raise newException(Exception, "invalid fieldtype") - -proc sizeOfString*(s: string): uint64 = - result = sizeOfVarint(len(s).uint64) + len(s).uint64 - -proc sizeOfBytes*(s: bytes): uint64 = - result = sizeOfString(string(s)) - -proc sizeOfDouble*(value: float64): uint64 = - result = 8 - -proc sizeOfFloat*(value: float32): uint64 = - result = 4 - -proc sizeOfInt64*(value: int64): uint64 = - result = sizeOfVarint(value) - -proc sizeOfUInt64*(value: uint64): uint64 = - result = sizeOfVarint(value) - -proc sizeOfInt32*(value: int32): uint64 = - result = sizeOfVarint(value) - -proc sizeOfFixed64*(value: uint64): uint64 = - result = 8 - -proc sizeOfFixed32*(value: uint32): uint64 = - result = 4 - -proc sizeOfBool*(value: bool): uint64 = - result = sizeOfVarint(value) - -proc sizeOfUInt32*(value: uint32): uint64 = - result = sizeOfVarint(value) - -proc sizeOfSFixed32*(value: int32): uint64 = - result = 4 - -proc sizeOfSFixed64*(value: int64): uint64 = - result = 8 - -proc sizeOfSInt32*(value: int32): uint64 = - result = sizeOfVarint(zigzagEncode(value)) - -proc sizeOfSInt64*(value: int64): uint64 = - result = sizeOfVarint(zigzagEncode(value)) - -proc sizeOfEnum*[T](value: T): uint64 = - result = sizeOfUInt32(value.uint32) - -proc sizeOfLengthDelimited*(size: uint64): uint64 = - result = size + sizeOfVarint(size) - -proc sizeOfTag*(fieldNumber: int, wiretype: WireType): uint64 = - result = sizeOfUInt32(uint32(makeTag(fieldNumber, wiretype))) - -proc skipField*(stream: ProtobufStream, wiretype: WireType) = - case wiretype - of WireType.Varint: - discard readVarint(stream) - of WireType.Fixed64: - discard readFixed64(stream) - of WireType.Fixed32: - discard readFixed32(stream) - of WireType.LengthDelimited: - let size = readVarint(stream) - discard safeReadStr(stream, int(size)) - else: - raise newException(Exception, "unsupported wiretype: " & $wiretype) - -proc expectWireType*(actual: WireType, expected: varargs[WireType]) = - for exp in expected: - if actual == exp: - return - let message = "Got wiretype " & $actual & " but expected: " & - join(expected, ", ") - raise newException(UnexpectedWireTypeError, message) - -macro writeMessage*(stream: ProtobufStream, message: typed, fieldNumber: int): typed = - ## Write a message to a stream with tag and length. - let t = getTypeInst(message) - result = newStmtList( - newCall( - ident("writeTag"), - stream, - fieldNumber, - newDotExpr(ident("WireType"), ident("LengthDelimited")) - ), - newCall( - ident("writeVarint"), - stream, - newCall(ident("sizeOf" & $t), message) - ), - newCall( - ident("write" & $t), - stream, - message - ) - ) - -proc excl*(s: var IntSet, values: openArray[int]) = - ## Exclude multiple values from an IntSet. - for value in values: - excl(s, value) - -proc readLengthDelimited*(stream: ProtobufStream): string = - let size = int(readVarint(stream)) - result = safeReadStr(stream, size) - -proc readUnknownField*(stream: ProtobufStream, tag: Tag, - fields: var seq[UnknownField]) = - var field: UnknownField - - new(field) - field.fieldNumber = fieldNumber(tag) - field.wireType = wiretype(tag) - - case field.wiretype - of WireType.Varint: - field.vint = readVarint(stream) - of WireType.Fixed64: - field.fixed64 = readFixed64(stream) - of WireType.Fixed32: - field.fixed32 = readFixed32(stream) - of WireType.LengthDelimited: - let size = readVarint(stream) - field.data = safeReadStr(stream, int(size)) - else: - raise newException(Exception, "unsupported wiretype: " & $field.wiretype) - - add(fields, field) - -proc writeUnknownFields*(stream: ProtobufStream, fields: seq[UnknownField]) = - for field in fields: - case field.wiretype - of WireType.Varint: - writeTag(stream, field.fieldNumber, field.wireType) - writeVarint(stream, field.vint) - of WireType.Fixed64: - writeFixed64(stream, field.fixed64, field.fieldNumber) - of WireType.Fixed32: - writeFixed32(stream, field.fixed32, field.fieldNumber) - of WireType.LengthDelimited: - writeString(stream, field.data, field.fieldNumber) - else: - raise newException(Exception, "unsupported wiretype: " & $field.wiretype) - -proc discardUnknownFields*[T](message: T) = - message.unknownFields = @[] - -proc sizeOfUnknownField*(field: UnknownField): uint64 = - result = sizeOfTag(field.fieldNumber, field.wiretype) - case field.wiretype - of WireType.Varint: - result = result + sizeOfVarint(field.vint) - of WireType.Fixed64: - result = result + 8 - of WireType.Fixed32: - result = result + 4 - of WireType.LengthDelimited: - result = result + sizeOfLengthDelimited(uint64(len(field.data))) - else: - raise newException(Exception, "unsupported wiretype: " & $field.wiretype) diff --git a/src/nimpb/wkt/any_pb.nim b/src/nimpb/wkt/any_pb.nim deleted file mode 100644 index aa6f56c..0000000 --- a/src/nimpb/wkt/any_pb.nim +++ /dev/null @@ -1,112 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_Any* = ref google_protobuf_AnyObj - google_protobuf_AnyObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - type_url: string - value: bytes - -proc newgoogle_protobuf_Any*(): google_protobuf_Any -proc newgoogle_protobuf_Any*(data: string): google_protobuf_Any -proc writegoogle_protobuf_Any*(stream: ProtobufStream, message: google_protobuf_Any) -proc readgoogle_protobuf_Any*(stream: ProtobufStream): google_protobuf_Any -proc sizeOfgoogle_protobuf_Any*(message: google_protobuf_Any): uint64 - -proc newgoogle_protobuf_Any*(): google_protobuf_Any = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.type_url = "" - result.value = bytes("") - -proc cleartype_url*(message: google_protobuf_Any) = - message.type_url = "" - excl(message.hasField, [1]) - -proc hastype_url*(message: google_protobuf_Any): bool = - result = contains(message.hasField, 1) - -proc settype_url*(message: google_protobuf_Any, value: string) = - message.type_url = value - incl(message.hasField, 1) - -proc type_url*(message: google_protobuf_Any): string {.inline.} = - message.type_url - -proc `type_url=`*(message: google_protobuf_Any, value: string) {.inline.} = - settype_url(message, value) - -proc clearvalue*(message: google_protobuf_Any) = - message.value = bytes("") - excl(message.hasField, [2]) - -proc hasvalue*(message: google_protobuf_Any): bool = - result = contains(message.hasField, 2) - -proc setvalue*(message: google_protobuf_Any, value: bytes) = - message.value = value - incl(message.hasField, 2) - -proc value*(message: google_protobuf_Any): bytes {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_Any, value: bytes) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_Any*(message: google_protobuf_Any): uint64 = - if hastype_url(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.type_url) - if hasvalue(message): - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfBytes(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Any*(stream: ProtobufStream, message: google_protobuf_Any) = - if hastype_url(message): - writeString(stream, message.type_url, 1) - if hasvalue(message): - writeBytes(stream, message.value, 2) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Any*(stream: ProtobufStream): google_protobuf_Any = - result = newgoogle_protobuf_Any() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - settype_url(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - setvalue(result, readBytes(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Any): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Any(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Any*(data: string): google_protobuf_Any = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Any(pbs) - - diff --git a/src/nimpb/wkt/api_pb.nim b/src/nimpb/wkt/api_pb.nim deleted file mode 100644 index 28f5b2b..0000000 --- a/src/nimpb/wkt/api_pb.nim +++ /dev/null @@ -1,664 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -import nimpb/wkt/source_context_pb -import nimpb/wkt/type_pb - -type - google_protobuf_Api* = ref google_protobuf_ApiObj - google_protobuf_ApiObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - methods: seq[google_protobuf_Method] - options: seq[google_protobuf_Option] - version: string - source_context: google_protobuf_SourceContext - mixins: seq[google_protobuf_Mixin] - syntax: google_protobuf_Syntax - google_protobuf_Method* = ref google_protobuf_MethodObj - google_protobuf_MethodObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - request_type_url: string - request_streaming: bool - response_type_url: string - response_streaming: bool - options: seq[google_protobuf_Option] - syntax: google_protobuf_Syntax - google_protobuf_Mixin* = ref google_protobuf_MixinObj - google_protobuf_MixinObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - root: string - -proc newgoogle_protobuf_Method*(): google_protobuf_Method -proc newgoogle_protobuf_Method*(data: string): google_protobuf_Method -proc writegoogle_protobuf_Method*(stream: ProtobufStream, message: google_protobuf_Method) -proc readgoogle_protobuf_Method*(stream: ProtobufStream): google_protobuf_Method -proc sizeOfgoogle_protobuf_Method*(message: google_protobuf_Method): uint64 -proc toJson*(message: google_protobuf_Method): JsonNode - -proc newgoogle_protobuf_Mixin*(): google_protobuf_Mixin -proc newgoogle_protobuf_Mixin*(data: string): google_protobuf_Mixin -proc writegoogle_protobuf_Mixin*(stream: ProtobufStream, message: google_protobuf_Mixin) -proc readgoogle_protobuf_Mixin*(stream: ProtobufStream): google_protobuf_Mixin -proc sizeOfgoogle_protobuf_Mixin*(message: google_protobuf_Mixin): uint64 -proc toJson*(message: google_protobuf_Mixin): JsonNode - -proc newgoogle_protobuf_Api*(): google_protobuf_Api -proc newgoogle_protobuf_Api*(data: string): google_protobuf_Api -proc writegoogle_protobuf_Api*(stream: ProtobufStream, message: google_protobuf_Api) -proc readgoogle_protobuf_Api*(stream: ProtobufStream): google_protobuf_Api -proc sizeOfgoogle_protobuf_Api*(message: google_protobuf_Api): uint64 -proc toJson*(message: google_protobuf_Api): JsonNode - -proc newgoogle_protobuf_Method*(): google_protobuf_Method = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.request_type_url = "" - result.request_streaming = false - result.response_type_url = "" - result.response_streaming = false - result.options = @[] - result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - -proc clearname*(message: google_protobuf_Method) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_Method, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_Method): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Method, value: string) {.inline.} = - setname(message, value) - -proc clearrequest_type_url*(message: google_protobuf_Method) = - message.request_type_url = "" - excl(message.hasField, [2]) - -proc hasrequest_type_url*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 2) - -proc setrequest_type_url*(message: google_protobuf_Method, value: string) = - message.request_type_url = value - incl(message.hasField, 2) - -proc request_type_url*(message: google_protobuf_Method): string {.inline.} = - message.request_type_url - -proc `request_type_url=`*(message: google_protobuf_Method, value: string) {.inline.} = - setrequest_type_url(message, value) - -proc clearrequest_streaming*(message: google_protobuf_Method) = - message.request_streaming = false - excl(message.hasField, [3]) - -proc hasrequest_streaming*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 3) - -proc setrequest_streaming*(message: google_protobuf_Method, value: bool) = - message.request_streaming = value - incl(message.hasField, 3) - -proc request_streaming*(message: google_protobuf_Method): bool {.inline.} = - message.request_streaming - -proc `request_streaming=`*(message: google_protobuf_Method, value: bool) {.inline.} = - setrequest_streaming(message, value) - -proc clearresponse_type_url*(message: google_protobuf_Method) = - message.response_type_url = "" - excl(message.hasField, [4]) - -proc hasresponse_type_url*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 4) - -proc setresponse_type_url*(message: google_protobuf_Method, value: string) = - message.response_type_url = value - incl(message.hasField, 4) - -proc response_type_url*(message: google_protobuf_Method): string {.inline.} = - message.response_type_url - -proc `response_type_url=`*(message: google_protobuf_Method, value: string) {.inline.} = - setresponse_type_url(message, value) - -proc clearresponse_streaming*(message: google_protobuf_Method) = - message.response_streaming = false - excl(message.hasField, [5]) - -proc hasresponse_streaming*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 5) - -proc setresponse_streaming*(message: google_protobuf_Method, value: bool) = - message.response_streaming = value - incl(message.hasField, 5) - -proc response_streaming*(message: google_protobuf_Method): bool {.inline.} = - message.response_streaming - -proc `response_streaming=`*(message: google_protobuf_Method, value: bool) {.inline.} = - setresponse_streaming(message, value) - -proc clearoptions*(message: google_protobuf_Method) = - message.options = @[] - excl(message.hasField, [6]) - -proc hasoptions*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 6) or (len(message.options) > 0) - -proc setoptions*(message: google_protobuf_Method, value: seq[google_protobuf_Option]) = - message.options = value - incl(message.hasField, 6) - -proc addoptions*(message: google_protobuf_Method, value: google_protobuf_Option) = - add(message.options, value) - incl(message.hasField, 6) - -proc options*(message: google_protobuf_Method): seq[google_protobuf_Option] {.inline.} = - message.options - -proc `options=`*(message: google_protobuf_Method, value: seq[google_protobuf_Option]) {.inline.} = - setoptions(message, value) - -proc clearsyntax*(message: google_protobuf_Method) = - message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - excl(message.hasField, [7]) - -proc hassyntax*(message: google_protobuf_Method): bool = - result = contains(message.hasField, 7) - -proc setsyntax*(message: google_protobuf_Method, value: google_protobuf_Syntax) = - message.syntax = value - incl(message.hasField, 7) - -proc syntax*(message: google_protobuf_Method): google_protobuf_Syntax {.inline.} = - message.syntax - -proc `syntax=`*(message: google_protobuf_Method, value: google_protobuf_Syntax) {.inline.} = - setsyntax(message, value) - -proc sizeOfgoogle_protobuf_Method*(message: google_protobuf_Method): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - if hasrequest_type_url(message): - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfString(message.request_type_url) - if hasrequest_streaming(message): - result = result + sizeOfTag(3, WireType.Varint) - result = result + sizeOfBool(message.request_streaming) - if hasresponse_type_url(message): - result = result + sizeOfTag(4, WireType.LengthDelimited) - result = result + sizeOfString(message.response_type_url) - if hasresponse_streaming(message): - result = result + sizeOfTag(5, WireType.Varint) - result = result + sizeOfBool(message.response_streaming) - for value in message.options: - result = result + sizeOfTag(6, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) - if hassyntax(message): - result = result + sizeOfTag(7, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Method*(stream: ProtobufStream, message: google_protobuf_Method) = - if hasname(message): - writeString(stream, message.name, 1) - if hasrequest_type_url(message): - writeString(stream, message.request_type_url, 2) - if hasrequest_streaming(message): - writeBool(stream, message.request_streaming, 3) - if hasresponse_type_url(message): - writeString(stream, message.response_type_url, 4) - if hasresponse_streaming(message): - writeBool(stream, message.response_streaming, 5) - for value in message.options: - writeMessage(stream, value, 6) - if hassyntax(message): - writeEnum(stream, message.syntax, 7) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Method*(stream: ProtobufStream): google_protobuf_Method = - result = newgoogle_protobuf_Method() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - setrequest_type_url(result, readString(stream)) - of 3: - expectWireType(wireType, WireType.Varint) - setrequest_streaming(result, readBool(stream)) - of 4: - expectWireType(wireType, WireType.LengthDelimited) - setresponse_type_url(result, readString(stream)) - of 5: - expectWireType(wireType, WireType.Varint) - setresponse_streaming(result, readBool(stream)) - of 6: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addoptions(result, newgoogle_protobuf_Option(data)) - of 7: - expectWireType(wireType, WireType.Varint) - setsyntax(result, readEnum[google_protobuf_Syntax](stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Method): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasrequest_type_url(message): - result["requestTypeUrl"] = %message.request_type_url - if hasrequest_streaming(message): - result["requestStreaming"] = %message.request_streaming - if hasresponse_type_url(message): - result["responseTypeUrl"] = %message.response_type_url - if hasresponse_streaming(message): - result["responseStreaming"] = %message.response_streaming - if hasoptions(message): - let arr = newJArray() - for value in message.options: - add(arr, toJson(value)) - result["options"] = arr - if hassyntax(message): - result["syntax"] = %($message.syntax) - -proc serialize*(message: google_protobuf_Method): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Method(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Method*(data: string): google_protobuf_Method = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Method(pbs) - - -proc newgoogle_protobuf_Mixin*(): google_protobuf_Mixin = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.root = "" - -proc clearname*(message: google_protobuf_Mixin) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_Mixin): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_Mixin, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_Mixin): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Mixin, value: string) {.inline.} = - setname(message, value) - -proc clearroot*(message: google_protobuf_Mixin) = - message.root = "" - excl(message.hasField, [2]) - -proc hasroot*(message: google_protobuf_Mixin): bool = - result = contains(message.hasField, 2) - -proc setroot*(message: google_protobuf_Mixin, value: string) = - message.root = value - incl(message.hasField, 2) - -proc root*(message: google_protobuf_Mixin): string {.inline.} = - message.root - -proc `root=`*(message: google_protobuf_Mixin, value: string) {.inline.} = - setroot(message, value) - -proc sizeOfgoogle_protobuf_Mixin*(message: google_protobuf_Mixin): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - if hasroot(message): - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfString(message.root) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Mixin*(stream: ProtobufStream, message: google_protobuf_Mixin) = - if hasname(message): - writeString(stream, message.name, 1) - if hasroot(message): - writeString(stream, message.root, 2) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Mixin*(stream: ProtobufStream): google_protobuf_Mixin = - result = newgoogle_protobuf_Mixin() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - setroot(result, readString(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Mixin): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasroot(message): - result["root"] = %message.root - -proc serialize*(message: google_protobuf_Mixin): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Mixin(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Mixin*(data: string): google_protobuf_Mixin = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Mixin(pbs) - - -proc newgoogle_protobuf_Api*(): google_protobuf_Api = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.methods = @[] - result.options = @[] - result.version = "" - result.source_context = nil - result.mixins = @[] - result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - -proc clearname*(message: google_protobuf_Api) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_Api, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_Api): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Api, value: string) {.inline.} = - setname(message, value) - -proc clearmethods*(message: google_protobuf_Api) = - message.methods = @[] - excl(message.hasField, [2]) - -proc hasmethods*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 2) or (len(message.methods) > 0) - -proc setmethods*(message: google_protobuf_Api, value: seq[google_protobuf_Method]) = - message.methods = value - incl(message.hasField, 2) - -proc addmethods*(message: google_protobuf_Api, value: google_protobuf_Method) = - add(message.methods, value) - incl(message.hasField, 2) - -proc methods*(message: google_protobuf_Api): seq[google_protobuf_Method] {.inline.} = - message.methods - -proc `methods=`*(message: google_protobuf_Api, value: seq[google_protobuf_Method]) {.inline.} = - setmethods(message, value) - -proc clearoptions*(message: google_protobuf_Api) = - message.options = @[] - excl(message.hasField, [3]) - -proc hasoptions*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 3) or (len(message.options) > 0) - -proc setoptions*(message: google_protobuf_Api, value: seq[google_protobuf_Option]) = - message.options = value - incl(message.hasField, 3) - -proc addoptions*(message: google_protobuf_Api, value: google_protobuf_Option) = - add(message.options, value) - incl(message.hasField, 3) - -proc options*(message: google_protobuf_Api): seq[google_protobuf_Option] {.inline.} = - message.options - -proc `options=`*(message: google_protobuf_Api, value: seq[google_protobuf_Option]) {.inline.} = - setoptions(message, value) - -proc clearversion*(message: google_protobuf_Api) = - message.version = "" - excl(message.hasField, [4]) - -proc hasversion*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 4) - -proc setversion*(message: google_protobuf_Api, value: string) = - message.version = value - incl(message.hasField, 4) - -proc version*(message: google_protobuf_Api): string {.inline.} = - message.version - -proc `version=`*(message: google_protobuf_Api, value: string) {.inline.} = - setversion(message, value) - -proc clearsource_context*(message: google_protobuf_Api) = - message.source_context = nil - excl(message.hasField, [5]) - -proc hassource_context*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 5) - -proc setsource_context*(message: google_protobuf_Api, value: google_protobuf_SourceContext) = - message.source_context = value - incl(message.hasField, 5) - -proc source_context*(message: google_protobuf_Api): google_protobuf_SourceContext {.inline.} = - message.source_context - -proc `source_context=`*(message: google_protobuf_Api, value: google_protobuf_SourceContext) {.inline.} = - setsource_context(message, value) - -proc clearmixins*(message: google_protobuf_Api) = - message.mixins = @[] - excl(message.hasField, [6]) - -proc hasmixins*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 6) or (len(message.mixins) > 0) - -proc setmixins*(message: google_protobuf_Api, value: seq[google_protobuf_Mixin]) = - message.mixins = value - incl(message.hasField, 6) - -proc addmixins*(message: google_protobuf_Api, value: google_protobuf_Mixin) = - add(message.mixins, value) - incl(message.hasField, 6) - -proc mixins*(message: google_protobuf_Api): seq[google_protobuf_Mixin] {.inline.} = - message.mixins - -proc `mixins=`*(message: google_protobuf_Api, value: seq[google_protobuf_Mixin]) {.inline.} = - setmixins(message, value) - -proc clearsyntax*(message: google_protobuf_Api) = - message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - excl(message.hasField, [7]) - -proc hassyntax*(message: google_protobuf_Api): bool = - result = contains(message.hasField, 7) - -proc setsyntax*(message: google_protobuf_Api, value: google_protobuf_Syntax) = - message.syntax = value - incl(message.hasField, 7) - -proc syntax*(message: google_protobuf_Api): google_protobuf_Syntax {.inline.} = - message.syntax - -proc `syntax=`*(message: google_protobuf_Api, value: google_protobuf_Syntax) {.inline.} = - setsyntax(message, value) - -proc sizeOfgoogle_protobuf_Api*(message: google_protobuf_Api): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - for value in message.methods: - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Method(value)) - for value in message.options: - result = result + sizeOfTag(3, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) - if hasversion(message): - result = result + sizeOfTag(4, WireType.LengthDelimited) - result = result + sizeOfString(message.version) - if hassource_context(message): - result = result + sizeOfTag(5, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context)) - for value in message.mixins: - result = result + sizeOfTag(6, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Mixin(value)) - if hassyntax(message): - result = result + sizeOfTag(7, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Api*(stream: ProtobufStream, message: google_protobuf_Api) = - if hasname(message): - writeString(stream, message.name, 1) - for value in message.methods: - writeMessage(stream, value, 2) - for value in message.options: - writeMessage(stream, value, 3) - if hasversion(message): - writeString(stream, message.version, 4) - if hassource_context(message): - writeMessage(stream, message.source_context, 5) - for value in message.mixins: - writeMessage(stream, value, 6) - if hassyntax(message): - writeEnum(stream, message.syntax, 7) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Api*(stream: ProtobufStream): google_protobuf_Api = - result = newgoogle_protobuf_Api() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addmethods(result, newgoogle_protobuf_Method(data)) - of 3: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addoptions(result, newgoogle_protobuf_Option(data)) - of 4: - expectWireType(wireType, WireType.LengthDelimited) - setversion(result, readString(stream)) - of 5: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - setsource_context(result, newgoogle_protobuf_SourceContext(data)) - of 6: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addmixins(result, newgoogle_protobuf_Mixin(data)) - of 7: - expectWireType(wireType, WireType.Varint) - setsyntax(result, readEnum[google_protobuf_Syntax](stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Api): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasmethods(message): - let arr = newJArray() - for value in message.methods: - add(arr, toJson(value)) - result["methods"] = arr - if hasoptions(message): - let arr = newJArray() - for value in message.options: - add(arr, toJson(value)) - result["options"] = arr - if hasversion(message): - result["version"] = %message.version - if hassource_context(message): - result["sourceContext"] = toJson(message.source_context) - if hasmixins(message): - let arr = newJArray() - for value in message.mixins: - add(arr, toJson(value)) - result["mixins"] = arr - if hassyntax(message): - result["syntax"] = %($message.syntax) - -proc serialize*(message: google_protobuf_Api): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Api(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Api*(data: string): google_protobuf_Api = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Api(pbs) - - diff --git a/src/nimpb/wkt/duration_pb.nim b/src/nimpb/wkt/duration_pb.nim deleted file mode 100644 index d15aeee..0000000 --- a/src/nimpb/wkt/duration_pb.nim +++ /dev/null @@ -1,112 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_Duration* = ref google_protobuf_DurationObj - google_protobuf_DurationObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - seconds: int64 - nanos: int32 - -proc newgoogle_protobuf_Duration*(): google_protobuf_Duration -proc newgoogle_protobuf_Duration*(data: string): google_protobuf_Duration -proc writegoogle_protobuf_Duration*(stream: ProtobufStream, message: google_protobuf_Duration) -proc readgoogle_protobuf_Duration*(stream: ProtobufStream): google_protobuf_Duration -proc sizeOfgoogle_protobuf_Duration*(message: google_protobuf_Duration): uint64 - -proc newgoogle_protobuf_Duration*(): google_protobuf_Duration = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.seconds = 0 - result.nanos = 0 - -proc clearseconds*(message: google_protobuf_Duration) = - message.seconds = 0 - excl(message.hasField, [1]) - -proc hasseconds*(message: google_protobuf_Duration): bool = - result = contains(message.hasField, 1) - -proc setseconds*(message: google_protobuf_Duration, value: int64) = - message.seconds = value - incl(message.hasField, 1) - -proc seconds*(message: google_protobuf_Duration): int64 {.inline.} = - message.seconds - -proc `seconds=`*(message: google_protobuf_Duration, value: int64) {.inline.} = - setseconds(message, value) - -proc clearnanos*(message: google_protobuf_Duration) = - message.nanos = 0 - excl(message.hasField, [2]) - -proc hasnanos*(message: google_protobuf_Duration): bool = - result = contains(message.hasField, 2) - -proc setnanos*(message: google_protobuf_Duration, value: int32) = - message.nanos = value - incl(message.hasField, 2) - -proc nanos*(message: google_protobuf_Duration): int32 {.inline.} = - message.nanos - -proc `nanos=`*(message: google_protobuf_Duration, value: int32) {.inline.} = - setnanos(message, value) - -proc sizeOfgoogle_protobuf_Duration*(message: google_protobuf_Duration): uint64 = - if hasseconds(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfInt64(message.seconds) - if hasnanos(message): - result = result + sizeOfTag(2, WireType.Varint) - result = result + sizeOfInt32(message.nanos) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Duration*(stream: ProtobufStream, message: google_protobuf_Duration) = - if hasseconds(message): - writeInt64(stream, message.seconds, 1) - if hasnanos(message): - writeInt32(stream, message.nanos, 2) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Duration*(stream: ProtobufStream): google_protobuf_Duration = - result = newgoogle_protobuf_Duration() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setseconds(result, readInt64(stream)) - of 2: - expectWireType(wireType, WireType.Varint) - setnanos(result, readInt32(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Duration): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Duration(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Duration*(data: string): google_protobuf_Duration = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Duration(pbs) - - diff --git a/src/nimpb/wkt/empty_pb.nim b/src/nimpb/wkt/empty_pb.nim deleted file mode 100644 index c53cb03..0000000 --- a/src/nimpb/wkt/empty_pb.nim +++ /dev/null @@ -1,62 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_Empty* = ref google_protobuf_EmptyObj - google_protobuf_EmptyObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - -proc newgoogle_protobuf_Empty*(): google_protobuf_Empty -proc newgoogle_protobuf_Empty*(data: string): google_protobuf_Empty -proc writegoogle_protobuf_Empty*(stream: ProtobufStream, message: google_protobuf_Empty) -proc readgoogle_protobuf_Empty*(stream: ProtobufStream): google_protobuf_Empty -proc sizeOfgoogle_protobuf_Empty*(message: google_protobuf_Empty): uint64 -proc toJson*(message: google_protobuf_Empty): JsonNode - -proc newgoogle_protobuf_Empty*(): google_protobuf_Empty = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - -proc sizeOfgoogle_protobuf_Empty*(message: google_protobuf_Empty): uint64 = - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Empty*(stream: ProtobufStream, message: google_protobuf_Empty) = - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Empty*(stream: ProtobufStream): google_protobuf_Empty = - result = newgoogle_protobuf_Empty() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Empty): JsonNode = - result = newJObject() - -proc serialize*(message: google_protobuf_Empty): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Empty(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Empty*(data: string): google_protobuf_Empty = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Empty(pbs) - - diff --git a/src/nimpb/wkt/field_mask_pb.nim b/src/nimpb/wkt/field_mask_pb.nim deleted file mode 100644 index e925416..0000000 --- a/src/nimpb/wkt/field_mask_pb.nim +++ /dev/null @@ -1,89 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_FieldMask* = ref google_protobuf_FieldMaskObj - google_protobuf_FieldMaskObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - paths: seq[string] - -proc newgoogle_protobuf_FieldMask*(): google_protobuf_FieldMask -proc newgoogle_protobuf_FieldMask*(data: string): google_protobuf_FieldMask -proc writegoogle_protobuf_FieldMask*(stream: ProtobufStream, message: google_protobuf_FieldMask) -proc readgoogle_protobuf_FieldMask*(stream: ProtobufStream): google_protobuf_FieldMask -proc sizeOfgoogle_protobuf_FieldMask*(message: google_protobuf_FieldMask): uint64 - -proc newgoogle_protobuf_FieldMask*(): google_protobuf_FieldMask = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.paths = @[] - -proc clearpaths*(message: google_protobuf_FieldMask) = - message.paths = @[] - excl(message.hasField, [1]) - -proc haspaths*(message: google_protobuf_FieldMask): bool = - result = contains(message.hasField, 1) or (len(message.paths) > 0) - -proc setpaths*(message: google_protobuf_FieldMask, value: seq[string]) = - message.paths = value - incl(message.hasField, 1) - -proc addpaths*(message: google_protobuf_FieldMask, value: string) = - add(message.paths, value) - incl(message.hasField, 1) - -proc paths*(message: google_protobuf_FieldMask): seq[string] {.inline.} = - message.paths - -proc `paths=`*(message: google_protobuf_FieldMask, value: seq[string]) {.inline.} = - setpaths(message, value) - -proc sizeOfgoogle_protobuf_FieldMask*(message: google_protobuf_FieldMask): uint64 = - for value in message.paths: - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_FieldMask*(stream: ProtobufStream, message: google_protobuf_FieldMask) = - for value in message.paths: - writeString(stream, value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_FieldMask*(stream: ProtobufStream): google_protobuf_FieldMask = - result = newgoogle_protobuf_FieldMask() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - addpaths(result, readString(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_FieldMask): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_FieldMask(pbs, message) - result = ss.data - -proc newgoogle_protobuf_FieldMask*(data: string): google_protobuf_FieldMask = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_FieldMask(pbs) - - diff --git a/src/nimpb/wkt/source_context_pb.nim b/src/nimpb/wkt/source_context_pb.nim deleted file mode 100644 index 815da98..0000000 --- a/src/nimpb/wkt/source_context_pb.nim +++ /dev/null @@ -1,91 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_SourceContext* = ref google_protobuf_SourceContextObj - google_protobuf_SourceContextObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - file_name: string - -proc newgoogle_protobuf_SourceContext*(): google_protobuf_SourceContext -proc newgoogle_protobuf_SourceContext*(data: string): google_protobuf_SourceContext -proc writegoogle_protobuf_SourceContext*(stream: ProtobufStream, message: google_protobuf_SourceContext) -proc readgoogle_protobuf_SourceContext*(stream: ProtobufStream): google_protobuf_SourceContext -proc sizeOfgoogle_protobuf_SourceContext*(message: google_protobuf_SourceContext): uint64 -proc toJson*(message: google_protobuf_SourceContext): JsonNode - -proc newgoogle_protobuf_SourceContext*(): google_protobuf_SourceContext = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.file_name = "" - -proc clearfile_name*(message: google_protobuf_SourceContext) = - message.file_name = "" - excl(message.hasField, [1]) - -proc hasfile_name*(message: google_protobuf_SourceContext): bool = - result = contains(message.hasField, 1) - -proc setfile_name*(message: google_protobuf_SourceContext, value: string) = - message.file_name = value - incl(message.hasField, 1) - -proc file_name*(message: google_protobuf_SourceContext): string {.inline.} = - message.file_name - -proc `file_name=`*(message: google_protobuf_SourceContext, value: string) {.inline.} = - setfile_name(message, value) - -proc sizeOfgoogle_protobuf_SourceContext*(message: google_protobuf_SourceContext): uint64 = - if hasfile_name(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.file_name) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_SourceContext*(stream: ProtobufStream, message: google_protobuf_SourceContext) = - if hasfile_name(message): - writeString(stream, message.file_name, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_SourceContext*(stream: ProtobufStream): google_protobuf_SourceContext = - result = newgoogle_protobuf_SourceContext() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setfile_name(result, readString(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_SourceContext): JsonNode = - result = newJObject() - if hasfile_name(message): - result["fileName"] = %message.file_name - -proc serialize*(message: google_protobuf_SourceContext): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_SourceContext(pbs, message) - result = ss.data - -proc newgoogle_protobuf_SourceContext*(data: string): google_protobuf_SourceContext = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_SourceContext(pbs) - - diff --git a/src/nimpb/wkt/struct_pb.nim b/src/nimpb/wkt/struct_pb.nim deleted file mode 100644 index 2a38f6d..0000000 --- a/src/nimpb/wkt/struct_pb.nim +++ /dev/null @@ -1,440 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json -import tables -export tables - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_NullValue* {.pure.} = enum - NULL_VALUE = 0 - google_protobuf_Struct* = ref google_protobuf_StructObj - google_protobuf_StructObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - fields: TableRef[string, google_protobuf_Value] - google_protobuf_Value* = ref google_protobuf_ValueObj - google_protobuf_ValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - kind: google_protobuf_Value_kind_OneOf - - google_protobuf_Value_kind_OneOf* {.union.} = object - null_value: google_protobuf_NullValue - number_value: float64 - string_value: string - bool_value: bool - struct_value: google_protobuf_Struct - list_value: google_protobuf_ListValue - google_protobuf_ListValue* = ref google_protobuf_ListValueObj - google_protobuf_ListValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - values: seq[google_protobuf_Value] - -proc writegoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, key: string, value: google_protobuf_Value) -proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: TableRef[string, google_protobuf_Value]) -proc sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key: string, value: google_protobuf_Value): uint64 - -proc newgoogle_protobuf_Struct*(): google_protobuf_Struct -proc newgoogle_protobuf_Struct*(data: string): google_protobuf_Struct -proc writegoogle_protobuf_Struct*(stream: ProtobufStream, message: google_protobuf_Struct) -proc readgoogle_protobuf_Struct*(stream: ProtobufStream): google_protobuf_Struct -proc sizeOfgoogle_protobuf_Struct*(message: google_protobuf_Struct): uint64 - -proc newgoogle_protobuf_ListValue*(): google_protobuf_ListValue -proc newgoogle_protobuf_ListValue*(data: string): google_protobuf_ListValue -proc writegoogle_protobuf_ListValue*(stream: ProtobufStream, message: google_protobuf_ListValue) -proc readgoogle_protobuf_ListValue*(stream: ProtobufStream): google_protobuf_ListValue -proc sizeOfgoogle_protobuf_ListValue*(message: google_protobuf_ListValue): uint64 - -proc newgoogle_protobuf_Value*(): google_protobuf_Value -proc newgoogle_protobuf_Value*(data: string): google_protobuf_Value -proc writegoogle_protobuf_Value*(stream: ProtobufStream, message: google_protobuf_Value) -proc readgoogle_protobuf_Value*(stream: ProtobufStream): google_protobuf_Value -proc sizeOfgoogle_protobuf_Value*(message: google_protobuf_Value): uint64 - -proc sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key: string, value: google_protobuf_Value): uint64 = - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(key) - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Value(value)) - -proc writegoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, key: string, value: google_protobuf_Value) = - writeString(stream, key, 1) - writeMessage(stream, value, 2) - -proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: TableRef[string, google_protobuf_Value]) = - var - key: string - gotKey = false - value: google_protobuf_Value - gotValue = false - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 1: - key = readString(stream) - gotKey = true - of 2: - let - size = readVarint(stream) - data = safeReadStr(stream, int(size)) - pbs = newProtobufStream(newStringStream(data)) - value = readgoogle_protobuf_Value(pbs) - gotValue = true - else: skipField(stream, wireType) - if not gotKey: - raise newException(Exception, "missing key") - if not gotValue: - raise newException(Exception, "missing value") - tbl[key] = value - - -proc newgoogle_protobuf_Struct*(): google_protobuf_Struct = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.fields = newTable[string, google_protobuf_Value]() - -proc clearfields*(message: google_protobuf_Struct) = - message.fields = newTable[string, google_protobuf_Value]() - excl(message.hasField, [1]) - -proc hasfields*(message: google_protobuf_Struct): bool = - result = contains(message.hasField, 1) or (len(message.fields) > 0) - -proc setfields*(message: google_protobuf_Struct, value: TableRef[string, google_protobuf_Value]) = - message.fields = value - incl(message.hasField, 1) - -proc fields*(message: google_protobuf_Struct): TableRef[string, google_protobuf_Value] {.inline.} = - message.fields - -proc `fields=`*(message: google_protobuf_Struct, value: TableRef[string, google_protobuf_Value]) {.inline.} = - setfields(message, value) - -proc sizeOfgoogle_protobuf_Struct*(message: google_protobuf_Struct): uint64 = - if hasfields(message): - var sizeOfKV = 0'u64 - for key, value in message.fields: - sizeOfKV = sizeOfKV + sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key, value) - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfKV) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Struct*(stream: ProtobufStream, message: google_protobuf_Struct) = - for key, value in message.fields: - writeTag(stream, 1, WireType.LengthDelimited) - writeVarint(stream, sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key, value)) - writegoogle_protobuf_Struct_FieldsEntryKV(stream, key, value) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Struct*(stream: ProtobufStream): google_protobuf_Struct = - result = newgoogle_protobuf_Struct() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - let - size = readVarint(stream) - data = safeReadStr(stream, int(size)) - pbs = newProtobufStream(newStringStream(data)) - readgoogle_protobuf_Struct_FieldsEntryKV(pbs, result.fields) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Struct): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Struct(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Struct*(data: string): google_protobuf_Struct = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Struct(pbs) - - -proc newgoogle_protobuf_ListValue*(): google_protobuf_ListValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.values = @[] - -proc clearvalues*(message: google_protobuf_ListValue) = - message.values = @[] - excl(message.hasField, [1]) - -proc hasvalues*(message: google_protobuf_ListValue): bool = - result = contains(message.hasField, 1) or (len(message.values) > 0) - -proc setvalues*(message: google_protobuf_ListValue, value: seq[google_protobuf_Value]) = - message.values = value - incl(message.hasField, 1) - -proc addvalues*(message: google_protobuf_ListValue, value: google_protobuf_Value) = - add(message.values, value) - incl(message.hasField, 1) - -proc values*(message: google_protobuf_ListValue): seq[google_protobuf_Value] {.inline.} = - message.values - -proc `values=`*(message: google_protobuf_ListValue, value: seq[google_protobuf_Value]) {.inline.} = - setvalues(message, value) - -proc sizeOfgoogle_protobuf_ListValue*(message: google_protobuf_ListValue): uint64 = - for value in message.values: - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Value(value)) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_ListValue*(stream: ProtobufStream, message: google_protobuf_ListValue) = - for value in message.values: - writeMessage(stream, value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_ListValue*(stream: ProtobufStream): google_protobuf_ListValue = - result = newgoogle_protobuf_ListValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addvalues(result, newgoogle_protobuf_Value(data)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_ListValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_ListValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_ListValue*(data: string): google_protobuf_ListValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_ListValue(pbs) - - -proc newgoogle_protobuf_Value*(): google_protobuf_Value = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.kind.null_value = google_protobuf_NullValue.NULL_VALUE - result.kind.number_value = 0 - result.kind.string_value = "" - result.kind.bool_value = false - result.kind.struct_value = nil - result.kind.list_value = nil - -proc clearnull_value*(message: google_protobuf_Value) = - message.kind.null_value = google_protobuf_NullValue.NULL_VALUE - excl(message.hasField, [1, 2, 3, 4, 5, 6]) - -proc hasnull_value*(message: google_protobuf_Value): bool = - result = contains(message.hasField, 1) - -proc setnull_value*(message: google_protobuf_Value, value: google_protobuf_NullValue) = - message.kind.null_value = value - incl(message.hasField, 1) - excl(message.hasField, [2, 3, 4, 5, 6]) - -proc null_value*(message: google_protobuf_Value): google_protobuf_NullValue {.inline.} = - message.kind.null_value - -proc `null_value=`*(message: google_protobuf_Value, value: google_protobuf_NullValue) {.inline.} = - setnull_value(message, value) - -proc clearnumber_value*(message: google_protobuf_Value) = - message.kind.number_value = 0 - excl(message.hasField, [2, 1, 3, 4, 5, 6]) - -proc hasnumber_value*(message: google_protobuf_Value): bool = - result = contains(message.hasField, 2) - -proc setnumber_value*(message: google_protobuf_Value, value: float64) = - message.kind.number_value = value - incl(message.hasField, 2) - excl(message.hasField, [1, 3, 4, 5, 6]) - -proc number_value*(message: google_protobuf_Value): float64 {.inline.} = - message.kind.number_value - -proc `number_value=`*(message: google_protobuf_Value, value: float64) {.inline.} = - setnumber_value(message, value) - -proc clearstring_value*(message: google_protobuf_Value) = - message.kind.string_value = "" - excl(message.hasField, [3, 1, 2, 4, 5, 6]) - -proc hasstring_value*(message: google_protobuf_Value): bool = - result = contains(message.hasField, 3) - -proc setstring_value*(message: google_protobuf_Value, value: string) = - message.kind.string_value = value - incl(message.hasField, 3) - excl(message.hasField, [1, 2, 4, 5, 6]) - -proc string_value*(message: google_protobuf_Value): string {.inline.} = - message.kind.string_value - -proc `string_value=`*(message: google_protobuf_Value, value: string) {.inline.} = - setstring_value(message, value) - -proc clearbool_value*(message: google_protobuf_Value) = - message.kind.bool_value = false - excl(message.hasField, [4, 1, 2, 3, 5, 6]) - -proc hasbool_value*(message: google_protobuf_Value): bool = - result = contains(message.hasField, 4) - -proc setbool_value*(message: google_protobuf_Value, value: bool) = - message.kind.bool_value = value - incl(message.hasField, 4) - excl(message.hasField, [1, 2, 3, 5, 6]) - -proc bool_value*(message: google_protobuf_Value): bool {.inline.} = - message.kind.bool_value - -proc `bool_value=`*(message: google_protobuf_Value, value: bool) {.inline.} = - setbool_value(message, value) - -proc clearstruct_value*(message: google_protobuf_Value) = - message.kind.struct_value = nil - excl(message.hasField, [5, 1, 2, 3, 4, 6]) - -proc hasstruct_value*(message: google_protobuf_Value): bool = - result = contains(message.hasField, 5) - -proc setstruct_value*(message: google_protobuf_Value, value: google_protobuf_Struct) = - message.kind.struct_value = value - incl(message.hasField, 5) - excl(message.hasField, [1, 2, 3, 4, 6]) - -proc struct_value*(message: google_protobuf_Value): google_protobuf_Struct {.inline.} = - message.kind.struct_value - -proc `struct_value=`*(message: google_protobuf_Value, value: google_protobuf_Struct) {.inline.} = - setstruct_value(message, value) - -proc clearlist_value*(message: google_protobuf_Value) = - message.kind.list_value = nil - excl(message.hasField, [6, 1, 2, 3, 4, 5]) - -proc haslist_value*(message: google_protobuf_Value): bool = - result = contains(message.hasField, 6) - -proc setlist_value*(message: google_protobuf_Value, value: google_protobuf_ListValue) = - message.kind.list_value = value - incl(message.hasField, 6) - excl(message.hasField, [1, 2, 3, 4, 5]) - -proc list_value*(message: google_protobuf_Value): google_protobuf_ListValue {.inline.} = - message.kind.list_value - -proc `list_value=`*(message: google_protobuf_Value, value: google_protobuf_ListValue) {.inline.} = - setlist_value(message, value) - -proc sizeOfgoogle_protobuf_Value*(message: google_protobuf_Value): uint64 = - if hasnull_value(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_NullValue](message.kind.null_value) - if hasnumber_value(message): - result = result + sizeOfTag(2, WireType.Fixed64) - result = result + sizeOfDouble(message.kind.number_value) - if hasstring_value(message): - result = result + sizeOfTag(3, WireType.LengthDelimited) - result = result + sizeOfString(message.kind.string_value) - if hasbool_value(message): - result = result + sizeOfTag(4, WireType.Varint) - result = result + sizeOfBool(message.kind.bool_value) - if hasstruct_value(message): - result = result + sizeOfTag(5, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Struct(message.kind.struct_value)) - if haslist_value(message): - result = result + sizeOfTag(6, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_ListValue(message.kind.list_value)) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Value*(stream: ProtobufStream, message: google_protobuf_Value) = - if hasnull_value(message): - writeEnum(stream, message.kind.null_value, 1) - if hasnumber_value(message): - writeDouble(stream, message.kind.number_value, 2) - if hasstring_value(message): - writeString(stream, message.kind.string_value, 3) - if hasbool_value(message): - writeBool(stream, message.kind.bool_value, 4) - if hasstruct_value(message): - writeMessage(stream, message.kind.struct_value, 5) - if haslist_value(message): - writeMessage(stream, message.kind.list_value, 6) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Value*(stream: ProtobufStream): google_protobuf_Value = - result = newgoogle_protobuf_Value() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setnull_value(result, readEnum[google_protobuf_NullValue](stream)) - of 2: - expectWireType(wireType, WireType.Fixed64) - setnumber_value(result, readDouble(stream)) - of 3: - expectWireType(wireType, WireType.LengthDelimited) - setstring_value(result, readString(stream)) - of 4: - expectWireType(wireType, WireType.Varint) - setbool_value(result, readBool(stream)) - of 5: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - setstruct_value(result, newgoogle_protobuf_Struct(data)) - of 6: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - setlist_value(result, newgoogle_protobuf_ListValue(data)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Value): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Value(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Value*(data: string): google_protobuf_Value = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Value(pbs) - - diff --git a/src/nimpb/wkt/timestamp_pb.nim b/src/nimpb/wkt/timestamp_pb.nim deleted file mode 100644 index 5f00154..0000000 --- a/src/nimpb/wkt/timestamp_pb.nim +++ /dev/null @@ -1,112 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_Timestamp* = ref google_protobuf_TimestampObj - google_protobuf_TimestampObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - seconds: int64 - nanos: int32 - -proc newgoogle_protobuf_Timestamp*(): google_protobuf_Timestamp -proc newgoogle_protobuf_Timestamp*(data: string): google_protobuf_Timestamp -proc writegoogle_protobuf_Timestamp*(stream: ProtobufStream, message: google_protobuf_Timestamp) -proc readgoogle_protobuf_Timestamp*(stream: ProtobufStream): google_protobuf_Timestamp -proc sizeOfgoogle_protobuf_Timestamp*(message: google_protobuf_Timestamp): uint64 - -proc newgoogle_protobuf_Timestamp*(): google_protobuf_Timestamp = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.seconds = 0 - result.nanos = 0 - -proc clearseconds*(message: google_protobuf_Timestamp) = - message.seconds = 0 - excl(message.hasField, [1]) - -proc hasseconds*(message: google_protobuf_Timestamp): bool = - result = contains(message.hasField, 1) - -proc setseconds*(message: google_protobuf_Timestamp, value: int64) = - message.seconds = value - incl(message.hasField, 1) - -proc seconds*(message: google_protobuf_Timestamp): int64 {.inline.} = - message.seconds - -proc `seconds=`*(message: google_protobuf_Timestamp, value: int64) {.inline.} = - setseconds(message, value) - -proc clearnanos*(message: google_protobuf_Timestamp) = - message.nanos = 0 - excl(message.hasField, [2]) - -proc hasnanos*(message: google_protobuf_Timestamp): bool = - result = contains(message.hasField, 2) - -proc setnanos*(message: google_protobuf_Timestamp, value: int32) = - message.nanos = value - incl(message.hasField, 2) - -proc nanos*(message: google_protobuf_Timestamp): int32 {.inline.} = - message.nanos - -proc `nanos=`*(message: google_protobuf_Timestamp, value: int32) {.inline.} = - setnanos(message, value) - -proc sizeOfgoogle_protobuf_Timestamp*(message: google_protobuf_Timestamp): uint64 = - if hasseconds(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfInt64(message.seconds) - if hasnanos(message): - result = result + sizeOfTag(2, WireType.Varint) - result = result + sizeOfInt32(message.nanos) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Timestamp*(stream: ProtobufStream, message: google_protobuf_Timestamp) = - if hasseconds(message): - writeInt64(stream, message.seconds, 1) - if hasnanos(message): - writeInt32(stream, message.nanos, 2) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Timestamp*(stream: ProtobufStream): google_protobuf_Timestamp = - result = newgoogle_protobuf_Timestamp() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setseconds(result, readInt64(stream)) - of 2: - expectWireType(wireType, WireType.Varint) - setnanos(result, readInt32(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Timestamp): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Timestamp(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Timestamp*(data: string): google_protobuf_Timestamp = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Timestamp(pbs) - - diff --git a/src/nimpb/wkt/type_pb.nim b/src/nimpb/wkt/type_pb.nim deleted file mode 100644 index efb7d26..0000000 --- a/src/nimpb/wkt/type_pb.nim +++ /dev/null @@ -1,1109 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -import nimpb/wkt/any_pb -import nimpb/wkt/source_context_pb - -type - google_protobuf_Syntax* {.pure.} = enum - SYNTAX_PROTO2 = 0 - SYNTAX_PROTO3 = 1 - google_protobuf_Field_Kind* {.pure.} = enum - TYPE_UNKNOWN = 0 - TYPE_DOUBLE = 1 - TYPE_FLOAT = 2 - TYPE_INT64 = 3 - TYPE_UINT64 = 4 - TYPE_INT32 = 5 - TYPE_FIXED64 = 6 - TYPE_FIXED32 = 7 - TYPE_BOOL = 8 - TYPE_STRING = 9 - TYPE_GROUP = 10 - TYPE_MESSAGE = 11 - TYPE_BYTES = 12 - TYPE_UINT32 = 13 - TYPE_ENUM = 14 - TYPE_SFIXED32 = 15 - TYPE_SFIXED64 = 16 - TYPE_SINT32 = 17 - TYPE_SINT64 = 18 - google_protobuf_Field_Cardinality* {.pure.} = enum - CARDINALITY_UNKNOWN = 0 - CARDINALITY_OPTIONAL = 1 - CARDINALITY_REQUIRED = 2 - CARDINALITY_REPEATED = 3 - google_protobuf_Type* = ref google_protobuf_TypeObj - google_protobuf_TypeObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - fields: seq[google_protobuf_Field] - oneofs: seq[string] - options: seq[google_protobuf_Option] - source_context: google_protobuf_SourceContext - syntax: google_protobuf_Syntax - google_protobuf_Field* = ref google_protobuf_FieldObj - google_protobuf_FieldObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - kind: google_protobuf_Field_Kind - cardinality: google_protobuf_Field_Cardinality - number: int32 - name: string - type_url: string - oneof_index: int32 - packed: bool - options: seq[google_protobuf_Option] - json_name: string - default_value: string - google_protobuf_Enum* = ref google_protobuf_EnumObj - google_protobuf_EnumObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - enumvalue: seq[google_protobuf_EnumValue] - options: seq[google_protobuf_Option] - source_context: google_protobuf_SourceContext - syntax: google_protobuf_Syntax - google_protobuf_EnumValue* = ref google_protobuf_EnumValueObj - google_protobuf_EnumValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - number: int32 - options: seq[google_protobuf_Option] - google_protobuf_Option* = ref google_protobuf_OptionObj - google_protobuf_OptionObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - name: string - value: google_protobuf_Any - -proc newgoogle_protobuf_Option*(): google_protobuf_Option -proc newgoogle_protobuf_Option*(data: string): google_protobuf_Option -proc writegoogle_protobuf_Option*(stream: ProtobufStream, message: google_protobuf_Option) -proc readgoogle_protobuf_Option*(stream: ProtobufStream): google_protobuf_Option -proc sizeOfgoogle_protobuf_Option*(message: google_protobuf_Option): uint64 -proc toJson*(message: google_protobuf_Option): JsonNode - -proc newgoogle_protobuf_Field*(): google_protobuf_Field -proc newgoogle_protobuf_Field*(data: string): google_protobuf_Field -proc writegoogle_protobuf_Field*(stream: ProtobufStream, message: google_protobuf_Field) -proc readgoogle_protobuf_Field*(stream: ProtobufStream): google_protobuf_Field -proc sizeOfgoogle_protobuf_Field*(message: google_protobuf_Field): uint64 -proc toJson*(message: google_protobuf_Field): JsonNode - -proc newgoogle_protobuf_Type*(): google_protobuf_Type -proc newgoogle_protobuf_Type*(data: string): google_protobuf_Type -proc writegoogle_protobuf_Type*(stream: ProtobufStream, message: google_protobuf_Type) -proc readgoogle_protobuf_Type*(stream: ProtobufStream): google_protobuf_Type -proc sizeOfgoogle_protobuf_Type*(message: google_protobuf_Type): uint64 -proc toJson*(message: google_protobuf_Type): JsonNode - -proc newgoogle_protobuf_EnumValue*(): google_protobuf_EnumValue -proc newgoogle_protobuf_EnumValue*(data: string): google_protobuf_EnumValue -proc writegoogle_protobuf_EnumValue*(stream: ProtobufStream, message: google_protobuf_EnumValue) -proc readgoogle_protobuf_EnumValue*(stream: ProtobufStream): google_protobuf_EnumValue -proc sizeOfgoogle_protobuf_EnumValue*(message: google_protobuf_EnumValue): uint64 -proc toJson*(message: google_protobuf_EnumValue): JsonNode - -proc newgoogle_protobuf_Enum*(): google_protobuf_Enum -proc newgoogle_protobuf_Enum*(data: string): google_protobuf_Enum -proc writegoogle_protobuf_Enum*(stream: ProtobufStream, message: google_protobuf_Enum) -proc readgoogle_protobuf_Enum*(stream: ProtobufStream): google_protobuf_Enum -proc sizeOfgoogle_protobuf_Enum*(message: google_protobuf_Enum): uint64 -proc toJson*(message: google_protobuf_Enum): JsonNode - -proc newgoogle_protobuf_Option*(): google_protobuf_Option = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.value = nil - -proc clearname*(message: google_protobuf_Option) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_Option): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_Option, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_Option): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Option, value: string) {.inline.} = - setname(message, value) - -proc clearvalue*(message: google_protobuf_Option) = - message.value = nil - excl(message.hasField, [2]) - -proc hasvalue*(message: google_protobuf_Option): bool = - result = contains(message.hasField, 2) - -proc setvalue*(message: google_protobuf_Option, value: google_protobuf_Any) = - message.value = value - incl(message.hasField, 2) - -proc value*(message: google_protobuf_Option): google_protobuf_Any {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_Option, value: google_protobuf_Any) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_Option*(message: google_protobuf_Option): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - if hasvalue(message): - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Any(message.value)) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Option*(stream: ProtobufStream, message: google_protobuf_Option) = - if hasname(message): - writeString(stream, message.name, 1) - if hasvalue(message): - writeMessage(stream, message.value, 2) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Option*(stream: ProtobufStream): google_protobuf_Option = - result = newgoogle_protobuf_Option() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - setvalue(result, newgoogle_protobuf_Any(data)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Option): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasvalue(message): - result["value"] = toJson(message.value) - -proc serialize*(message: google_protobuf_Option): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Option(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Option*(data: string): google_protobuf_Option = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Option(pbs) - - -proc newgoogle_protobuf_Field*(): google_protobuf_Field = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.kind = google_protobuf_Field_Kind.TYPE_UNKNOWN - result.cardinality = google_protobuf_Field_Cardinality.CARDINALITY_UNKNOWN - result.number = 0 - result.name = "" - result.type_url = "" - result.oneof_index = 0 - result.packed = false - result.options = @[] - result.json_name = "" - result.default_value = "" - -proc clearkind*(message: google_protobuf_Field) = - message.kind = google_protobuf_Field_Kind.TYPE_UNKNOWN - excl(message.hasField, [1]) - -proc haskind*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 1) - -proc setkind*(message: google_protobuf_Field, value: google_protobuf_Field_Kind) = - message.kind = value - incl(message.hasField, 1) - -proc kind*(message: google_protobuf_Field): google_protobuf_Field_Kind {.inline.} = - message.kind - -proc `kind=`*(message: google_protobuf_Field, value: google_protobuf_Field_Kind) {.inline.} = - setkind(message, value) - -proc clearcardinality*(message: google_protobuf_Field) = - message.cardinality = google_protobuf_Field_Cardinality.CARDINALITY_UNKNOWN - excl(message.hasField, [2]) - -proc hascardinality*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 2) - -proc setcardinality*(message: google_protobuf_Field, value: google_protobuf_Field_Cardinality) = - message.cardinality = value - incl(message.hasField, 2) - -proc cardinality*(message: google_protobuf_Field): google_protobuf_Field_Cardinality {.inline.} = - message.cardinality - -proc `cardinality=`*(message: google_protobuf_Field, value: google_protobuf_Field_Cardinality) {.inline.} = - setcardinality(message, value) - -proc clearnumber*(message: google_protobuf_Field) = - message.number = 0 - excl(message.hasField, [3]) - -proc hasnumber*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 3) - -proc setnumber*(message: google_protobuf_Field, value: int32) = - message.number = value - incl(message.hasField, 3) - -proc number*(message: google_protobuf_Field): int32 {.inline.} = - message.number - -proc `number=`*(message: google_protobuf_Field, value: int32) {.inline.} = - setnumber(message, value) - -proc clearname*(message: google_protobuf_Field) = - message.name = "" - excl(message.hasField, [4]) - -proc hasname*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 4) - -proc setname*(message: google_protobuf_Field, value: string) = - message.name = value - incl(message.hasField, 4) - -proc name*(message: google_protobuf_Field): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Field, value: string) {.inline.} = - setname(message, value) - -proc cleartype_url*(message: google_protobuf_Field) = - message.type_url = "" - excl(message.hasField, [6]) - -proc hastype_url*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 6) - -proc settype_url*(message: google_protobuf_Field, value: string) = - message.type_url = value - incl(message.hasField, 6) - -proc type_url*(message: google_protobuf_Field): string {.inline.} = - message.type_url - -proc `type_url=`*(message: google_protobuf_Field, value: string) {.inline.} = - settype_url(message, value) - -proc clearoneof_index*(message: google_protobuf_Field) = - message.oneof_index = 0 - excl(message.hasField, [7]) - -proc hasoneof_index*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 7) - -proc setoneof_index*(message: google_protobuf_Field, value: int32) = - message.oneof_index = value - incl(message.hasField, 7) - -proc oneof_index*(message: google_protobuf_Field): int32 {.inline.} = - message.oneof_index - -proc `oneof_index=`*(message: google_protobuf_Field, value: int32) {.inline.} = - setoneof_index(message, value) - -proc clearpacked*(message: google_protobuf_Field) = - message.packed = false - excl(message.hasField, [8]) - -proc haspacked*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 8) - -proc setpacked*(message: google_protobuf_Field, value: bool) = - message.packed = value - incl(message.hasField, 8) - -proc packed*(message: google_protobuf_Field): bool {.inline.} = - message.packed - -proc `packed=`*(message: google_protobuf_Field, value: bool) {.inline.} = - setpacked(message, value) - -proc clearoptions*(message: google_protobuf_Field) = - message.options = @[] - excl(message.hasField, [9]) - -proc hasoptions*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 9) or (len(message.options) > 0) - -proc setoptions*(message: google_protobuf_Field, value: seq[google_protobuf_Option]) = - message.options = value - incl(message.hasField, 9) - -proc addoptions*(message: google_protobuf_Field, value: google_protobuf_Option) = - add(message.options, value) - incl(message.hasField, 9) - -proc options*(message: google_protobuf_Field): seq[google_protobuf_Option] {.inline.} = - message.options - -proc `options=`*(message: google_protobuf_Field, value: seq[google_protobuf_Option]) {.inline.} = - setoptions(message, value) - -proc clearjson_name*(message: google_protobuf_Field) = - message.json_name = "" - excl(message.hasField, [10]) - -proc hasjson_name*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 10) - -proc setjson_name*(message: google_protobuf_Field, value: string) = - message.json_name = value - incl(message.hasField, 10) - -proc json_name*(message: google_protobuf_Field): string {.inline.} = - message.json_name - -proc `json_name=`*(message: google_protobuf_Field, value: string) {.inline.} = - setjson_name(message, value) - -proc cleardefault_value*(message: google_protobuf_Field) = - message.default_value = "" - excl(message.hasField, [11]) - -proc hasdefault_value*(message: google_protobuf_Field): bool = - result = contains(message.hasField, 11) - -proc setdefault_value*(message: google_protobuf_Field, value: string) = - message.default_value = value - incl(message.hasField, 11) - -proc default_value*(message: google_protobuf_Field): string {.inline.} = - message.default_value - -proc `default_value=`*(message: google_protobuf_Field, value: string) {.inline.} = - setdefault_value(message, value) - -proc sizeOfgoogle_protobuf_Field*(message: google_protobuf_Field): uint64 = - if haskind(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_Field_Kind](message.kind) - if hascardinality(message): - result = result + sizeOfTag(2, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_Field_Cardinality](message.cardinality) - if hasnumber(message): - result = result + sizeOfTag(3, WireType.Varint) - result = result + sizeOfInt32(message.number) - if hasname(message): - result = result + sizeOfTag(4, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - if hastype_url(message): - result = result + sizeOfTag(6, WireType.LengthDelimited) - result = result + sizeOfString(message.type_url) - if hasoneof_index(message): - result = result + sizeOfTag(7, WireType.Varint) - result = result + sizeOfInt32(message.oneof_index) - if haspacked(message): - result = result + sizeOfTag(8, WireType.Varint) - result = result + sizeOfBool(message.packed) - for value in message.options: - result = result + sizeOfTag(9, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) - if hasjson_name(message): - result = result + sizeOfTag(10, WireType.LengthDelimited) - result = result + sizeOfString(message.json_name) - if hasdefault_value(message): - result = result + sizeOfTag(11, WireType.LengthDelimited) - result = result + sizeOfString(message.default_value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Field*(stream: ProtobufStream, message: google_protobuf_Field) = - if haskind(message): - writeEnum(stream, message.kind, 1) - if hascardinality(message): - writeEnum(stream, message.cardinality, 2) - if hasnumber(message): - writeInt32(stream, message.number, 3) - if hasname(message): - writeString(stream, message.name, 4) - if hastype_url(message): - writeString(stream, message.type_url, 6) - if hasoneof_index(message): - writeInt32(stream, message.oneof_index, 7) - if haspacked(message): - writeBool(stream, message.packed, 8) - for value in message.options: - writeMessage(stream, value, 9) - if hasjson_name(message): - writeString(stream, message.json_name, 10) - if hasdefault_value(message): - writeString(stream, message.default_value, 11) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Field*(stream: ProtobufStream): google_protobuf_Field = - result = newgoogle_protobuf_Field() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setkind(result, readEnum[google_protobuf_Field_Kind](stream)) - of 2: - expectWireType(wireType, WireType.Varint) - setcardinality(result, readEnum[google_protobuf_Field_Cardinality](stream)) - of 3: - expectWireType(wireType, WireType.Varint) - setnumber(result, readInt32(stream)) - of 4: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 6: - expectWireType(wireType, WireType.LengthDelimited) - settype_url(result, readString(stream)) - of 7: - expectWireType(wireType, WireType.Varint) - setoneof_index(result, readInt32(stream)) - of 8: - expectWireType(wireType, WireType.Varint) - setpacked(result, readBool(stream)) - of 9: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addoptions(result, newgoogle_protobuf_Option(data)) - of 10: - expectWireType(wireType, WireType.LengthDelimited) - setjson_name(result, readString(stream)) - of 11: - expectWireType(wireType, WireType.LengthDelimited) - setdefault_value(result, readString(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Field): JsonNode = - result = newJObject() - if haskind(message): - result["kind"] = %($message.kind) - if hascardinality(message): - result["cardinality"] = %($message.cardinality) - if hasnumber(message): - result["number"] = %message.number - if hasname(message): - result["name"] = %message.name - if hastype_url(message): - result["typeUrl"] = %message.type_url - if hasoneof_index(message): - result["oneofIndex"] = %message.oneof_index - if haspacked(message): - result["packed"] = %message.packed - if hasoptions(message): - let arr = newJArray() - for value in message.options: - add(arr, toJson(value)) - result["options"] = arr - if hasjson_name(message): - result["jsonName"] = %message.json_name - if hasdefault_value(message): - result["defaultValue"] = %message.default_value - -proc serialize*(message: google_protobuf_Field): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Field(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Field*(data: string): google_protobuf_Field = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Field(pbs) - - -proc newgoogle_protobuf_Type*(): google_protobuf_Type = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.fields = @[] - result.oneofs = @[] - result.options = @[] - result.source_context = nil - result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - -proc clearname*(message: google_protobuf_Type) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_Type): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_Type, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_Type): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Type, value: string) {.inline.} = - setname(message, value) - -proc clearfields*(message: google_protobuf_Type) = - message.fields = @[] - excl(message.hasField, [2]) - -proc hasfields*(message: google_protobuf_Type): bool = - result = contains(message.hasField, 2) or (len(message.fields) > 0) - -proc setfields*(message: google_protobuf_Type, value: seq[google_protobuf_Field]) = - message.fields = value - incl(message.hasField, 2) - -proc addfields*(message: google_protobuf_Type, value: google_protobuf_Field) = - add(message.fields, value) - incl(message.hasField, 2) - -proc fields*(message: google_protobuf_Type): seq[google_protobuf_Field] {.inline.} = - message.fields - -proc `fields=`*(message: google_protobuf_Type, value: seq[google_protobuf_Field]) {.inline.} = - setfields(message, value) - -proc clearoneofs*(message: google_protobuf_Type) = - message.oneofs = @[] - excl(message.hasField, [3]) - -proc hasoneofs*(message: google_protobuf_Type): bool = - result = contains(message.hasField, 3) or (len(message.oneofs) > 0) - -proc setoneofs*(message: google_protobuf_Type, value: seq[string]) = - message.oneofs = value - incl(message.hasField, 3) - -proc addoneofs*(message: google_protobuf_Type, value: string) = - add(message.oneofs, value) - incl(message.hasField, 3) - -proc oneofs*(message: google_protobuf_Type): seq[string] {.inline.} = - message.oneofs - -proc `oneofs=`*(message: google_protobuf_Type, value: seq[string]) {.inline.} = - setoneofs(message, value) - -proc clearoptions*(message: google_protobuf_Type) = - message.options = @[] - excl(message.hasField, [4]) - -proc hasoptions*(message: google_protobuf_Type): bool = - result = contains(message.hasField, 4) or (len(message.options) > 0) - -proc setoptions*(message: google_protobuf_Type, value: seq[google_protobuf_Option]) = - message.options = value - incl(message.hasField, 4) - -proc addoptions*(message: google_protobuf_Type, value: google_protobuf_Option) = - add(message.options, value) - incl(message.hasField, 4) - -proc options*(message: google_protobuf_Type): seq[google_protobuf_Option] {.inline.} = - message.options - -proc `options=`*(message: google_protobuf_Type, value: seq[google_protobuf_Option]) {.inline.} = - setoptions(message, value) - -proc clearsource_context*(message: google_protobuf_Type) = - message.source_context = nil - excl(message.hasField, [5]) - -proc hassource_context*(message: google_protobuf_Type): bool = - result = contains(message.hasField, 5) - -proc setsource_context*(message: google_protobuf_Type, value: google_protobuf_SourceContext) = - message.source_context = value - incl(message.hasField, 5) - -proc source_context*(message: google_protobuf_Type): google_protobuf_SourceContext {.inline.} = - message.source_context - -proc `source_context=`*(message: google_protobuf_Type, value: google_protobuf_SourceContext) {.inline.} = - setsource_context(message, value) - -proc clearsyntax*(message: google_protobuf_Type) = - message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - excl(message.hasField, [6]) - -proc hassyntax*(message: google_protobuf_Type): bool = - result = contains(message.hasField, 6) - -proc setsyntax*(message: google_protobuf_Type, value: google_protobuf_Syntax) = - message.syntax = value - incl(message.hasField, 6) - -proc syntax*(message: google_protobuf_Type): google_protobuf_Syntax {.inline.} = - message.syntax - -proc `syntax=`*(message: google_protobuf_Type, value: google_protobuf_Syntax) {.inline.} = - setsyntax(message, value) - -proc sizeOfgoogle_protobuf_Type*(message: google_protobuf_Type): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - for value in message.fields: - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Field(value)) - for value in message.oneofs: - result = result + sizeOfTag(3, WireType.LengthDelimited) - result = result + sizeOfString(value) - for value in message.options: - result = result + sizeOfTag(4, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) - if hassource_context(message): - result = result + sizeOfTag(5, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context)) - if hassyntax(message): - result = result + sizeOfTag(6, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Type*(stream: ProtobufStream, message: google_protobuf_Type) = - if hasname(message): - writeString(stream, message.name, 1) - for value in message.fields: - writeMessage(stream, value, 2) - for value in message.oneofs: - writeString(stream, value, 3) - for value in message.options: - writeMessage(stream, value, 4) - if hassource_context(message): - writeMessage(stream, message.source_context, 5) - if hassyntax(message): - writeEnum(stream, message.syntax, 6) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Type*(stream: ProtobufStream): google_protobuf_Type = - result = newgoogle_protobuf_Type() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addfields(result, newgoogle_protobuf_Field(data)) - of 3: - expectWireType(wireType, WireType.LengthDelimited) - addoneofs(result, readString(stream)) - of 4: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addoptions(result, newgoogle_protobuf_Option(data)) - of 5: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - setsource_context(result, newgoogle_protobuf_SourceContext(data)) - of 6: - expectWireType(wireType, WireType.Varint) - setsyntax(result, readEnum[google_protobuf_Syntax](stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Type): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasfields(message): - let arr = newJArray() - for value in message.fields: - add(arr, toJson(value)) - result["fields"] = arr - if hasoneofs(message): - let arr = newJArray() - for value in message.oneofs: - add(arr, %value) - result["oneofs"] = arr - if hasoptions(message): - let arr = newJArray() - for value in message.options: - add(arr, toJson(value)) - result["options"] = arr - if hassource_context(message): - result["sourceContext"] = toJson(message.source_context) - if hassyntax(message): - result["syntax"] = %($message.syntax) - -proc serialize*(message: google_protobuf_Type): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Type(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Type*(data: string): google_protobuf_Type = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Type(pbs) - - -proc newgoogle_protobuf_EnumValue*(): google_protobuf_EnumValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.number = 0 - result.options = @[] - -proc clearname*(message: google_protobuf_EnumValue) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_EnumValue): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_EnumValue, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_EnumValue): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_EnumValue, value: string) {.inline.} = - setname(message, value) - -proc clearnumber*(message: google_protobuf_EnumValue) = - message.number = 0 - excl(message.hasField, [2]) - -proc hasnumber*(message: google_protobuf_EnumValue): bool = - result = contains(message.hasField, 2) - -proc setnumber*(message: google_protobuf_EnumValue, value: int32) = - message.number = value - incl(message.hasField, 2) - -proc number*(message: google_protobuf_EnumValue): int32 {.inline.} = - message.number - -proc `number=`*(message: google_protobuf_EnumValue, value: int32) {.inline.} = - setnumber(message, value) - -proc clearoptions*(message: google_protobuf_EnumValue) = - message.options = @[] - excl(message.hasField, [3]) - -proc hasoptions*(message: google_protobuf_EnumValue): bool = - result = contains(message.hasField, 3) or (len(message.options) > 0) - -proc setoptions*(message: google_protobuf_EnumValue, value: seq[google_protobuf_Option]) = - message.options = value - incl(message.hasField, 3) - -proc addoptions*(message: google_protobuf_EnumValue, value: google_protobuf_Option) = - add(message.options, value) - incl(message.hasField, 3) - -proc options*(message: google_protobuf_EnumValue): seq[google_protobuf_Option] {.inline.} = - message.options - -proc `options=`*(message: google_protobuf_EnumValue, value: seq[google_protobuf_Option]) {.inline.} = - setoptions(message, value) - -proc sizeOfgoogle_protobuf_EnumValue*(message: google_protobuf_EnumValue): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - if hasnumber(message): - result = result + sizeOfTag(2, WireType.Varint) - result = result + sizeOfInt32(message.number) - for value in message.options: - result = result + sizeOfTag(3, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_EnumValue*(stream: ProtobufStream, message: google_protobuf_EnumValue) = - if hasname(message): - writeString(stream, message.name, 1) - if hasnumber(message): - writeInt32(stream, message.number, 2) - for value in message.options: - writeMessage(stream, value, 3) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_EnumValue*(stream: ProtobufStream): google_protobuf_EnumValue = - result = newgoogle_protobuf_EnumValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.Varint) - setnumber(result, readInt32(stream)) - of 3: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addoptions(result, newgoogle_protobuf_Option(data)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_EnumValue): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasnumber(message): - result["number"] = %message.number - if hasoptions(message): - let arr = newJArray() - for value in message.options: - add(arr, toJson(value)) - result["options"] = arr - -proc serialize*(message: google_protobuf_EnumValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_EnumValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_EnumValue*(data: string): google_protobuf_EnumValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_EnumValue(pbs) - - -proc newgoogle_protobuf_Enum*(): google_protobuf_Enum = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.name = "" - result.enumvalue = @[] - result.options = @[] - result.source_context = nil - result.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - -proc clearname*(message: google_protobuf_Enum) = - message.name = "" - excl(message.hasField, [1]) - -proc hasname*(message: google_protobuf_Enum): bool = - result = contains(message.hasField, 1) - -proc setname*(message: google_protobuf_Enum, value: string) = - message.name = value - incl(message.hasField, 1) - -proc name*(message: google_protobuf_Enum): string {.inline.} = - message.name - -proc `name=`*(message: google_protobuf_Enum, value: string) {.inline.} = - setname(message, value) - -proc clearenumvalue*(message: google_protobuf_Enum) = - message.enumvalue = @[] - excl(message.hasField, [2]) - -proc hasenumvalue*(message: google_protobuf_Enum): bool = - result = contains(message.hasField, 2) or (len(message.enumvalue) > 0) - -proc setenumvalue*(message: google_protobuf_Enum, value: seq[google_protobuf_EnumValue]) = - message.enumvalue = value - incl(message.hasField, 2) - -proc addenumvalue*(message: google_protobuf_Enum, value: google_protobuf_EnumValue) = - add(message.enumvalue, value) - incl(message.hasField, 2) - -proc enumvalue*(message: google_protobuf_Enum): seq[google_protobuf_EnumValue] {.inline.} = - message.enumvalue - -proc `enumvalue=`*(message: google_protobuf_Enum, value: seq[google_protobuf_EnumValue]) {.inline.} = - setenumvalue(message, value) - -proc clearoptions*(message: google_protobuf_Enum) = - message.options = @[] - excl(message.hasField, [3]) - -proc hasoptions*(message: google_protobuf_Enum): bool = - result = contains(message.hasField, 3) or (len(message.options) > 0) - -proc setoptions*(message: google_protobuf_Enum, value: seq[google_protobuf_Option]) = - message.options = value - incl(message.hasField, 3) - -proc addoptions*(message: google_protobuf_Enum, value: google_protobuf_Option) = - add(message.options, value) - incl(message.hasField, 3) - -proc options*(message: google_protobuf_Enum): seq[google_protobuf_Option] {.inline.} = - message.options - -proc `options=`*(message: google_protobuf_Enum, value: seq[google_protobuf_Option]) {.inline.} = - setoptions(message, value) - -proc clearsource_context*(message: google_protobuf_Enum) = - message.source_context = nil - excl(message.hasField, [4]) - -proc hassource_context*(message: google_protobuf_Enum): bool = - result = contains(message.hasField, 4) - -proc setsource_context*(message: google_protobuf_Enum, value: google_protobuf_SourceContext) = - message.source_context = value - incl(message.hasField, 4) - -proc source_context*(message: google_protobuf_Enum): google_protobuf_SourceContext {.inline.} = - message.source_context - -proc `source_context=`*(message: google_protobuf_Enum, value: google_protobuf_SourceContext) {.inline.} = - setsource_context(message, value) - -proc clearsyntax*(message: google_protobuf_Enum) = - message.syntax = google_protobuf_Syntax.SYNTAX_PROTO2 - excl(message.hasField, [5]) - -proc hassyntax*(message: google_protobuf_Enum): bool = - result = contains(message.hasField, 5) - -proc setsyntax*(message: google_protobuf_Enum, value: google_protobuf_Syntax) = - message.syntax = value - incl(message.hasField, 5) - -proc syntax*(message: google_protobuf_Enum): google_protobuf_Syntax {.inline.} = - message.syntax - -proc `syntax=`*(message: google_protobuf_Enum, value: google_protobuf_Syntax) {.inline.} = - setsyntax(message, value) - -proc sizeOfgoogle_protobuf_Enum*(message: google_protobuf_Enum): uint64 = - if hasname(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.name) - for value in message.enumvalue: - result = result + sizeOfTag(2, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumValue(value)) - for value in message.options: - result = result + sizeOfTag(3, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value)) - if hassource_context(message): - result = result + sizeOfTag(4, WireType.LengthDelimited) - result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context)) - if hassyntax(message): - result = result + sizeOfTag(5, WireType.Varint) - result = result + sizeOfEnum[google_protobuf_Syntax](message.syntax) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Enum*(stream: ProtobufStream, message: google_protobuf_Enum) = - if hasname(message): - writeString(stream, message.name, 1) - for value in message.enumvalue: - writeMessage(stream, value, 2) - for value in message.options: - writeMessage(stream, value, 3) - if hassource_context(message): - writeMessage(stream, message.source_context, 4) - if hassyntax(message): - writeEnum(stream, message.syntax, 5) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Enum*(stream: ProtobufStream): google_protobuf_Enum = - result = newgoogle_protobuf_Enum() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setname(result, readString(stream)) - of 2: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addenumvalue(result, newgoogle_protobuf_EnumValue(data)) - of 3: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - addoptions(result, newgoogle_protobuf_Option(data)) - of 4: - expectWireType(wireType, WireType.LengthDelimited) - let data = readLengthDelimited(stream) - setsource_context(result, newgoogle_protobuf_SourceContext(data)) - of 5: - expectWireType(wireType, WireType.Varint) - setsyntax(result, readEnum[google_protobuf_Syntax](stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc toJson*(message: google_protobuf_Enum): JsonNode = - result = newJObject() - if hasname(message): - result["name"] = %message.name - if hasenumvalue(message): - let arr = newJArray() - for value in message.enumvalue: - add(arr, toJson(value)) - result["enumvalue"] = arr - if hasoptions(message): - let arr = newJArray() - for value in message.options: - add(arr, toJson(value)) - result["options"] = arr - if hassource_context(message): - result["sourceContext"] = toJson(message.source_context) - if hassyntax(message): - result["syntax"] = %($message.syntax) - -proc serialize*(message: google_protobuf_Enum): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Enum(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Enum*(data: string): google_protobuf_Enum = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Enum(pbs) - - diff --git a/src/nimpb/wkt/wrappers_pb.nim b/src/nimpb/wkt/wrappers_pb.nim deleted file mode 100644 index d1b5f80..0000000 --- a/src/nimpb/wkt/wrappers_pb.nim +++ /dev/null @@ -1,677 +0,0 @@ -# Generated by protoc_gen_nim. Do not edit! - -import base64 -import intsets -import json - -import nimpb/nimpb -import nimpb/json as nimpb_json - -type - google_protobuf_DoubleValue* = ref google_protobuf_DoubleValueObj - google_protobuf_DoubleValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: float64 - google_protobuf_FloatValue* = ref google_protobuf_FloatValueObj - google_protobuf_FloatValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: float32 - google_protobuf_Int64Value* = ref google_protobuf_Int64ValueObj - google_protobuf_Int64ValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: int64 - google_protobuf_UInt64Value* = ref google_protobuf_UInt64ValueObj - google_protobuf_UInt64ValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: uint64 - google_protobuf_Int32Value* = ref google_protobuf_Int32ValueObj - google_protobuf_Int32ValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: int32 - google_protobuf_UInt32Value* = ref google_protobuf_UInt32ValueObj - google_protobuf_UInt32ValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: uint32 - google_protobuf_BoolValue* = ref google_protobuf_BoolValueObj - google_protobuf_BoolValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: bool - google_protobuf_StringValue* = ref google_protobuf_StringValueObj - google_protobuf_StringValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: string - google_protobuf_BytesValue* = ref google_protobuf_BytesValueObj - google_protobuf_BytesValueObj* = object of RootObj - hasField: IntSet - unknownFields: seq[UnknownField] - value: bytes - -proc newgoogle_protobuf_Int32Value*(): google_protobuf_Int32Value -proc newgoogle_protobuf_Int32Value*(data: string): google_protobuf_Int32Value -proc writegoogle_protobuf_Int32Value*(stream: ProtobufStream, message: google_protobuf_Int32Value) -proc readgoogle_protobuf_Int32Value*(stream: ProtobufStream): google_protobuf_Int32Value -proc sizeOfgoogle_protobuf_Int32Value*(message: google_protobuf_Int32Value): uint64 - -proc newgoogle_protobuf_Int64Value*(): google_protobuf_Int64Value -proc newgoogle_protobuf_Int64Value*(data: string): google_protobuf_Int64Value -proc writegoogle_protobuf_Int64Value*(stream: ProtobufStream, message: google_protobuf_Int64Value) -proc readgoogle_protobuf_Int64Value*(stream: ProtobufStream): google_protobuf_Int64Value -proc sizeOfgoogle_protobuf_Int64Value*(message: google_protobuf_Int64Value): uint64 - -proc newgoogle_protobuf_DoubleValue*(): google_protobuf_DoubleValue -proc newgoogle_protobuf_DoubleValue*(data: string): google_protobuf_DoubleValue -proc writegoogle_protobuf_DoubleValue*(stream: ProtobufStream, message: google_protobuf_DoubleValue) -proc readgoogle_protobuf_DoubleValue*(stream: ProtobufStream): google_protobuf_DoubleValue -proc sizeOfgoogle_protobuf_DoubleValue*(message: google_protobuf_DoubleValue): uint64 - -proc newgoogle_protobuf_StringValue*(): google_protobuf_StringValue -proc newgoogle_protobuf_StringValue*(data: string): google_protobuf_StringValue -proc writegoogle_protobuf_StringValue*(stream: ProtobufStream, message: google_protobuf_StringValue) -proc readgoogle_protobuf_StringValue*(stream: ProtobufStream): google_protobuf_StringValue -proc sizeOfgoogle_protobuf_StringValue*(message: google_protobuf_StringValue): uint64 - -proc newgoogle_protobuf_BoolValue*(): google_protobuf_BoolValue -proc newgoogle_protobuf_BoolValue*(data: string): google_protobuf_BoolValue -proc writegoogle_protobuf_BoolValue*(stream: ProtobufStream, message: google_protobuf_BoolValue) -proc readgoogle_protobuf_BoolValue*(stream: ProtobufStream): google_protobuf_BoolValue -proc sizeOfgoogle_protobuf_BoolValue*(message: google_protobuf_BoolValue): uint64 - -proc newgoogle_protobuf_BytesValue*(): google_protobuf_BytesValue -proc newgoogle_protobuf_BytesValue*(data: string): google_protobuf_BytesValue -proc writegoogle_protobuf_BytesValue*(stream: ProtobufStream, message: google_protobuf_BytesValue) -proc readgoogle_protobuf_BytesValue*(stream: ProtobufStream): google_protobuf_BytesValue -proc sizeOfgoogle_protobuf_BytesValue*(message: google_protobuf_BytesValue): uint64 - -proc newgoogle_protobuf_FloatValue*(): google_protobuf_FloatValue -proc newgoogle_protobuf_FloatValue*(data: string): google_protobuf_FloatValue -proc writegoogle_protobuf_FloatValue*(stream: ProtobufStream, message: google_protobuf_FloatValue) -proc readgoogle_protobuf_FloatValue*(stream: ProtobufStream): google_protobuf_FloatValue -proc sizeOfgoogle_protobuf_FloatValue*(message: google_protobuf_FloatValue): uint64 - -proc newgoogle_protobuf_UInt64Value*(): google_protobuf_UInt64Value -proc newgoogle_protobuf_UInt64Value*(data: string): google_protobuf_UInt64Value -proc writegoogle_protobuf_UInt64Value*(stream: ProtobufStream, message: google_protobuf_UInt64Value) -proc readgoogle_protobuf_UInt64Value*(stream: ProtobufStream): google_protobuf_UInt64Value -proc sizeOfgoogle_protobuf_UInt64Value*(message: google_protobuf_UInt64Value): uint64 - -proc newgoogle_protobuf_UInt32Value*(): google_protobuf_UInt32Value -proc newgoogle_protobuf_UInt32Value*(data: string): google_protobuf_UInt32Value -proc writegoogle_protobuf_UInt32Value*(stream: ProtobufStream, message: google_protobuf_UInt32Value) -proc readgoogle_protobuf_UInt32Value*(stream: ProtobufStream): google_protobuf_UInt32Value -proc sizeOfgoogle_protobuf_UInt32Value*(message: google_protobuf_UInt32Value): uint64 - -proc newgoogle_protobuf_Int32Value*(): google_protobuf_Int32Value = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = 0 - -proc clearvalue*(message: google_protobuf_Int32Value) = - message.value = 0 - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_Int32Value): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_Int32Value, value: int32) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_Int32Value): int32 {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_Int32Value, value: int32) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_Int32Value*(message: google_protobuf_Int32Value): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfInt32(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Int32Value*(stream: ProtobufStream, message: google_protobuf_Int32Value) = - if hasvalue(message): - writeInt32(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Int32Value*(stream: ProtobufStream): google_protobuf_Int32Value = - result = newgoogle_protobuf_Int32Value() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setvalue(result, readInt32(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Int32Value): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Int32Value(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Int32Value*(data: string): google_protobuf_Int32Value = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Int32Value(pbs) - - -proc newgoogle_protobuf_Int64Value*(): google_protobuf_Int64Value = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = 0 - -proc clearvalue*(message: google_protobuf_Int64Value) = - message.value = 0 - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_Int64Value): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_Int64Value, value: int64) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_Int64Value): int64 {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_Int64Value, value: int64) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_Int64Value*(message: google_protobuf_Int64Value): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfInt64(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_Int64Value*(stream: ProtobufStream, message: google_protobuf_Int64Value) = - if hasvalue(message): - writeInt64(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_Int64Value*(stream: ProtobufStream): google_protobuf_Int64Value = - result = newgoogle_protobuf_Int64Value() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setvalue(result, readInt64(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_Int64Value): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_Int64Value(pbs, message) - result = ss.data - -proc newgoogle_protobuf_Int64Value*(data: string): google_protobuf_Int64Value = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_Int64Value(pbs) - - -proc newgoogle_protobuf_DoubleValue*(): google_protobuf_DoubleValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = 0 - -proc clearvalue*(message: google_protobuf_DoubleValue) = - message.value = 0 - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_DoubleValue): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_DoubleValue, value: float64) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_DoubleValue): float64 {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_DoubleValue, value: float64) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_DoubleValue*(message: google_protobuf_DoubleValue): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Fixed64) - result = result + sizeOfDouble(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_DoubleValue*(stream: ProtobufStream, message: google_protobuf_DoubleValue) = - if hasvalue(message): - writeDouble(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_DoubleValue*(stream: ProtobufStream): google_protobuf_DoubleValue = - result = newgoogle_protobuf_DoubleValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Fixed64) - setvalue(result, readDouble(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_DoubleValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_DoubleValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_DoubleValue*(data: string): google_protobuf_DoubleValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_DoubleValue(pbs) - - -proc newgoogle_protobuf_StringValue*(): google_protobuf_StringValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = "" - -proc clearvalue*(message: google_protobuf_StringValue) = - message.value = "" - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_StringValue): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_StringValue, value: string) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_StringValue): string {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_StringValue, value: string) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_StringValue*(message: google_protobuf_StringValue): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfString(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_StringValue*(stream: ProtobufStream, message: google_protobuf_StringValue) = - if hasvalue(message): - writeString(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_StringValue*(stream: ProtobufStream): google_protobuf_StringValue = - result = newgoogle_protobuf_StringValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setvalue(result, readString(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_StringValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_StringValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_StringValue*(data: string): google_protobuf_StringValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_StringValue(pbs) - - -proc newgoogle_protobuf_BoolValue*(): google_protobuf_BoolValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = false - -proc clearvalue*(message: google_protobuf_BoolValue) = - message.value = false - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_BoolValue): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_BoolValue, value: bool) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_BoolValue): bool {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_BoolValue, value: bool) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_BoolValue*(message: google_protobuf_BoolValue): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfBool(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_BoolValue*(stream: ProtobufStream, message: google_protobuf_BoolValue) = - if hasvalue(message): - writeBool(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_BoolValue*(stream: ProtobufStream): google_protobuf_BoolValue = - result = newgoogle_protobuf_BoolValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setvalue(result, readBool(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_BoolValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_BoolValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_BoolValue*(data: string): google_protobuf_BoolValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_BoolValue(pbs) - - -proc newgoogle_protobuf_BytesValue*(): google_protobuf_BytesValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = bytes("") - -proc clearvalue*(message: google_protobuf_BytesValue) = - message.value = bytes("") - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_BytesValue): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_BytesValue, value: bytes) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_BytesValue): bytes {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_BytesValue, value: bytes) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_BytesValue*(message: google_protobuf_BytesValue): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.LengthDelimited) - result = result + sizeOfBytes(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_BytesValue*(stream: ProtobufStream, message: google_protobuf_BytesValue) = - if hasvalue(message): - writeBytes(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_BytesValue*(stream: ProtobufStream): google_protobuf_BytesValue = - result = newgoogle_protobuf_BytesValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.LengthDelimited) - setvalue(result, readBytes(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_BytesValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_BytesValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_BytesValue*(data: string): google_protobuf_BytesValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_BytesValue(pbs) - - -proc newgoogle_protobuf_FloatValue*(): google_protobuf_FloatValue = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = 0 - -proc clearvalue*(message: google_protobuf_FloatValue) = - message.value = 0 - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_FloatValue): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_FloatValue, value: float32) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_FloatValue): float32 {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_FloatValue, value: float32) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_FloatValue*(message: google_protobuf_FloatValue): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Fixed32) - result = result + sizeOfFloat(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_FloatValue*(stream: ProtobufStream, message: google_protobuf_FloatValue) = - if hasvalue(message): - writeFloat(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_FloatValue*(stream: ProtobufStream): google_protobuf_FloatValue = - result = newgoogle_protobuf_FloatValue() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Fixed32) - setvalue(result, readFloat(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_FloatValue): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_FloatValue(pbs, message) - result = ss.data - -proc newgoogle_protobuf_FloatValue*(data: string): google_protobuf_FloatValue = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_FloatValue(pbs) - - -proc newgoogle_protobuf_UInt64Value*(): google_protobuf_UInt64Value = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = 0 - -proc clearvalue*(message: google_protobuf_UInt64Value) = - message.value = 0 - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_UInt64Value): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_UInt64Value, value: uint64) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_UInt64Value): uint64 {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_UInt64Value, value: uint64) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_UInt64Value*(message: google_protobuf_UInt64Value): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfUInt64(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_UInt64Value*(stream: ProtobufStream, message: google_protobuf_UInt64Value) = - if hasvalue(message): - writeUInt64(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_UInt64Value*(stream: ProtobufStream): google_protobuf_UInt64Value = - result = newgoogle_protobuf_UInt64Value() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setvalue(result, readUInt64(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_UInt64Value): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_UInt64Value(pbs, message) - result = ss.data - -proc newgoogle_protobuf_UInt64Value*(data: string): google_protobuf_UInt64Value = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_UInt64Value(pbs) - - -proc newgoogle_protobuf_UInt32Value*(): google_protobuf_UInt32Value = - new(result) - result.hasField = initIntSet() - result.unknownFields = @[] - result.value = 0 - -proc clearvalue*(message: google_protobuf_UInt32Value) = - message.value = 0 - excl(message.hasField, [1]) - -proc hasvalue*(message: google_protobuf_UInt32Value): bool = - result = contains(message.hasField, 1) - -proc setvalue*(message: google_protobuf_UInt32Value, value: uint32) = - message.value = value - incl(message.hasField, 1) - -proc value*(message: google_protobuf_UInt32Value): uint32 {.inline.} = - message.value - -proc `value=`*(message: google_protobuf_UInt32Value, value: uint32) {.inline.} = - setvalue(message, value) - -proc sizeOfgoogle_protobuf_UInt32Value*(message: google_protobuf_UInt32Value): uint64 = - if hasvalue(message): - result = result + sizeOfTag(1, WireType.Varint) - result = result + sizeOfUInt32(message.value) - for field in message.unknownFields: - result = result + sizeOfUnknownField(field) - -proc writegoogle_protobuf_UInt32Value*(stream: ProtobufStream, message: google_protobuf_UInt32Value) = - if hasvalue(message): - writeUInt32(stream, message.value, 1) - writeUnknownFields(stream, message.unknownFields) - -proc readgoogle_protobuf_UInt32Value*(stream: ProtobufStream): google_protobuf_UInt32Value = - result = newgoogle_protobuf_UInt32Value() - while not atEnd(stream): - let - tag = readTag(stream) - wireType = wireType(tag) - case fieldNumber(tag) - of 0: - raise newException(InvalidFieldNumberError, "Invalid field number: 0") - of 1: - expectWireType(wireType, WireType.Varint) - setvalue(result, readUInt32(stream)) - else: readUnknownField(stream, tag, result.unknownFields) - -proc serialize*(message: google_protobuf_UInt32Value): string = - let - ss = newStringStream() - pbs = newProtobufStream(ss) - writegoogle_protobuf_UInt32Value(pbs, message) - result = ss.data - -proc newgoogle_protobuf_UInt32Value*(data: string): google_protobuf_UInt32Value = - let - ss = newStringStream(data) - pbs = newProtobufStream(ss) - result = readgoogle_protobuf_UInt32Value(pbs) - - diff --git a/tests/nim.cfg b/tests/nim.cfg index a119208..0f840a1 100644 --- a/tests/nim.cfg +++ b/tests/nim.cfg @@ -1 +1 @@ ---path:"../src" +--path:".." -- cgit v1.2.3 From 2cf4a1710c7fac6263e50b384592df6a18f5da08 Mon Sep 17 00:00:00 2001 From: Oskari Timperi Date: Wed, 11 Apr 2018 18:52:09 +0300 Subject: Add protobuf compiler utility back --- nimpb/compiler/compiler.nim | 134 ++ nimpb/compiler/descriptor_pb.nim | 4801 ++++++++++++++++++++++++++++++++++++++ nimpb/compiler/plugin.nim | 1084 +++++++++ 3 files changed, 6019 insertions(+) create mode 100644 nimpb/compiler/compiler.nim create mode 100644 nimpb/compiler/descriptor_pb.nim create mode 100644 nimpb/compiler/plugin.nim diff --git a/nimpb/compiler/compiler.nim b/nimpb/compiler/compiler.nim new file mode 100644 index 0000000..b93d158 --- /dev/null +++ b/nimpb/compiler/compiler.nim @@ -0,0 +1,134 @@ +import os +import osproc +import streams +import strformat +import strtabs +import strutils + +from plugin import processFileDescriptorSet, ServiceGenerator, Service, ServiceMethod + +export Service, ServiceMethod + +when defined(windows): + const compilerId = "win32" +elif defined(linux): + when defined(i386): + const arch = "x86_32" + elif defined(amd64): + const arch = "x86_64" + elif defined(arm64): + const arch = "aarch_64" + else: + {.fatal:"unsupported architecture".} + const compilerId = "linux-" & arch +elif defined(macosx): + when defined(amd64): + const arch = "x86_64" + else: + {.fatal:"unsupported architecture".} + const compilerId = "osx-" & arch +else: + {.fatal:"unsupported platform".} + +when defined(windows): + const exeSuffix = ".exe" +else: + const exeSuffix = "" + +proc findCompiler(): string = + let + compilerName = &"protoc-{compilerId}{exeSuffix}" + paths = @[ + getAppDir() / "src" / "nimpb_buildpkg" / "protobuf", + getAppDir() / "nimpb_buildpkg" / "protobuf", + parentDir(currentSourcePath()) / "nimpb_buildpkg" / "protobuf", + ] + + for path in paths: + if fileExists(path / compilerName): + return path / compilerName + + raise newException(Exception, &"{compilerName} not found!") + +proc builtinIncludeDir(compilerPath: string): string = + parentDir(compilerPath) / "include" + +template verboseEcho(x: untyped): untyped = + if verbose: + echo(x) + +proc myTempDir(): string = + result = getTempDir() / "nimpb_build_tmp" + +proc compileProtos*(protos: openArray[string], + includes: openArray[string], + outdir: string, + serviceGenerator: ServiceGenerator = nil) = + let command = findCompiler() + var args: seq[string] = @[] + + var outputFilename = myTempDir() / "file-descriptor-set" + createDir(myTempDir()) + + add(args, "--include_imports") + add(args, "--include_source_info") + add(args, &"-o{outputFilename}") + + for incdir in includes: + add(args, &"-I{incdir}") + + add(args, &"-I{builtinIncludeDir(command)}") + + for proto in protos: + add(args, proto) + + var cmdline: string = quoteShell(command) + for arg in args: + cmdline &= " " & quoteShell(arg) + + let (outp, rc) = execCmdEx(cmdline) + + if rc != 0: + raise newException(Exception, outp) + + processFileDescriptorSet(outputFilename, outdir, protos, serviceGenerator) + + +when isMainModule: + proc usage() {.noreturn.} = + echo(&""" + {getAppFilename()} --out=OUTDIR [-IPATH [-IPATH]...] PROTOFILE... + + --out The output directory for the generated files + -I Add a path to the set of include paths + """) + quit(QuitFailure) + + var includes: seq[string] = @[] + var protos: seq[string] = @[] + var outdir: string + + if paramCount() == 0: + usage() + + for idx in 1..paramCount(): + let param = paramStr(idx) + + if param.startsWith("-I"): + add(includes, param[2..^1]) + elif param.startsWith("--out="): + outdir = param[6..^1] + elif param == "--help": + usage() + else: + add(protos, param) + + if outdir == nil: + echo("error: --out is required") + quit(QuitFailure) + + if len(protos) == 0: + echo("error: no input files") + quit(QuitFailure) + + compileProtos(protos, includes, outdir) diff --git a/nimpb/compiler/descriptor_pb.nim b/nimpb/compiler/descriptor_pb.nim new file mode 100644 index 0000000..b6ed832 --- /dev/null +++ b/nimpb/compiler/descriptor_pb.nim @@ -0,0 +1,4801 @@ +# Generated by protoc_gen_nim. Do not edit! + +import intsets + +import nimpb/nimpb + +type + google_protobuf_FieldDescriptorProto_Type* {.pure.} = enum + TYPE_DOUBLE = 1 + TYPE_FLOAT = 2 + TYPE_INT64 = 3 + TYPE_UINT64 = 4 + TYPE_INT32 = 5 + TYPE_FIXED64 = 6 + TYPE_FIXED32 = 7 + TYPE_BOOL = 8 + TYPE_STRING = 9 + TYPE_GROUP = 10 + TYPE_MESSAGE = 11 + TYPE_BYTES = 12 + TYPE_UINT32 = 13 + TYPE_ENUM = 14 + TYPE_SFIXED32 = 15 + TYPE_SFIXED64 = 16 + TYPE_SINT32 = 17 + TYPE_SINT64 = 18 + google_protobuf_FieldDescriptorProto_Label* {.pure.} = enum + LABEL_OPTIONAL = 1 + LABEL_REQUIRED = 2 + LABEL_REPEATED = 3 + google_protobuf_FileOptions_OptimizeMode* {.pure.} = enum + SPEED = 1 + CODE_SIZE = 2 + LITE_RUNTIME = 3 + google_protobuf_FieldOptions_CType* {.pure.} = enum + STRING = 0 + CORD = 1 + STRING_PIECE = 2 + google_protobuf_FieldOptions_JSType* {.pure.} = enum + JS_NORMAL = 0 + JS_STRING = 1 + JS_NUMBER = 2 + google_protobuf_MethodOptions_IdempotencyLevel* {.pure.} = enum + IDEMPOTENCY_UNKNOWN = 0 + NO_SIDE_EFFECTS = 1 + IDEMPOTENT = 2 + google_protobuf_FileDescriptorSet* = ref google_protobuf_FileDescriptorSetObj + google_protobuf_FileDescriptorSetObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + file: seq[google_protobuf_FileDescriptorProto] + google_protobuf_FileDescriptorProto* = ref google_protobuf_FileDescriptorProtoObj + google_protobuf_FileDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + package: string + dependency: seq[string] + public_dependency: seq[int32] + weak_dependency: seq[int32] + message_type: seq[google_protobuf_DescriptorProto] + enum_type: seq[google_protobuf_EnumDescriptorProto] + service: seq[google_protobuf_ServiceDescriptorProto] + extension: seq[google_protobuf_FieldDescriptorProto] + options: google_protobuf_FileOptions + source_code_info: google_protobuf_SourceCodeInfo + syntax: string + google_protobuf_DescriptorProto* = ref google_protobuf_DescriptorProtoObj + google_protobuf_DescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + field: seq[google_protobuf_FieldDescriptorProto] + extension: seq[google_protobuf_FieldDescriptorProto] + nested_type: seq[google_protobuf_DescriptorProto] + enum_type: seq[google_protobuf_EnumDescriptorProto] + extension_range: seq[google_protobuf_DescriptorProto_ExtensionRange] + oneof_decl: seq[google_protobuf_OneofDescriptorProto] + options: google_protobuf_MessageOptions + reserved_range: seq[google_protobuf_DescriptorProto_ReservedRange] + reserved_name: seq[string] + google_protobuf_DescriptorProto_ReservedRange* = ref google_protobuf_DescriptorProto_ReservedRangeObj + google_protobuf_DescriptorProto_ReservedRangeObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + start: int32 + fend: int32 + google_protobuf_DescriptorProto_ExtensionRange* = ref google_protobuf_DescriptorProto_ExtensionRangeObj + google_protobuf_DescriptorProto_ExtensionRangeObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + start: int32 + fend: int32 + options: google_protobuf_ExtensionRangeOptions + google_protobuf_ExtensionRangeOptions* = ref google_protobuf_ExtensionRangeOptionsObj + google_protobuf_ExtensionRangeOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_FieldDescriptorProto* = ref google_protobuf_FieldDescriptorProtoObj + google_protobuf_FieldDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + number: int32 + label: google_protobuf_FieldDescriptorProto_Label + ftype: google_protobuf_FieldDescriptorProto_Type + type_name: string + extendee: string + default_value: string + oneof_index: int32 + json_name: string + options: google_protobuf_FieldOptions + google_protobuf_OneofDescriptorProto* = ref google_protobuf_OneofDescriptorProtoObj + google_protobuf_OneofDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + options: google_protobuf_OneofOptions + google_protobuf_EnumDescriptorProto* = ref google_protobuf_EnumDescriptorProtoObj + google_protobuf_EnumDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + value: seq[google_protobuf_EnumValueDescriptorProto] + options: google_protobuf_EnumOptions + reserved_range: seq[google_protobuf_EnumDescriptorProto_EnumReservedRange] + reserved_name: seq[string] + google_protobuf_EnumDescriptorProto_EnumReservedRange* = ref google_protobuf_EnumDescriptorProto_EnumReservedRangeObj + google_protobuf_EnumDescriptorProto_EnumReservedRangeObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + start: int32 + fend: int32 + google_protobuf_EnumValueDescriptorProto* = ref google_protobuf_EnumValueDescriptorProtoObj + google_protobuf_EnumValueDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + number: int32 + options: google_protobuf_EnumValueOptions + google_protobuf_ServiceDescriptorProto* = ref google_protobuf_ServiceDescriptorProtoObj + google_protobuf_ServiceDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + fmethod: seq[google_protobuf_MethodDescriptorProto] + options: google_protobuf_ServiceOptions + google_protobuf_MethodDescriptorProto* = ref google_protobuf_MethodDescriptorProtoObj + google_protobuf_MethodDescriptorProtoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: string + input_type: string + output_type: string + options: google_protobuf_MethodOptions + client_streaming: bool + server_streaming: bool + google_protobuf_FileOptions* = ref google_protobuf_FileOptionsObj + google_protobuf_FileOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + java_package: string + java_outer_classname: string + java_multiple_files: bool + java_generate_equals_and_hash: bool + java_string_check_utf8: bool + optimize_for: google_protobuf_FileOptions_OptimizeMode + go_package: string + cc_generic_services: bool + java_generic_services: bool + py_generic_services: bool + php_generic_services: bool + deprecated: bool + cc_enable_arenas: bool + objc_class_prefix: string + csharp_namespace: string + swift_prefix: string + php_class_prefix: string + php_namespace: string + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_MessageOptions* = ref google_protobuf_MessageOptionsObj + google_protobuf_MessageOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + message_set_wire_format: bool + no_standard_descriptor_accessor: bool + deprecated: bool + map_entry: bool + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_FieldOptions* = ref google_protobuf_FieldOptionsObj + google_protobuf_FieldOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + ctype: google_protobuf_FieldOptions_CType + packed: bool + jstype: google_protobuf_FieldOptions_JSType + lazy: bool + deprecated: bool + weak: bool + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_OneofOptions* = ref google_protobuf_OneofOptionsObj + google_protobuf_OneofOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_EnumOptions* = ref google_protobuf_EnumOptionsObj + google_protobuf_EnumOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + allow_alias: bool + deprecated: bool + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_EnumValueOptions* = ref google_protobuf_EnumValueOptionsObj + google_protobuf_EnumValueOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + deprecated: bool + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_ServiceOptions* = ref google_protobuf_ServiceOptionsObj + google_protobuf_ServiceOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + deprecated: bool + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_MethodOptions* = ref google_protobuf_MethodOptionsObj + google_protobuf_MethodOptionsObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + deprecated: bool + idempotency_level: google_protobuf_MethodOptions_IdempotencyLevel + uninterpreted_option: seq[google_protobuf_UninterpretedOption] + google_protobuf_UninterpretedOption* = ref google_protobuf_UninterpretedOptionObj + google_protobuf_UninterpretedOptionObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name: seq[google_protobuf_UninterpretedOption_NamePart] + identifier_value: string + positive_int_value: uint64 + negative_int_value: int64 + double_value: float64 + string_value: bytes + aggregate_value: string + google_protobuf_UninterpretedOption_NamePart* = ref google_protobuf_UninterpretedOption_NamePartObj + google_protobuf_UninterpretedOption_NamePartObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + name_part: string + is_extension: bool + google_protobuf_SourceCodeInfo* = ref google_protobuf_SourceCodeInfoObj + google_protobuf_SourceCodeInfoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + location: seq[google_protobuf_SourceCodeInfo_Location] + google_protobuf_SourceCodeInfo_Location* = ref google_protobuf_SourceCodeInfo_LocationObj + google_protobuf_SourceCodeInfo_LocationObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + path: seq[int32] + span: seq[int32] + leading_comments: string + trailing_comments: string + leading_detached_comments: seq[string] + google_protobuf_GeneratedCodeInfo* = ref google_protobuf_GeneratedCodeInfoObj + google_protobuf_GeneratedCodeInfoObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + annotation: seq[google_protobuf_GeneratedCodeInfo_Annotation] + google_protobuf_GeneratedCodeInfo_Annotation* = ref google_protobuf_GeneratedCodeInfo_AnnotationObj + google_protobuf_GeneratedCodeInfo_AnnotationObj* = object of RootObj + hasField: IntSet + unknownFields: seq[UnknownField] + path: seq[int32] + source_file: string + begin: int32 + fend: int32 + +proc newgoogle_protobuf_UninterpretedOption_NamePart*(): google_protobuf_UninterpretedOption_NamePart +proc newgoogle_protobuf_UninterpretedOption_NamePart*(data: string): google_protobuf_UninterpretedOption_NamePart +proc writegoogle_protobuf_UninterpretedOption_NamePart*(stream: ProtobufStream, message: google_protobuf_UninterpretedOption_NamePart) +proc readgoogle_protobuf_UninterpretedOption_NamePart*(stream: ProtobufStream): google_protobuf_UninterpretedOption_NamePart +proc sizeOfgoogle_protobuf_UninterpretedOption_NamePart*(message: google_protobuf_UninterpretedOption_NamePart): uint64 + +proc newgoogle_protobuf_UninterpretedOption*(): google_protobuf_UninterpretedOption +proc newgoogle_protobuf_UninterpretedOption*(data: string): google_protobuf_UninterpretedOption +proc writegoogle_protobuf_UninterpretedOption*(stream: ProtobufStream, message: google_protobuf_UninterpretedOption) +proc readgoogle_protobuf_UninterpretedOption*(stream: ProtobufStream): google_protobuf_UninterpretedOption +proc sizeOfgoogle_protobuf_UninterpretedOption*(message: google_protobuf_UninterpretedOption): uint64 + +proc newgoogle_protobuf_EnumValueOptions*(): google_protobuf_EnumValueOptions +proc newgoogle_protobuf_EnumValueOptions*(data: string): google_protobuf_EnumValueOptions +proc writegoogle_protobuf_EnumValueOptions*(stream: ProtobufStream, message: google_protobuf_EnumValueOptions) +proc readgoogle_protobuf_EnumValueOptions*(stream: ProtobufStream): google_protobuf_EnumValueOptions +proc sizeOfgoogle_protobuf_EnumValueOptions*(message: google_protobuf_EnumValueOptions): uint64 + +proc newgoogle_protobuf_EnumValueDescriptorProto*(): google_protobuf_EnumValueDescriptorProto +proc newgoogle_protobuf_EnumValueDescriptorProto*(data: string): google_protobuf_EnumValueDescriptorProto +proc writegoogle_protobuf_EnumValueDescriptorProto*(stream: ProtobufStream, message: google_protobuf_EnumValueDescriptorProto) +proc readgoogle_protobuf_EnumValueDescriptorProto*(stream: ProtobufStream): google_protobuf_EnumValueDescriptorProto +proc sizeOfgoogle_protobuf_EnumValueDescriptorProto*(message: google_protobuf_EnumValueDescriptorProto): uint64 + +proc newgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(): google_protobuf_EnumDescriptorProto_EnumReservedRange +proc newgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(data: string): google_protobuf_EnumDescriptorProto_EnumReservedRange +proc writegoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(stream: ProtobufStream, message: google_protobuf_EnumDescriptorProto_EnumReservedRange) +proc readgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(stream: ProtobufStream): google_protobuf_EnumDescriptorProto_EnumReservedRange +proc sizeOfgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): uint64 + +proc newgoogle_protobuf_EnumOptions*(): google_protobuf_EnumOptions +proc newgoogle_protobuf_EnumOptions*(data: string): google_protobuf_EnumOptions +proc writegoogle_protobuf_EnumOptions*(stream: ProtobufStream, message: google_protobuf_EnumOptions) +proc readgoogle_protobuf_EnumOptions*(stream: ProtobufStream): google_protobuf_EnumOptions +proc sizeOfgoogle_protobuf_EnumOptions*(message: google_protobuf_EnumOptions): uint64 + +proc newgoogle_protobuf_EnumDescriptorProto*(): google_protobuf_EnumDescriptorProto +proc newgoogle_protobuf_EnumDescriptorProto*(data: string): google_protobuf_EnumDescriptorProto +proc writegoogle_protobuf_EnumDescriptorProto*(stream: ProtobufStream, message: google_protobuf_EnumDescriptorProto) +proc readgoogle_protobuf_EnumDescriptorProto*(stream: ProtobufStream): google_protobuf_EnumDescriptorProto +proc sizeOfgoogle_protobuf_EnumDescriptorProto*(message: google_protobuf_EnumDescriptorProto): uint64 + +proc newgoogle_protobuf_ExtensionRangeOptions*(): google_protobuf_ExtensionRangeOptions +proc newgoogle_protobuf_ExtensionRangeOptions*(data: string): google_protobuf_ExtensionRangeOptions +proc writegoogle_protobuf_ExtensionRangeOptions*(stream: ProtobufStream, message: google_protobuf_ExtensionRangeOptions) +proc readgoogle_protobuf_ExtensionRangeOptions*(stream: ProtobufStream): google_protobuf_ExtensionRangeOptions +proc sizeOfgoogle_protobuf_ExtensionRangeOptions*(message: google_protobuf_ExtensionRangeOptions): uint64 + +proc newgoogle_protobuf_SourceCodeInfo_Location*(): google_protobuf_SourceCodeInfo_Location +proc newgoogle_protobuf_SourceCodeInfo_Location*(data: string): google_protobuf_SourceCodeInfo_Location +proc writegoogle_protobuf_SourceCodeInfo_Location*(stream: ProtobufStream, message: google_protobuf_SourceCodeInfo_Location) +proc readgoogle_protobuf_SourceCodeInfo_Location*(stream: ProtobufStream): google_protobuf_SourceCodeInfo_Location +proc sizeOfgoogle_protobuf_SourceCodeInfo_Location*(message: google_protobuf_SourceCodeInfo_Location): uint64 + +proc newgoogle_protobuf_SourceCodeInfo*(): google_protobuf_SourceCodeInfo +proc newgoogle_protobuf_SourceCodeInfo*(data: string): google_protobuf_SourceCodeInfo +proc writegoogle_protobuf_SourceCodeInfo*(stream: ProtobufStream, message: google_protobuf_SourceCodeInfo) +proc readgoogle_protobuf_SourceCodeInfo*(stream: ProtobufStream): google_protobuf_SourceCodeInfo +proc sizeOfgoogle_protobuf_SourceCodeInfo*(message: google_protobuf_SourceCodeInfo): uint64 + +proc newgoogle_protobuf_FieldOptions*(): google_protobuf_FieldOptions +proc newgoogle_protobuf_FieldOptions*(data: string): google_protobuf_FieldOptions +proc writegoogle_protobuf_FieldOptions*(stream: ProtobufStream, message: google_protobuf_FieldOptions) +proc readgoogle_protobuf_FieldOptions*(stream: ProtobufStream): google_protobuf_FieldOptions +proc sizeOfgoogle_protobuf_FieldOptions*(message: google_protobuf_FieldOptions): uint64 + +proc newgoogle_protobuf_FieldDescriptorProto*(): google_protobuf_FieldDescriptorProto +proc newgoogle_protobuf_FieldDescriptorProto*(data: string): google_protobuf_FieldDescriptorProto +proc writegoogle_protobuf_FieldDescriptorProto*(stream: ProtobufStream, message: google_protobuf_FieldDescriptorProto) +proc readgoogle_protobuf_FieldDescriptorProto*(stream: ProtobufStream): google_protobuf_FieldDescriptorProto +proc sizeOfgoogle_protobuf_FieldDescriptorProto*(message: google_protobuf_FieldDescriptorProto): uint64 + +proc newgoogle_protobuf_DescriptorProto_ExtensionRange*(): google_protobuf_DescriptorProto_ExtensionRange +proc newgoogle_protobuf_DescriptorProto_ExtensionRange*(data: string): google_protobuf_DescriptorProto_ExtensionRange +proc writegoogle_protobuf_DescriptorProto_ExtensionRange*(stream: ProtobufStream, message: google_protobuf_DescriptorProto_ExtensionRange) +proc readgoogle_protobuf_DescriptorProto_ExtensionRange*(stream: ProtobufStream): google_protobuf_DescriptorProto_ExtensionRange +proc sizeOfgoogle_protobuf_DescriptorProto_ExtensionRange*(message: google_protobuf_DescriptorProto_ExtensionRange): uint64 + +proc newgoogle_protobuf_MessageOptions*(): google_protobuf_MessageOptions +proc newgoogle_protobuf_MessageOptions*(data: string): google_protobuf_MessageOptions +proc writegoogle_protobuf_MessageOptions*(stream: ProtobufStream, message: google_protobuf_MessageOptions) +proc readgoogle_protobuf_MessageOptions*(stream: ProtobufStream): google_protobuf_MessageOptions +proc sizeOfgoogle_protobuf_MessageOptions*(message: google_protobuf_MessageOptions): uint64 + +proc newgoogle_protobuf_OneofOptions*(): google_protobuf_OneofOptions +proc newgoogle_protobuf_OneofOptions*(data: string): google_protobuf_OneofOptions +proc writegoogle_protobuf_OneofOptions*(stream: ProtobufStream, message: google_protobuf_OneofOptions) +proc readgoogle_protobuf_OneofOptions*(stream: ProtobufStream): google_protobuf_OneofOptions +proc sizeOfgoogle_protobuf_OneofOptions*(message: google_protobuf_OneofOptions): uint64 + +proc newgoogle_protobuf_OneofDescriptorProto*(): google_protobuf_OneofDescriptorProto +proc newgoogle_protobuf_OneofDescriptorProto*(data: string): google_protobuf_OneofDescriptorProto +proc writegoogle_protobuf_OneofDescriptorProto*(stream: ProtobufStream, message: google_protobuf_OneofDescriptorProto) +proc readgoogle_protobuf_OneofDescriptorProto*(stream: ProtobufStream): google_protobuf_OneofDescriptorProto +proc sizeOfgoogle_protobuf_OneofDescriptorProto*(message: google_protobuf_OneofDescriptorProto): uint64 + +proc newgoogle_protobuf_DescriptorProto_ReservedRange*(): google_protobuf_DescriptorProto_ReservedRange +proc newgoogle_protobuf_DescriptorProto_ReservedRange*(data: string): google_protobuf_DescriptorProto_ReservedRange +proc writegoogle_protobuf_DescriptorProto_ReservedRange*(stream: ProtobufStream, message: google_protobuf_DescriptorProto_ReservedRange) +proc readgoogle_protobuf_DescriptorProto_ReservedRange*(stream: ProtobufStream): google_protobuf_DescriptorProto_ReservedRange +proc sizeOfgoogle_protobuf_DescriptorProto_ReservedRange*(message: google_protobuf_DescriptorProto_ReservedRange): uint64 + +proc newgoogle_protobuf_DescriptorProto*(): google_protobuf_DescriptorProto +proc newgoogle_protobuf_DescriptorProto*(data: string): google_protobuf_DescriptorProto +proc writegoogle_protobuf_DescriptorProto*(stream: ProtobufStream, message: google_protobuf_DescriptorProto) +proc readgoogle_protobuf_DescriptorProto*(stream: ProtobufStream): google_protobuf_DescriptorProto +proc sizeOfgoogle_protobuf_DescriptorProto*(message: google_protobuf_DescriptorProto): uint64 + +proc newgoogle_protobuf_FileOptions*(): google_protobuf_FileOptions +proc newgoogle_protobuf_FileOptions*(data: string): google_protobuf_FileOptions +proc writegoogle_protobuf_FileOptions*(stream: ProtobufStream, message: google_protobuf_FileOptions) +proc readgoogle_protobuf_FileOptions*(stream: ProtobufStream): google_protobuf_FileOptions +proc sizeOfgoogle_protobuf_FileOptions*(message: google_protobuf_FileOptions): uint64 + +proc newgoogle_protobuf_ServiceOptions*(): google_protobuf_ServiceOptions +proc newgoogle_protobuf_ServiceOptions*(data: string): google_protobuf_ServiceOptions +proc writegoogle_protobuf_ServiceOptions*(stream: ProtobufStream, message: google_protobuf_ServiceOptions) +proc readgoogle_protobuf_ServiceOptions*(stream: ProtobufStream): google_protobuf_ServiceOptions +proc sizeOfgoogle_protobuf_ServiceOptions*(message: google_protobuf_ServiceOptions): uint64 + +proc newgoogle_protobuf_MethodOptions*(): google_protobuf_MethodOptions +proc newgoogle_protobuf_MethodOptions*(data: string): google_protobuf_MethodOptions +proc writegoogle_protobuf_MethodOptions*(stream: ProtobufStream, message: google_protobuf_MethodOptions) +proc readgoogle_protobuf_MethodOptions*(stream: ProtobufStream): google_protobuf_MethodOptions +proc sizeOfgoogle_protobuf_MethodOptions*(message: google_protobuf_MethodOptions): uint64 + +proc newgoogle_protobuf_MethodDescriptorProto*(): google_protobuf_MethodDescriptorProto +proc newgoogle_protobuf_MethodDescriptorProto*(data: string): google_protobuf_MethodDescriptorProto +proc writegoogle_protobuf_MethodDescriptorProto*(stream: ProtobufStream, message: google_protobuf_MethodDescriptorProto) +proc readgoogle_protobuf_MethodDescriptorProto*(stream: ProtobufStream): google_protobuf_MethodDescriptorProto +proc sizeOfgoogle_protobuf_MethodDescriptorProto*(message: google_protobuf_MethodDescriptorProto): uint64 + +proc newgoogle_protobuf_ServiceDescriptorProto*(): google_protobuf_ServiceDescriptorProto +proc newgoogle_protobuf_ServiceDescriptorProto*(data: string): google_protobuf_ServiceDescriptorProto +proc writegoogle_protobuf_ServiceDescriptorProto*(stream: ProtobufStream, message: google_protobuf_ServiceDescriptorProto) +proc readgoogle_protobuf_ServiceDescriptorProto*(stream: ProtobufStream): google_protobuf_ServiceDescriptorProto +proc sizeOfgoogle_protobuf_ServiceDescriptorProto*(message: google_protobuf_ServiceDescriptorProto): uint64 + +proc newgoogle_protobuf_FileDescriptorProto*(): google_protobuf_FileDescriptorProto +proc newgoogle_protobuf_FileDescriptorProto*(data: string): google_protobuf_FileDescriptorProto +proc writegoogle_protobuf_FileDescriptorProto*(stream: ProtobufStream, message: google_protobuf_FileDescriptorProto) +proc readgoogle_protobuf_FileDescriptorProto*(stream: ProtobufStream): google_protobuf_FileDescriptorProto +proc sizeOfgoogle_protobuf_FileDescriptorProto*(message: google_protobuf_FileDescriptorProto): uint64 + +proc newgoogle_protobuf_FileDescriptorSet*(): google_protobuf_FileDescriptorSet +proc newgoogle_protobuf_FileDescriptorSet*(data: string): google_protobuf_FileDescriptorSet +proc writegoogle_protobuf_FileDescriptorSet*(stream: ProtobufStream, message: google_protobuf_FileDescriptorSet) +proc readgoogle_protobuf_FileDescriptorSet*(stream: ProtobufStream): google_protobuf_FileDescriptorSet +proc sizeOfgoogle_protobuf_FileDescriptorSet*(message: google_protobuf_FileDescriptorSet): uint64 + +proc newgoogle_protobuf_GeneratedCodeInfo_Annotation*(): google_protobuf_GeneratedCodeInfo_Annotation +proc newgoogle_protobuf_GeneratedCodeInfo_Annotation*(data: string): google_protobuf_GeneratedCodeInfo_Annotation +proc writegoogle_protobuf_GeneratedCodeInfo_Annotation*(stream: ProtobufStream, message: google_protobuf_GeneratedCodeInfo_Annotation) +proc readgoogle_protobuf_GeneratedCodeInfo_Annotation*(stream: ProtobufStream): google_protobuf_GeneratedCodeInfo_Annotation +proc sizeOfgoogle_protobuf_GeneratedCodeInfo_Annotation*(message: google_protobuf_GeneratedCodeInfo_Annotation): uint64 + +proc newgoogle_protobuf_GeneratedCodeInfo*(): google_protobuf_GeneratedCodeInfo +proc newgoogle_protobuf_GeneratedCodeInfo*(data: string): google_protobuf_GeneratedCodeInfo +proc writegoogle_protobuf_GeneratedCodeInfo*(stream: ProtobufStream, message: google_protobuf_GeneratedCodeInfo) +proc readgoogle_protobuf_GeneratedCodeInfo*(stream: ProtobufStream): google_protobuf_GeneratedCodeInfo +proc sizeOfgoogle_protobuf_GeneratedCodeInfo*(message: google_protobuf_GeneratedCodeInfo): uint64 + +proc newgoogle_protobuf_UninterpretedOption_NamePart*(): google_protobuf_UninterpretedOption_NamePart = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name_part = "" + result.is_extension = false + +proc clearname_part*(message: google_protobuf_UninterpretedOption_NamePart) = + message.name_part = "" + excl(message.hasField, [1]) + +proc hasname_part*(message: google_protobuf_UninterpretedOption_NamePart): bool = + result = contains(message.hasField, 1) + +proc setname_part*(message: google_protobuf_UninterpretedOption_NamePart, value: string) = + message.name_part = value + incl(message.hasField, 1) + +proc name_part*(message: google_protobuf_UninterpretedOption_NamePart): string {.inline.} = + message.name_part + +proc `name_part=`*(message: google_protobuf_UninterpretedOption_NamePart, value: string) {.inline.} = + setname_part(message, value) + +proc clearis_extension*(message: google_protobuf_UninterpretedOption_NamePart) = + message.is_extension = false + excl(message.hasField, [2]) + +proc hasis_extension*(message: google_protobuf_UninterpretedOption_NamePart): bool = + result = contains(message.hasField, 2) + +proc setis_extension*(message: google_protobuf_UninterpretedOption_NamePart, value: bool) = + message.is_extension = value + incl(message.hasField, 2) + +proc is_extension*(message: google_protobuf_UninterpretedOption_NamePart): bool {.inline.} = + message.is_extension + +proc `is_extension=`*(message: google_protobuf_UninterpretedOption_NamePart, value: bool) {.inline.} = + setis_extension(message, value) + +proc sizeOfgoogle_protobuf_UninterpretedOption_NamePart*(message: google_protobuf_UninterpretedOption_NamePart): uint64 = + if hasname_part(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name_part) + if hasis_extension(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfBool(message.is_extension) + +proc writegoogle_protobuf_UninterpretedOption_NamePart*(stream: ProtobufStream, message: google_protobuf_UninterpretedOption_NamePart) = + if hasname_part(message): + writeString(stream, message.name_part, 1) + if hasis_extension(message): + writeBool(stream, message.is_extension, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_UninterpretedOption_NamePart*(stream: ProtobufStream): google_protobuf_UninterpretedOption_NamePart = + result = newgoogle_protobuf_UninterpretedOption_NamePart() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname_part(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setis_extension(result, readBool(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_UninterpretedOption_NamePart): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_UninterpretedOption_NamePart(pbs, message) + result = ss.data + +proc newgoogle_protobuf_UninterpretedOption_NamePart*(data: string): google_protobuf_UninterpretedOption_NamePart = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_UninterpretedOption_NamePart(pbs) + + +proc newgoogle_protobuf_UninterpretedOption*(): google_protobuf_UninterpretedOption = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = @[] + result.identifier_value = "" + result.positive_int_value = 0 + result.negative_int_value = 0 + result.double_value = 0 + result.string_value = bytes("") + result.aggregate_value = "" + +proc clearname*(message: google_protobuf_UninterpretedOption) = + message.name = @[] + excl(message.hasField, [2]) + +proc hasname*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 2) or (len(message.name) > 0) + +proc setname*(message: google_protobuf_UninterpretedOption, value: seq[google_protobuf_UninterpretedOption_NamePart]) = + message.name = value + incl(message.hasField, 2) + +proc addname*(message: google_protobuf_UninterpretedOption, value: google_protobuf_UninterpretedOption_NamePart) = + add(message.name, value) + incl(message.hasField, 2) + +proc name*(message: google_protobuf_UninterpretedOption): seq[google_protobuf_UninterpretedOption_NamePart] {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_UninterpretedOption, value: seq[google_protobuf_UninterpretedOption_NamePart]) {.inline.} = + setname(message, value) + +proc clearidentifier_value*(message: google_protobuf_UninterpretedOption) = + message.identifier_value = "" + excl(message.hasField, [3]) + +proc hasidentifier_value*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 3) + +proc setidentifier_value*(message: google_protobuf_UninterpretedOption, value: string) = + message.identifier_value = value + incl(message.hasField, 3) + +proc identifier_value*(message: google_protobuf_UninterpretedOption): string {.inline.} = + message.identifier_value + +proc `identifier_value=`*(message: google_protobuf_UninterpretedOption, value: string) {.inline.} = + setidentifier_value(message, value) + +proc clearpositive_int_value*(message: google_protobuf_UninterpretedOption) = + message.positive_int_value = 0 + excl(message.hasField, [4]) + +proc haspositive_int_value*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 4) + +proc setpositive_int_value*(message: google_protobuf_UninterpretedOption, value: uint64) = + message.positive_int_value = value + incl(message.hasField, 4) + +proc positive_int_value*(message: google_protobuf_UninterpretedOption): uint64 {.inline.} = + message.positive_int_value + +proc `positive_int_value=`*(message: google_protobuf_UninterpretedOption, value: uint64) {.inline.} = + setpositive_int_value(message, value) + +proc clearnegative_int_value*(message: google_protobuf_UninterpretedOption) = + message.negative_int_value = 0 + excl(message.hasField, [5]) + +proc hasnegative_int_value*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 5) + +proc setnegative_int_value*(message: google_protobuf_UninterpretedOption, value: int64) = + message.negative_int_value = value + incl(message.hasField, 5) + +proc negative_int_value*(message: google_protobuf_UninterpretedOption): int64 {.inline.} = + message.negative_int_value + +proc `negative_int_value=`*(message: google_protobuf_UninterpretedOption, value: int64) {.inline.} = + setnegative_int_value(message, value) + +proc cleardouble_value*(message: google_protobuf_UninterpretedOption) = + message.double_value = 0 + excl(message.hasField, [6]) + +proc hasdouble_value*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 6) + +proc setdouble_value*(message: google_protobuf_UninterpretedOption, value: float64) = + message.double_value = value + incl(message.hasField, 6) + +proc double_value*(message: google_protobuf_UninterpretedOption): float64 {.inline.} = + message.double_value + +proc `double_value=`*(message: google_protobuf_UninterpretedOption, value: float64) {.inline.} = + setdouble_value(message, value) + +proc clearstring_value*(message: google_protobuf_UninterpretedOption) = + message.string_value = bytes("") + excl(message.hasField, [7]) + +proc hasstring_value*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 7) + +proc setstring_value*(message: google_protobuf_UninterpretedOption, value: bytes) = + message.string_value = value + incl(message.hasField, 7) + +proc string_value*(message: google_protobuf_UninterpretedOption): bytes {.inline.} = + message.string_value + +proc `string_value=`*(message: google_protobuf_UninterpretedOption, value: bytes) {.inline.} = + setstring_value(message, value) + +proc clearaggregate_value*(message: google_protobuf_UninterpretedOption) = + message.aggregate_value = "" + excl(message.hasField, [8]) + +proc hasaggregate_value*(message: google_protobuf_UninterpretedOption): bool = + result = contains(message.hasField, 8) + +proc setaggregate_value*(message: google_protobuf_UninterpretedOption, value: string) = + message.aggregate_value = value + incl(message.hasField, 8) + +proc aggregate_value*(message: google_protobuf_UninterpretedOption): string {.inline.} = + message.aggregate_value + +proc `aggregate_value=`*(message: google_protobuf_UninterpretedOption, value: string) {.inline.} = + setaggregate_value(message, value) + +proc sizeOfgoogle_protobuf_UninterpretedOption*(message: google_protobuf_UninterpretedOption): uint64 = + for value in message.name: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption_NamePart(value)) + if hasidentifier_value(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfString(message.identifier_value) + if haspositive_int_value(message): + result = result + sizeOfTag(4, WireType.Varint) + result = result + sizeOfUInt64(message.positive_int_value) + if hasnegative_int_value(message): + result = result + sizeOfTag(5, WireType.Varint) + result = result + sizeOfInt64(message.negative_int_value) + if hasdouble_value(message): + result = result + sizeOfTag(6, WireType.Fixed64) + result = result + sizeOfDouble(message.double_value) + if hasstring_value(message): + result = result + sizeOfTag(7, WireType.LengthDelimited) + result = result + sizeOfBytes(message.string_value) + if hasaggregate_value(message): + result = result + sizeOfTag(8, WireType.LengthDelimited) + result = result + sizeOfString(message.aggregate_value) + +proc writegoogle_protobuf_UninterpretedOption*(stream: ProtobufStream, message: google_protobuf_UninterpretedOption) = + for value in message.name: + writeMessage(stream, value, 2) + if hasidentifier_value(message): + writeString(stream, message.identifier_value, 3) + if haspositive_int_value(message): + writeUInt64(stream, message.positive_int_value, 4) + if hasnegative_int_value(message): + writeInt64(stream, message.negative_int_value, 5) + if hasdouble_value(message): + writeDouble(stream, message.double_value, 6) + if hasstring_value(message): + writeBytes(stream, message.string_value, 7) + if hasaggregate_value(message): + writeString(stream, message.aggregate_value, 8) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_UninterpretedOption*(stream: ProtobufStream): google_protobuf_UninterpretedOption = + result = newgoogle_protobuf_UninterpretedOption() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addname(result, newgoogle_protobuf_UninterpretedOption_NamePart(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + setidentifier_value(result, readString(stream)) + of 4: + expectWireType(wireType, WireType.Varint) + setpositive_int_value(result, readUInt64(stream)) + of 5: + expectWireType(wireType, WireType.Varint) + setnegative_int_value(result, readInt64(stream)) + of 6: + expectWireType(wireType, WireType.Fixed64) + setdouble_value(result, readDouble(stream)) + of 7: + expectWireType(wireType, WireType.LengthDelimited) + setstring_value(result, readBytes(stream)) + of 8: + expectWireType(wireType, WireType.LengthDelimited) + setaggregate_value(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_UninterpretedOption): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_UninterpretedOption(pbs, message) + result = ss.data + +proc newgoogle_protobuf_UninterpretedOption*(data: string): google_protobuf_UninterpretedOption = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_UninterpretedOption(pbs) + + +proc newgoogle_protobuf_EnumValueOptions*(): google_protobuf_EnumValueOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.deprecated = false + result.uninterpreted_option = @[] + +proc cleardeprecated*(message: google_protobuf_EnumValueOptions) = + message.deprecated = false + excl(message.hasField, [1]) + +proc hasdeprecated*(message: google_protobuf_EnumValueOptions): bool = + result = contains(message.hasField, 1) + +proc setdeprecated*(message: google_protobuf_EnumValueOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 1) + +proc deprecated*(message: google_protobuf_EnumValueOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_EnumValueOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_EnumValueOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_EnumValueOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_EnumValueOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_EnumValueOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_EnumValueOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_EnumValueOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_EnumValueOptions*(message: google_protobuf_EnumValueOptions): uint64 = + if hasdeprecated(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_EnumValueOptions*(stream: ProtobufStream, message: google_protobuf_EnumValueOptions) = + if hasdeprecated(message): + writeBool(stream, message.deprecated, 1) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_EnumValueOptions*(stream: ProtobufStream): google_protobuf_EnumValueOptions = + result = newgoogle_protobuf_EnumValueOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_EnumValueOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_EnumValueOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_EnumValueOptions*(data: string): google_protobuf_EnumValueOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_EnumValueOptions(pbs) + + +proc newgoogle_protobuf_EnumValueDescriptorProto*(): google_protobuf_EnumValueDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.number = 0 + result.options = nil + +proc clearname*(message: google_protobuf_EnumValueDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_EnumValueDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_EnumValueDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_EnumValueDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_EnumValueDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearnumber*(message: google_protobuf_EnumValueDescriptorProto) = + message.number = 0 + excl(message.hasField, [2]) + +proc hasnumber*(message: google_protobuf_EnumValueDescriptorProto): bool = + result = contains(message.hasField, 2) + +proc setnumber*(message: google_protobuf_EnumValueDescriptorProto, value: int32) = + message.number = value + incl(message.hasField, 2) + +proc number*(message: google_protobuf_EnumValueDescriptorProto): int32 {.inline.} = + message.number + +proc `number=`*(message: google_protobuf_EnumValueDescriptorProto, value: int32) {.inline.} = + setnumber(message, value) + +proc clearoptions*(message: google_protobuf_EnumValueDescriptorProto) = + message.options = nil + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_EnumValueDescriptorProto): bool = + result = contains(message.hasField, 3) + +proc setoptions*(message: google_protobuf_EnumValueDescriptorProto, value: google_protobuf_EnumValueOptions) = + message.options = value + incl(message.hasField, 3) + +proc options*(message: google_protobuf_EnumValueDescriptorProto): google_protobuf_EnumValueOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_EnumValueDescriptorProto, value: google_protobuf_EnumValueOptions) {.inline.} = + setoptions(message, value) + +proc sizeOfgoogle_protobuf_EnumValueDescriptorProto*(message: google_protobuf_EnumValueDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasnumber(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.number) + if hasoptions(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumValueOptions(message.options)) + +proc writegoogle_protobuf_EnumValueDescriptorProto*(stream: ProtobufStream, message: google_protobuf_EnumValueDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + if hasnumber(message): + writeInt32(stream, message.number, 2) + if hasoptions(message): + writeMessage(stream, message.options, 3) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_EnumValueDescriptorProto*(stream: ProtobufStream): google_protobuf_EnumValueDescriptorProto = + result = newgoogle_protobuf_EnumValueDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setnumber(result, readInt32(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_EnumValueOptions(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_EnumValueDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_EnumValueDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_EnumValueDescriptorProto*(data: string): google_protobuf_EnumValueDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_EnumValueDescriptorProto(pbs) + + +proc newgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(): google_protobuf_EnumDescriptorProto_EnumReservedRange = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.start = 0 + result.fend = 0 + +proc clearstart*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange) = + message.start = 0 + excl(message.hasField, [1]) + +proc hasstart*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): bool = + result = contains(message.hasField, 1) + +proc setstart*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange, value: int32) = + message.start = value + incl(message.hasField, 1) + +proc start*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): int32 {.inline.} = + message.start + +proc `start=`*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange, value: int32) {.inline.} = + setstart(message, value) + +proc clearfend*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange) = + message.fend = 0 + excl(message.hasField, [2]) + +proc hasfend*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): bool = + result = contains(message.hasField, 2) + +proc setfend*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange, value: int32) = + message.fend = value + incl(message.hasField, 2) + +proc fend*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): int32 {.inline.} = + message.fend + +proc `fend=`*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange, value: int32) {.inline.} = + setfend(message, value) + +proc sizeOfgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): uint64 = + if hasstart(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt32(message.start) + if hasfend(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.fend) + +proc writegoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(stream: ProtobufStream, message: google_protobuf_EnumDescriptorProto_EnumReservedRange) = + if hasstart(message): + writeInt32(stream, message.start, 1) + if hasfend(message): + writeInt32(stream, message.fend, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(stream: ProtobufStream): google_protobuf_EnumDescriptorProto_EnumReservedRange = + result = newgoogle_protobuf_EnumDescriptorProto_EnumReservedRange() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setstart(result, readInt32(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setfend(result, readInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_EnumDescriptorProto_EnumReservedRange): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_EnumDescriptorProto_EnumReservedRange(pbs, message) + result = ss.data + +proc newgoogle_protobuf_EnumDescriptorProto_EnumReservedRange*(data: string): google_protobuf_EnumDescriptorProto_EnumReservedRange = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_EnumDescriptorProto_EnumReservedRange(pbs) + + +proc newgoogle_protobuf_EnumOptions*(): google_protobuf_EnumOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.allow_alias = false + result.deprecated = false + result.uninterpreted_option = @[] + +proc clearallow_alias*(message: google_protobuf_EnumOptions) = + message.allow_alias = false + excl(message.hasField, [2]) + +proc hasallow_alias*(message: google_protobuf_EnumOptions): bool = + result = contains(message.hasField, 2) + +proc setallow_alias*(message: google_protobuf_EnumOptions, value: bool) = + message.allow_alias = value + incl(message.hasField, 2) + +proc allow_alias*(message: google_protobuf_EnumOptions): bool {.inline.} = + message.allow_alias + +proc `allow_alias=`*(message: google_protobuf_EnumOptions, value: bool) {.inline.} = + setallow_alias(message, value) + +proc cleardeprecated*(message: google_protobuf_EnumOptions) = + message.deprecated = false + excl(message.hasField, [3]) + +proc hasdeprecated*(message: google_protobuf_EnumOptions): bool = + result = contains(message.hasField, 3) + +proc setdeprecated*(message: google_protobuf_EnumOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 3) + +proc deprecated*(message: google_protobuf_EnumOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_EnumOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_EnumOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_EnumOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_EnumOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_EnumOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_EnumOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_EnumOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_EnumOptions*(message: google_protobuf_EnumOptions): uint64 = + if hasallow_alias(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfBool(message.allow_alias) + if hasdeprecated(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_EnumOptions*(stream: ProtobufStream, message: google_protobuf_EnumOptions) = + if hasallow_alias(message): + writeBool(stream, message.allow_alias, 2) + if hasdeprecated(message): + writeBool(stream, message.deprecated, 3) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_EnumOptions*(stream: ProtobufStream): google_protobuf_EnumOptions = + result = newgoogle_protobuf_EnumOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 2: + expectWireType(wireType, WireType.Varint) + setallow_alias(result, readBool(stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_EnumOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_EnumOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_EnumOptions*(data: string): google_protobuf_EnumOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_EnumOptions(pbs) + + +proc newgoogle_protobuf_EnumDescriptorProto*(): google_protobuf_EnumDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.value = @[] + result.options = nil + result.reserved_range = @[] + result.reserved_name = @[] + +proc clearname*(message: google_protobuf_EnumDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_EnumDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_EnumDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_EnumDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_EnumDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearvalue*(message: google_protobuf_EnumDescriptorProto) = + message.value = @[] + excl(message.hasField, [2]) + +proc hasvalue*(message: google_protobuf_EnumDescriptorProto): bool = + result = contains(message.hasField, 2) or (len(message.value) > 0) + +proc setvalue*(message: google_protobuf_EnumDescriptorProto, value: seq[google_protobuf_EnumValueDescriptorProto]) = + message.value = value + incl(message.hasField, 2) + +proc addvalue*(message: google_protobuf_EnumDescriptorProto, value: google_protobuf_EnumValueDescriptorProto) = + add(message.value, value) + incl(message.hasField, 2) + +proc value*(message: google_protobuf_EnumDescriptorProto): seq[google_protobuf_EnumValueDescriptorProto] {.inline.} = + message.value + +proc `value=`*(message: google_protobuf_EnumDescriptorProto, value: seq[google_protobuf_EnumValueDescriptorProto]) {.inline.} = + setvalue(message, value) + +proc clearoptions*(message: google_protobuf_EnumDescriptorProto) = + message.options = nil + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_EnumDescriptorProto): bool = + result = contains(message.hasField, 3) + +proc setoptions*(message: google_protobuf_EnumDescriptorProto, value: google_protobuf_EnumOptions) = + message.options = value + incl(message.hasField, 3) + +proc options*(message: google_protobuf_EnumDescriptorProto): google_protobuf_EnumOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_EnumDescriptorProto, value: google_protobuf_EnumOptions) {.inline.} = + setoptions(message, value) + +proc clearreserved_range*(message: google_protobuf_EnumDescriptorProto) = + message.reserved_range = @[] + excl(message.hasField, [4]) + +proc hasreserved_range*(message: google_protobuf_EnumDescriptorProto): bool = + result = contains(message.hasField, 4) or (len(message.reserved_range) > 0) + +proc setreserved_range*(message: google_protobuf_EnumDescriptorProto, value: seq[google_protobuf_EnumDescriptorProto_EnumReservedRange]) = + message.reserved_range = value + incl(message.hasField, 4) + +proc addreserved_range*(message: google_protobuf_EnumDescriptorProto, value: google_protobuf_EnumDescriptorProto_EnumReservedRange) = + add(message.reserved_range, value) + incl(message.hasField, 4) + +proc reserved_range*(message: google_protobuf_EnumDescriptorProto): seq[google_protobuf_EnumDescriptorProto_EnumReservedRange] {.inline.} = + message.reserved_range + +proc `reserved_range=`*(message: google_protobuf_EnumDescriptorProto, value: seq[google_protobuf_EnumDescriptorProto_EnumReservedRange]) {.inline.} = + setreserved_range(message, value) + +proc clearreserved_name*(message: google_protobuf_EnumDescriptorProto) = + message.reserved_name = @[] + excl(message.hasField, [5]) + +proc hasreserved_name*(message: google_protobuf_EnumDescriptorProto): bool = + result = contains(message.hasField, 5) or (len(message.reserved_name) > 0) + +proc setreserved_name*(message: google_protobuf_EnumDescriptorProto, value: seq[string]) = + message.reserved_name = value + incl(message.hasField, 5) + +proc addreserved_name*(message: google_protobuf_EnumDescriptorProto, value: string) = + add(message.reserved_name, value) + incl(message.hasField, 5) + +proc reserved_name*(message: google_protobuf_EnumDescriptorProto): seq[string] {.inline.} = + message.reserved_name + +proc `reserved_name=`*(message: google_protobuf_EnumDescriptorProto, value: seq[string]) {.inline.} = + setreserved_name(message, value) + +proc sizeOfgoogle_protobuf_EnumDescriptorProto*(message: google_protobuf_EnumDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + for value in message.value: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumValueDescriptorProto(value)) + if hasoptions(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumOptions(message.options)) + for value in message.reserved_range: + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumDescriptorProto_EnumReservedRange(value)) + for value in message.reserved_name: + result = result + sizeOfTag(5, WireType.LengthDelimited) + result = result + sizeOfString(value) + +proc writegoogle_protobuf_EnumDescriptorProto*(stream: ProtobufStream, message: google_protobuf_EnumDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + for value in message.value: + writeMessage(stream, value, 2) + if hasoptions(message): + writeMessage(stream, message.options, 3) + for value in message.reserved_range: + writeMessage(stream, value, 4) + for value in message.reserved_name: + writeString(stream, value, 5) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_EnumDescriptorProto*(stream: ProtobufStream): google_protobuf_EnumDescriptorProto = + result = newgoogle_protobuf_EnumDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addvalue(result, newgoogle_protobuf_EnumValueDescriptorProto(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_EnumOptions(data)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addreserved_range(result, newgoogle_protobuf_EnumDescriptorProto_EnumReservedRange(data)) + of 5: + expectWireType(wireType, WireType.LengthDelimited) + addreserved_name(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_EnumDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_EnumDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_EnumDescriptorProto*(data: string): google_protobuf_EnumDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_EnumDescriptorProto(pbs) + + +proc newgoogle_protobuf_ExtensionRangeOptions*(): google_protobuf_ExtensionRangeOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.uninterpreted_option = @[] + +proc clearuninterpreted_option*(message: google_protobuf_ExtensionRangeOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_ExtensionRangeOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_ExtensionRangeOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_ExtensionRangeOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_ExtensionRangeOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_ExtensionRangeOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_ExtensionRangeOptions*(message: google_protobuf_ExtensionRangeOptions): uint64 = + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_ExtensionRangeOptions*(stream: ProtobufStream, message: google_protobuf_ExtensionRangeOptions) = + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_ExtensionRangeOptions*(stream: ProtobufStream): google_protobuf_ExtensionRangeOptions = + result = newgoogle_protobuf_ExtensionRangeOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_ExtensionRangeOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_ExtensionRangeOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_ExtensionRangeOptions*(data: string): google_protobuf_ExtensionRangeOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_ExtensionRangeOptions(pbs) + + +proc newgoogle_protobuf_SourceCodeInfo_Location*(): google_protobuf_SourceCodeInfo_Location = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.path = @[] + result.span = @[] + result.leading_comments = "" + result.trailing_comments = "" + result.leading_detached_comments = @[] + +proc clearpath*(message: google_protobuf_SourceCodeInfo_Location) = + message.path = @[] + excl(message.hasField, [1]) + +proc haspath*(message: google_protobuf_SourceCodeInfo_Location): bool = + result = contains(message.hasField, 1) or (len(message.path) > 0) + +proc setpath*(message: google_protobuf_SourceCodeInfo_Location, value: seq[int32]) = + message.path = value + incl(message.hasField, 1) + +proc addpath*(message: google_protobuf_SourceCodeInfo_Location, value: int32) = + add(message.path, value) + incl(message.hasField, 1) + +proc path*(message: google_protobuf_SourceCodeInfo_Location): seq[int32] {.inline.} = + message.path + +proc `path=`*(message: google_protobuf_SourceCodeInfo_Location, value: seq[int32]) {.inline.} = + setpath(message, value) + +proc clearspan*(message: google_protobuf_SourceCodeInfo_Location) = + message.span = @[] + excl(message.hasField, [2]) + +proc hasspan*(message: google_protobuf_SourceCodeInfo_Location): bool = + result = contains(message.hasField, 2) or (len(message.span) > 0) + +proc setspan*(message: google_protobuf_SourceCodeInfo_Location, value: seq[int32]) = + message.span = value + incl(message.hasField, 2) + +proc addspan*(message: google_protobuf_SourceCodeInfo_Location, value: int32) = + add(message.span, value) + incl(message.hasField, 2) + +proc span*(message: google_protobuf_SourceCodeInfo_Location): seq[int32] {.inline.} = + message.span + +proc `span=`*(message: google_protobuf_SourceCodeInfo_Location, value: seq[int32]) {.inline.} = + setspan(message, value) + +proc clearleading_comments*(message: google_protobuf_SourceCodeInfo_Location) = + message.leading_comments = "" + excl(message.hasField, [3]) + +proc hasleading_comments*(message: google_protobuf_SourceCodeInfo_Location): bool = + result = contains(message.hasField, 3) + +proc setleading_comments*(message: google_protobuf_SourceCodeInfo_Location, value: string) = + message.leading_comments = value + incl(message.hasField, 3) + +proc leading_comments*(message: google_protobuf_SourceCodeInfo_Location): string {.inline.} = + message.leading_comments + +proc `leading_comments=`*(message: google_protobuf_SourceCodeInfo_Location, value: string) {.inline.} = + setleading_comments(message, value) + +proc cleartrailing_comments*(message: google_protobuf_SourceCodeInfo_Location) = + message.trailing_comments = "" + excl(message.hasField, [4]) + +proc hastrailing_comments*(message: google_protobuf_SourceCodeInfo_Location): bool = + result = contains(message.hasField, 4) + +proc settrailing_comments*(message: google_protobuf_SourceCodeInfo_Location, value: string) = + message.trailing_comments = value + incl(message.hasField, 4) + +proc trailing_comments*(message: google_protobuf_SourceCodeInfo_Location): string {.inline.} = + message.trailing_comments + +proc `trailing_comments=`*(message: google_protobuf_SourceCodeInfo_Location, value: string) {.inline.} = + settrailing_comments(message, value) + +proc clearleading_detached_comments*(message: google_protobuf_SourceCodeInfo_Location) = + message.leading_detached_comments = @[] + excl(message.hasField, [6]) + +proc hasleading_detached_comments*(message: google_protobuf_SourceCodeInfo_Location): bool = + result = contains(message.hasField, 6) or (len(message.leading_detached_comments) > 0) + +proc setleading_detached_comments*(message: google_protobuf_SourceCodeInfo_Location, value: seq[string]) = + message.leading_detached_comments = value + incl(message.hasField, 6) + +proc addleading_detached_comments*(message: google_protobuf_SourceCodeInfo_Location, value: string) = + add(message.leading_detached_comments, value) + incl(message.hasField, 6) + +proc leading_detached_comments*(message: google_protobuf_SourceCodeInfo_Location): seq[string] {.inline.} = + message.leading_detached_comments + +proc `leading_detached_comments=`*(message: google_protobuf_SourceCodeInfo_Location, value: seq[string]) {.inline.} = + setleading_detached_comments(message, value) + +proc sizeOfgoogle_protobuf_SourceCodeInfo_Location*(message: google_protobuf_SourceCodeInfo_Location): uint64 = + if haspath(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(packedFieldSize(message.path, FieldType.Int32)) + if hasspan(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(packedFieldSize(message.span, FieldType.Int32)) + if hasleading_comments(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfString(message.leading_comments) + if hastrailing_comments(message): + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfString(message.trailing_comments) + for value in message.leading_detached_comments: + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfString(value) + +proc writegoogle_protobuf_SourceCodeInfo_Location*(stream: ProtobufStream, message: google_protobuf_SourceCodeInfo_Location) = + if haspath(message): + writeTag(stream, 1, WireType.LengthDelimited) + writeVarint(stream, packedFieldSize(message.path, FieldType.Int32)) + for value in message.path: + writeInt32(stream, value) + if hasspan(message): + writeTag(stream, 2, WireType.LengthDelimited) + writeVarint(stream, packedFieldSize(message.span, FieldType.Int32)) + for value in message.span: + writeInt32(stream, value) + if hasleading_comments(message): + writeString(stream, message.leading_comments, 3) + if hastrailing_comments(message): + writeString(stream, message.trailing_comments, 4) + for value in message.leading_detached_comments: + writeString(stream, value, 6) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_SourceCodeInfo_Location*(stream: ProtobufStream): google_protobuf_SourceCodeInfo_Location = + result = newgoogle_protobuf_SourceCodeInfo_Location() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint, WireType.LengthDelimited) + if wireType == WireType.LengthDelimited: + let + size = readVarint(stream) + start = uint64(getPosition(stream)) + var consumed = 0'u64 + while consumed < size: + addpath(result, readInt32(stream)) + consumed = uint64(getPosition(stream)) - start + if consumed != size: + raise newException(Exception, "packed field size mismatch") + else: + addpath(result, readInt32(stream)) + of 2: + expectWireType(wireType, WireType.Varint, WireType.LengthDelimited) + if wireType == WireType.LengthDelimited: + let + size = readVarint(stream) + start = uint64(getPosition(stream)) + var consumed = 0'u64 + while consumed < size: + addspan(result, readInt32(stream)) + consumed = uint64(getPosition(stream)) - start + if consumed != size: + raise newException(Exception, "packed field size mismatch") + else: + addspan(result, readInt32(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + setleading_comments(result, readString(stream)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + settrailing_comments(result, readString(stream)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + addleading_detached_comments(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_SourceCodeInfo_Location): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_SourceCodeInfo_Location(pbs, message) + result = ss.data + +proc newgoogle_protobuf_SourceCodeInfo_Location*(data: string): google_protobuf_SourceCodeInfo_Location = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_SourceCodeInfo_Location(pbs) + + +proc newgoogle_protobuf_SourceCodeInfo*(): google_protobuf_SourceCodeInfo = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.location = @[] + +proc clearlocation*(message: google_protobuf_SourceCodeInfo) = + message.location = @[] + excl(message.hasField, [1]) + +proc haslocation*(message: google_protobuf_SourceCodeInfo): bool = + result = contains(message.hasField, 1) or (len(message.location) > 0) + +proc setlocation*(message: google_protobuf_SourceCodeInfo, value: seq[google_protobuf_SourceCodeInfo_Location]) = + message.location = value + incl(message.hasField, 1) + +proc addlocation*(message: google_protobuf_SourceCodeInfo, value: google_protobuf_SourceCodeInfo_Location) = + add(message.location, value) + incl(message.hasField, 1) + +proc location*(message: google_protobuf_SourceCodeInfo): seq[google_protobuf_SourceCodeInfo_Location] {.inline.} = + message.location + +proc `location=`*(message: google_protobuf_SourceCodeInfo, value: seq[google_protobuf_SourceCodeInfo_Location]) {.inline.} = + setlocation(message, value) + +proc sizeOfgoogle_protobuf_SourceCodeInfo*(message: google_protobuf_SourceCodeInfo): uint64 = + for value in message.location: + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceCodeInfo_Location(value)) + +proc writegoogle_protobuf_SourceCodeInfo*(stream: ProtobufStream, message: google_protobuf_SourceCodeInfo) = + for value in message.location: + writeMessage(stream, value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_SourceCodeInfo*(stream: ProtobufStream): google_protobuf_SourceCodeInfo = + result = newgoogle_protobuf_SourceCodeInfo() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addlocation(result, newgoogle_protobuf_SourceCodeInfo_Location(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_SourceCodeInfo): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_SourceCodeInfo(pbs, message) + result = ss.data + +proc newgoogle_protobuf_SourceCodeInfo*(data: string): google_protobuf_SourceCodeInfo = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_SourceCodeInfo(pbs) + + +proc newgoogle_protobuf_FieldOptions*(): google_protobuf_FieldOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.ctype = google_protobuf_FieldOptions_CType.STRING + result.packed = false + result.jstype = google_protobuf_FieldOptions_JSType.JS_NORMAL + result.lazy = false + result.deprecated = false + result.weak = false + result.uninterpreted_option = @[] + +proc clearctype*(message: google_protobuf_FieldOptions) = + message.ctype = google_protobuf_FieldOptions_CType.STRING + excl(message.hasField, [1]) + +proc hasctype*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 1) + +proc setctype*(message: google_protobuf_FieldOptions, value: google_protobuf_FieldOptions_CType) = + message.ctype = value + incl(message.hasField, 1) + +proc ctype*(message: google_protobuf_FieldOptions): google_protobuf_FieldOptions_CType {.inline.} = + message.ctype + +proc `ctype=`*(message: google_protobuf_FieldOptions, value: google_protobuf_FieldOptions_CType) {.inline.} = + setctype(message, value) + +proc clearpacked*(message: google_protobuf_FieldOptions) = + message.packed = false + excl(message.hasField, [2]) + +proc haspacked*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 2) + +proc setpacked*(message: google_protobuf_FieldOptions, value: bool) = + message.packed = value + incl(message.hasField, 2) + +proc packed*(message: google_protobuf_FieldOptions): bool {.inline.} = + message.packed + +proc `packed=`*(message: google_protobuf_FieldOptions, value: bool) {.inline.} = + setpacked(message, value) + +proc clearjstype*(message: google_protobuf_FieldOptions) = + message.jstype = google_protobuf_FieldOptions_JSType.JS_NORMAL + excl(message.hasField, [6]) + +proc hasjstype*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 6) + +proc setjstype*(message: google_protobuf_FieldOptions, value: google_protobuf_FieldOptions_JSType) = + message.jstype = value + incl(message.hasField, 6) + +proc jstype*(message: google_protobuf_FieldOptions): google_protobuf_FieldOptions_JSType {.inline.} = + message.jstype + +proc `jstype=`*(message: google_protobuf_FieldOptions, value: google_protobuf_FieldOptions_JSType) {.inline.} = + setjstype(message, value) + +proc clearlazy*(message: google_protobuf_FieldOptions) = + message.lazy = false + excl(message.hasField, [5]) + +proc haslazy*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 5) + +proc setlazy*(message: google_protobuf_FieldOptions, value: bool) = + message.lazy = value + incl(message.hasField, 5) + +proc lazy*(message: google_protobuf_FieldOptions): bool {.inline.} = + message.lazy + +proc `lazy=`*(message: google_protobuf_FieldOptions, value: bool) {.inline.} = + setlazy(message, value) + +proc cleardeprecated*(message: google_protobuf_FieldOptions) = + message.deprecated = false + excl(message.hasField, [3]) + +proc hasdeprecated*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 3) + +proc setdeprecated*(message: google_protobuf_FieldOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 3) + +proc deprecated*(message: google_protobuf_FieldOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_FieldOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearweak*(message: google_protobuf_FieldOptions) = + message.weak = false + excl(message.hasField, [10]) + +proc hasweak*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 10) + +proc setweak*(message: google_protobuf_FieldOptions, value: bool) = + message.weak = value + incl(message.hasField, 10) + +proc weak*(message: google_protobuf_FieldOptions): bool {.inline.} = + message.weak + +proc `weak=`*(message: google_protobuf_FieldOptions, value: bool) {.inline.} = + setweak(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_FieldOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_FieldOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_FieldOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_FieldOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_FieldOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_FieldOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_FieldOptions*(message: google_protobuf_FieldOptions): uint64 = + if hasctype(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_FieldOptions_CType](message.ctype) + if haspacked(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfBool(message.packed) + if hasjstype(message): + result = result + sizeOfTag(6, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_FieldOptions_JSType](message.jstype) + if haslazy(message): + result = result + sizeOfTag(5, WireType.Varint) + result = result + sizeOfBool(message.lazy) + if hasdeprecated(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + if hasweak(message): + result = result + sizeOfTag(10, WireType.Varint) + result = result + sizeOfBool(message.weak) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_FieldOptions*(stream: ProtobufStream, message: google_protobuf_FieldOptions) = + if hasctype(message): + writeEnum(stream, message.ctype, 1) + if haspacked(message): + writeBool(stream, message.packed, 2) + if hasjstype(message): + writeEnum(stream, message.jstype, 6) + if haslazy(message): + writeBool(stream, message.lazy, 5) + if hasdeprecated(message): + writeBool(stream, message.deprecated, 3) + if hasweak(message): + writeBool(stream, message.weak, 10) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FieldOptions*(stream: ProtobufStream): google_protobuf_FieldOptions = + result = newgoogle_protobuf_FieldOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setctype(result, readEnum[google_protobuf_FieldOptions_CType](stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setpacked(result, readBool(stream)) + of 6: + expectWireType(wireType, WireType.Varint) + setjstype(result, readEnum[google_protobuf_FieldOptions_JSType](stream)) + of 5: + expectWireType(wireType, WireType.Varint) + setlazy(result, readBool(stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 10: + expectWireType(wireType, WireType.Varint) + setweak(result, readBool(stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FieldOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FieldOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FieldOptions*(data: string): google_protobuf_FieldOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FieldOptions(pbs) + + +proc newgoogle_protobuf_FieldDescriptorProto*(): google_protobuf_FieldDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.number = 0 + result.label = google_protobuf_FieldDescriptorProto_Label.LABEL_OPTIONAL + result.ftype = google_protobuf_FieldDescriptorProto_Type.TYPE_DOUBLE + result.type_name = "" + result.extendee = "" + result.default_value = "" + result.oneof_index = 0 + result.json_name = "" + result.options = nil + +proc clearname*(message: google_protobuf_FieldDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_FieldDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_FieldDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_FieldDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearnumber*(message: google_protobuf_FieldDescriptorProto) = + message.number = 0 + excl(message.hasField, [3]) + +proc hasnumber*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 3) + +proc setnumber*(message: google_protobuf_FieldDescriptorProto, value: int32) = + message.number = value + incl(message.hasField, 3) + +proc number*(message: google_protobuf_FieldDescriptorProto): int32 {.inline.} = + message.number + +proc `number=`*(message: google_protobuf_FieldDescriptorProto, value: int32) {.inline.} = + setnumber(message, value) + +proc clearlabel*(message: google_protobuf_FieldDescriptorProto) = + message.label = google_protobuf_FieldDescriptorProto_Label.LABEL_OPTIONAL + excl(message.hasField, [4]) + +proc haslabel*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 4) + +proc setlabel*(message: google_protobuf_FieldDescriptorProto, value: google_protobuf_FieldDescriptorProto_Label) = + message.label = value + incl(message.hasField, 4) + +proc label*(message: google_protobuf_FieldDescriptorProto): google_protobuf_FieldDescriptorProto_Label {.inline.} = + message.label + +proc `label=`*(message: google_protobuf_FieldDescriptorProto, value: google_protobuf_FieldDescriptorProto_Label) {.inline.} = + setlabel(message, value) + +proc clearftype*(message: google_protobuf_FieldDescriptorProto) = + message.ftype = google_protobuf_FieldDescriptorProto_Type.TYPE_DOUBLE + excl(message.hasField, [5]) + +proc hasftype*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 5) + +proc setftype*(message: google_protobuf_FieldDescriptorProto, value: google_protobuf_FieldDescriptorProto_Type) = + message.ftype = value + incl(message.hasField, 5) + +proc ftype*(message: google_protobuf_FieldDescriptorProto): google_protobuf_FieldDescriptorProto_Type {.inline.} = + message.ftype + +proc `ftype=`*(message: google_protobuf_FieldDescriptorProto, value: google_protobuf_FieldDescriptorProto_Type) {.inline.} = + setftype(message, value) + +proc cleartype_name*(message: google_protobuf_FieldDescriptorProto) = + message.type_name = "" + excl(message.hasField, [6]) + +proc hastype_name*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 6) + +proc settype_name*(message: google_protobuf_FieldDescriptorProto, value: string) = + message.type_name = value + incl(message.hasField, 6) + +proc type_name*(message: google_protobuf_FieldDescriptorProto): string {.inline.} = + message.type_name + +proc `type_name=`*(message: google_protobuf_FieldDescriptorProto, value: string) {.inline.} = + settype_name(message, value) + +proc clearextendee*(message: google_protobuf_FieldDescriptorProto) = + message.extendee = "" + excl(message.hasField, [2]) + +proc hasextendee*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 2) + +proc setextendee*(message: google_protobuf_FieldDescriptorProto, value: string) = + message.extendee = value + incl(message.hasField, 2) + +proc extendee*(message: google_protobuf_FieldDescriptorProto): string {.inline.} = + message.extendee + +proc `extendee=`*(message: google_protobuf_FieldDescriptorProto, value: string) {.inline.} = + setextendee(message, value) + +proc cleardefault_value*(message: google_protobuf_FieldDescriptorProto) = + message.default_value = "" + excl(message.hasField, [7]) + +proc hasdefault_value*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 7) + +proc setdefault_value*(message: google_protobuf_FieldDescriptorProto, value: string) = + message.default_value = value + incl(message.hasField, 7) + +proc default_value*(message: google_protobuf_FieldDescriptorProto): string {.inline.} = + message.default_value + +proc `default_value=`*(message: google_protobuf_FieldDescriptorProto, value: string) {.inline.} = + setdefault_value(message, value) + +proc clearoneof_index*(message: google_protobuf_FieldDescriptorProto) = + message.oneof_index = 0 + excl(message.hasField, [9]) + +proc hasoneof_index*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 9) + +proc setoneof_index*(message: google_protobuf_FieldDescriptorProto, value: int32) = + message.oneof_index = value + incl(message.hasField, 9) + +proc oneof_index*(message: google_protobuf_FieldDescriptorProto): int32 {.inline.} = + message.oneof_index + +proc `oneof_index=`*(message: google_protobuf_FieldDescriptorProto, value: int32) {.inline.} = + setoneof_index(message, value) + +proc clearjson_name*(message: google_protobuf_FieldDescriptorProto) = + message.json_name = "" + excl(message.hasField, [10]) + +proc hasjson_name*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 10) + +proc setjson_name*(message: google_protobuf_FieldDescriptorProto, value: string) = + message.json_name = value + incl(message.hasField, 10) + +proc json_name*(message: google_protobuf_FieldDescriptorProto): string {.inline.} = + message.json_name + +proc `json_name=`*(message: google_protobuf_FieldDescriptorProto, value: string) {.inline.} = + setjson_name(message, value) + +proc clearoptions*(message: google_protobuf_FieldDescriptorProto) = + message.options = nil + excl(message.hasField, [8]) + +proc hasoptions*(message: google_protobuf_FieldDescriptorProto): bool = + result = contains(message.hasField, 8) + +proc setoptions*(message: google_protobuf_FieldDescriptorProto, value: google_protobuf_FieldOptions) = + message.options = value + incl(message.hasField, 8) + +proc options*(message: google_protobuf_FieldDescriptorProto): google_protobuf_FieldOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_FieldDescriptorProto, value: google_protobuf_FieldOptions) {.inline.} = + setoptions(message, value) + +proc sizeOfgoogle_protobuf_FieldDescriptorProto*(message: google_protobuf_FieldDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasnumber(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfInt32(message.number) + if haslabel(message): + result = result + sizeOfTag(4, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_FieldDescriptorProto_Label](message.label) + if hasftype(message): + result = result + sizeOfTag(5, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_FieldDescriptorProto_Type](message.ftype) + if hastype_name(message): + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfString(message.type_name) + if hasextendee(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfString(message.extendee) + if hasdefault_value(message): + result = result + sizeOfTag(7, WireType.LengthDelimited) + result = result + sizeOfString(message.default_value) + if hasoneof_index(message): + result = result + sizeOfTag(9, WireType.Varint) + result = result + sizeOfInt32(message.oneof_index) + if hasjson_name(message): + result = result + sizeOfTag(10, WireType.LengthDelimited) + result = result + sizeOfString(message.json_name) + if hasoptions(message): + result = result + sizeOfTag(8, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_FieldOptions(message.options)) + +proc writegoogle_protobuf_FieldDescriptorProto*(stream: ProtobufStream, message: google_protobuf_FieldDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + if hasnumber(message): + writeInt32(stream, message.number, 3) + if haslabel(message): + writeEnum(stream, message.label, 4) + if hasftype(message): + writeEnum(stream, message.ftype, 5) + if hastype_name(message): + writeString(stream, message.type_name, 6) + if hasextendee(message): + writeString(stream, message.extendee, 2) + if hasdefault_value(message): + writeString(stream, message.default_value, 7) + if hasoneof_index(message): + writeInt32(stream, message.oneof_index, 9) + if hasjson_name(message): + writeString(stream, message.json_name, 10) + if hasoptions(message): + writeMessage(stream, message.options, 8) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FieldDescriptorProto*(stream: ProtobufStream): google_protobuf_FieldDescriptorProto = + result = newgoogle_protobuf_FieldDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setnumber(result, readInt32(stream)) + of 4: + expectWireType(wireType, WireType.Varint) + setlabel(result, readEnum[google_protobuf_FieldDescriptorProto_Label](stream)) + of 5: + expectWireType(wireType, WireType.Varint) + setftype(result, readEnum[google_protobuf_FieldDescriptorProto_Type](stream)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + settype_name(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setextendee(result, readString(stream)) + of 7: + expectWireType(wireType, WireType.LengthDelimited) + setdefault_value(result, readString(stream)) + of 9: + expectWireType(wireType, WireType.Varint) + setoneof_index(result, readInt32(stream)) + of 10: + expectWireType(wireType, WireType.LengthDelimited) + setjson_name(result, readString(stream)) + of 8: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_FieldOptions(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FieldDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FieldDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FieldDescriptorProto*(data: string): google_protobuf_FieldDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FieldDescriptorProto(pbs) + + +proc newgoogle_protobuf_DescriptorProto_ExtensionRange*(): google_protobuf_DescriptorProto_ExtensionRange = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.start = 0 + result.fend = 0 + result.options = nil + +proc clearstart*(message: google_protobuf_DescriptorProto_ExtensionRange) = + message.start = 0 + excl(message.hasField, [1]) + +proc hasstart*(message: google_protobuf_DescriptorProto_ExtensionRange): bool = + result = contains(message.hasField, 1) + +proc setstart*(message: google_protobuf_DescriptorProto_ExtensionRange, value: int32) = + message.start = value + incl(message.hasField, 1) + +proc start*(message: google_protobuf_DescriptorProto_ExtensionRange): int32 {.inline.} = + message.start + +proc `start=`*(message: google_protobuf_DescriptorProto_ExtensionRange, value: int32) {.inline.} = + setstart(message, value) + +proc clearfend*(message: google_protobuf_DescriptorProto_ExtensionRange) = + message.fend = 0 + excl(message.hasField, [2]) + +proc hasfend*(message: google_protobuf_DescriptorProto_ExtensionRange): bool = + result = contains(message.hasField, 2) + +proc setfend*(message: google_protobuf_DescriptorProto_ExtensionRange, value: int32) = + message.fend = value + incl(message.hasField, 2) + +proc fend*(message: google_protobuf_DescriptorProto_ExtensionRange): int32 {.inline.} = + message.fend + +proc `fend=`*(message: google_protobuf_DescriptorProto_ExtensionRange, value: int32) {.inline.} = + setfend(message, value) + +proc clearoptions*(message: google_protobuf_DescriptorProto_ExtensionRange) = + message.options = nil + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_DescriptorProto_ExtensionRange): bool = + result = contains(message.hasField, 3) + +proc setoptions*(message: google_protobuf_DescriptorProto_ExtensionRange, value: google_protobuf_ExtensionRangeOptions) = + message.options = value + incl(message.hasField, 3) + +proc options*(message: google_protobuf_DescriptorProto_ExtensionRange): google_protobuf_ExtensionRangeOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_DescriptorProto_ExtensionRange, value: google_protobuf_ExtensionRangeOptions) {.inline.} = + setoptions(message, value) + +proc sizeOfgoogle_protobuf_DescriptorProto_ExtensionRange*(message: google_protobuf_DescriptorProto_ExtensionRange): uint64 = + if hasstart(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt32(message.start) + if hasfend(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.fend) + if hasoptions(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_ExtensionRangeOptions(message.options)) + +proc writegoogle_protobuf_DescriptorProto_ExtensionRange*(stream: ProtobufStream, message: google_protobuf_DescriptorProto_ExtensionRange) = + if hasstart(message): + writeInt32(stream, message.start, 1) + if hasfend(message): + writeInt32(stream, message.fend, 2) + if hasoptions(message): + writeMessage(stream, message.options, 3) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_DescriptorProto_ExtensionRange*(stream: ProtobufStream): google_protobuf_DescriptorProto_ExtensionRange = + result = newgoogle_protobuf_DescriptorProto_ExtensionRange() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setstart(result, readInt32(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setfend(result, readInt32(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_ExtensionRangeOptions(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_DescriptorProto_ExtensionRange): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_DescriptorProto_ExtensionRange(pbs, message) + result = ss.data + +proc newgoogle_protobuf_DescriptorProto_ExtensionRange*(data: string): google_protobuf_DescriptorProto_ExtensionRange = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_DescriptorProto_ExtensionRange(pbs) + + +proc newgoogle_protobuf_MessageOptions*(): google_protobuf_MessageOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.message_set_wire_format = false + result.no_standard_descriptor_accessor = false + result.deprecated = false + result.map_entry = false + result.uninterpreted_option = @[] + +proc clearmessage_set_wire_format*(message: google_protobuf_MessageOptions) = + message.message_set_wire_format = false + excl(message.hasField, [1]) + +proc hasmessage_set_wire_format*(message: google_protobuf_MessageOptions): bool = + result = contains(message.hasField, 1) + +proc setmessage_set_wire_format*(message: google_protobuf_MessageOptions, value: bool) = + message.message_set_wire_format = value + incl(message.hasField, 1) + +proc message_set_wire_format*(message: google_protobuf_MessageOptions): bool {.inline.} = + message.message_set_wire_format + +proc `message_set_wire_format=`*(message: google_protobuf_MessageOptions, value: bool) {.inline.} = + setmessage_set_wire_format(message, value) + +proc clearno_standard_descriptor_accessor*(message: google_protobuf_MessageOptions) = + message.no_standard_descriptor_accessor = false + excl(message.hasField, [2]) + +proc hasno_standard_descriptor_accessor*(message: google_protobuf_MessageOptions): bool = + result = contains(message.hasField, 2) + +proc setno_standard_descriptor_accessor*(message: google_protobuf_MessageOptions, value: bool) = + message.no_standard_descriptor_accessor = value + incl(message.hasField, 2) + +proc no_standard_descriptor_accessor*(message: google_protobuf_MessageOptions): bool {.inline.} = + message.no_standard_descriptor_accessor + +proc `no_standard_descriptor_accessor=`*(message: google_protobuf_MessageOptions, value: bool) {.inline.} = + setno_standard_descriptor_accessor(message, value) + +proc cleardeprecated*(message: google_protobuf_MessageOptions) = + message.deprecated = false + excl(message.hasField, [3]) + +proc hasdeprecated*(message: google_protobuf_MessageOptions): bool = + result = contains(message.hasField, 3) + +proc setdeprecated*(message: google_protobuf_MessageOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 3) + +proc deprecated*(message: google_protobuf_MessageOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_MessageOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearmap_entry*(message: google_protobuf_MessageOptions) = + message.map_entry = false + excl(message.hasField, [7]) + +proc hasmap_entry*(message: google_protobuf_MessageOptions): bool = + result = contains(message.hasField, 7) + +proc setmap_entry*(message: google_protobuf_MessageOptions, value: bool) = + message.map_entry = value + incl(message.hasField, 7) + +proc map_entry*(message: google_protobuf_MessageOptions): bool {.inline.} = + message.map_entry + +proc `map_entry=`*(message: google_protobuf_MessageOptions, value: bool) {.inline.} = + setmap_entry(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_MessageOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_MessageOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_MessageOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_MessageOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_MessageOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_MessageOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_MessageOptions*(message: google_protobuf_MessageOptions): uint64 = + if hasmessage_set_wire_format(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfBool(message.message_set_wire_format) + if hasno_standard_descriptor_accessor(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfBool(message.no_standard_descriptor_accessor) + if hasdeprecated(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + if hasmap_entry(message): + result = result + sizeOfTag(7, WireType.Varint) + result = result + sizeOfBool(message.map_entry) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_MessageOptions*(stream: ProtobufStream, message: google_protobuf_MessageOptions) = + if hasmessage_set_wire_format(message): + writeBool(stream, message.message_set_wire_format, 1) + if hasno_standard_descriptor_accessor(message): + writeBool(stream, message.no_standard_descriptor_accessor, 2) + if hasdeprecated(message): + writeBool(stream, message.deprecated, 3) + if hasmap_entry(message): + writeBool(stream, message.map_entry, 7) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_MessageOptions*(stream: ProtobufStream): google_protobuf_MessageOptions = + result = newgoogle_protobuf_MessageOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setmessage_set_wire_format(result, readBool(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setno_standard_descriptor_accessor(result, readBool(stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 7: + expectWireType(wireType, WireType.Varint) + setmap_entry(result, readBool(stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_MessageOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_MessageOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_MessageOptions*(data: string): google_protobuf_MessageOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_MessageOptions(pbs) + + +proc newgoogle_protobuf_OneofOptions*(): google_protobuf_OneofOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.uninterpreted_option = @[] + +proc clearuninterpreted_option*(message: google_protobuf_OneofOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_OneofOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_OneofOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_OneofOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_OneofOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_OneofOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_OneofOptions*(message: google_protobuf_OneofOptions): uint64 = + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_OneofOptions*(stream: ProtobufStream, message: google_protobuf_OneofOptions) = + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_OneofOptions*(stream: ProtobufStream): google_protobuf_OneofOptions = + result = newgoogle_protobuf_OneofOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_OneofOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_OneofOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_OneofOptions*(data: string): google_protobuf_OneofOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_OneofOptions(pbs) + + +proc newgoogle_protobuf_OneofDescriptorProto*(): google_protobuf_OneofDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.options = nil + +proc clearname*(message: google_protobuf_OneofDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_OneofDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_OneofDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_OneofDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_OneofDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearoptions*(message: google_protobuf_OneofDescriptorProto) = + message.options = nil + excl(message.hasField, [2]) + +proc hasoptions*(message: google_protobuf_OneofDescriptorProto): bool = + result = contains(message.hasField, 2) + +proc setoptions*(message: google_protobuf_OneofDescriptorProto, value: google_protobuf_OneofOptions) = + message.options = value + incl(message.hasField, 2) + +proc options*(message: google_protobuf_OneofDescriptorProto): google_protobuf_OneofOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_OneofDescriptorProto, value: google_protobuf_OneofOptions) {.inline.} = + setoptions(message, value) + +proc sizeOfgoogle_protobuf_OneofDescriptorProto*(message: google_protobuf_OneofDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasoptions(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_OneofOptions(message.options)) + +proc writegoogle_protobuf_OneofDescriptorProto*(stream: ProtobufStream, message: google_protobuf_OneofDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + if hasoptions(message): + writeMessage(stream, message.options, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_OneofDescriptorProto*(stream: ProtobufStream): google_protobuf_OneofDescriptorProto = + result = newgoogle_protobuf_OneofDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_OneofOptions(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_OneofDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_OneofDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_OneofDescriptorProto*(data: string): google_protobuf_OneofDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_OneofDescriptorProto(pbs) + + +proc newgoogle_protobuf_DescriptorProto_ReservedRange*(): google_protobuf_DescriptorProto_ReservedRange = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.start = 0 + result.fend = 0 + +proc clearstart*(message: google_protobuf_DescriptorProto_ReservedRange) = + message.start = 0 + excl(message.hasField, [1]) + +proc hasstart*(message: google_protobuf_DescriptorProto_ReservedRange): bool = + result = contains(message.hasField, 1) + +proc setstart*(message: google_protobuf_DescriptorProto_ReservedRange, value: int32) = + message.start = value + incl(message.hasField, 1) + +proc start*(message: google_protobuf_DescriptorProto_ReservedRange): int32 {.inline.} = + message.start + +proc `start=`*(message: google_protobuf_DescriptorProto_ReservedRange, value: int32) {.inline.} = + setstart(message, value) + +proc clearfend*(message: google_protobuf_DescriptorProto_ReservedRange) = + message.fend = 0 + excl(message.hasField, [2]) + +proc hasfend*(message: google_protobuf_DescriptorProto_ReservedRange): bool = + result = contains(message.hasField, 2) + +proc setfend*(message: google_protobuf_DescriptorProto_ReservedRange, value: int32) = + message.fend = value + incl(message.hasField, 2) + +proc fend*(message: google_protobuf_DescriptorProto_ReservedRange): int32 {.inline.} = + message.fend + +proc `fend=`*(message: google_protobuf_DescriptorProto_ReservedRange, value: int32) {.inline.} = + setfend(message, value) + +proc sizeOfgoogle_protobuf_DescriptorProto_ReservedRange*(message: google_protobuf_DescriptorProto_ReservedRange): uint64 = + if hasstart(message): + result = result + sizeOfTag(1, WireType.Varint) + result = result + sizeOfInt32(message.start) + if hasfend(message): + result = result + sizeOfTag(2, WireType.Varint) + result = result + sizeOfInt32(message.fend) + +proc writegoogle_protobuf_DescriptorProto_ReservedRange*(stream: ProtobufStream, message: google_protobuf_DescriptorProto_ReservedRange) = + if hasstart(message): + writeInt32(stream, message.start, 1) + if hasfend(message): + writeInt32(stream, message.fend, 2) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_DescriptorProto_ReservedRange*(stream: ProtobufStream): google_protobuf_DescriptorProto_ReservedRange = + result = newgoogle_protobuf_DescriptorProto_ReservedRange() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint) + setstart(result, readInt32(stream)) + of 2: + expectWireType(wireType, WireType.Varint) + setfend(result, readInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_DescriptorProto_ReservedRange): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_DescriptorProto_ReservedRange(pbs, message) + result = ss.data + +proc newgoogle_protobuf_DescriptorProto_ReservedRange*(data: string): google_protobuf_DescriptorProto_ReservedRange = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_DescriptorProto_ReservedRange(pbs) + + +proc newgoogle_protobuf_DescriptorProto*(): google_protobuf_DescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.field = @[] + result.extension = @[] + result.nested_type = @[] + result.enum_type = @[] + result.extension_range = @[] + result.oneof_decl = @[] + result.options = nil + result.reserved_range = @[] + result.reserved_name = @[] + +proc clearname*(message: google_protobuf_DescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_DescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_DescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_DescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearfield*(message: google_protobuf_DescriptorProto) = + message.field = @[] + excl(message.hasField, [2]) + +proc hasfield*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 2) or (len(message.field) > 0) + +proc setfield*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_FieldDescriptorProto]) = + message.field = value + incl(message.hasField, 2) + +proc addfield*(message: google_protobuf_DescriptorProto, value: google_protobuf_FieldDescriptorProto) = + add(message.field, value) + incl(message.hasField, 2) + +proc field*(message: google_protobuf_DescriptorProto): seq[google_protobuf_FieldDescriptorProto] {.inline.} = + message.field + +proc `field=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_FieldDescriptorProto]) {.inline.} = + setfield(message, value) + +proc clearextension*(message: google_protobuf_DescriptorProto) = + message.extension = @[] + excl(message.hasField, [6]) + +proc hasextension*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 6) or (len(message.extension) > 0) + +proc setextension*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_FieldDescriptorProto]) = + message.extension = value + incl(message.hasField, 6) + +proc addextension*(message: google_protobuf_DescriptorProto, value: google_protobuf_FieldDescriptorProto) = + add(message.extension, value) + incl(message.hasField, 6) + +proc extension*(message: google_protobuf_DescriptorProto): seq[google_protobuf_FieldDescriptorProto] {.inline.} = + message.extension + +proc `extension=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_FieldDescriptorProto]) {.inline.} = + setextension(message, value) + +proc clearnested_type*(message: google_protobuf_DescriptorProto) = + message.nested_type = @[] + excl(message.hasField, [3]) + +proc hasnested_type*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 3) or (len(message.nested_type) > 0) + +proc setnested_type*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_DescriptorProto]) = + message.nested_type = value + incl(message.hasField, 3) + +proc addnested_type*(message: google_protobuf_DescriptorProto, value: google_protobuf_DescriptorProto) = + add(message.nested_type, value) + incl(message.hasField, 3) + +proc nested_type*(message: google_protobuf_DescriptorProto): seq[google_protobuf_DescriptorProto] {.inline.} = + message.nested_type + +proc `nested_type=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_DescriptorProto]) {.inline.} = + setnested_type(message, value) + +proc clearenum_type*(message: google_protobuf_DescriptorProto) = + message.enum_type = @[] + excl(message.hasField, [4]) + +proc hasenum_type*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 4) or (len(message.enum_type) > 0) + +proc setenum_type*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_EnumDescriptorProto]) = + message.enum_type = value + incl(message.hasField, 4) + +proc addenum_type*(message: google_protobuf_DescriptorProto, value: google_protobuf_EnumDescriptorProto) = + add(message.enum_type, value) + incl(message.hasField, 4) + +proc enum_type*(message: google_protobuf_DescriptorProto): seq[google_protobuf_EnumDescriptorProto] {.inline.} = + message.enum_type + +proc `enum_type=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_EnumDescriptorProto]) {.inline.} = + setenum_type(message, value) + +proc clearextension_range*(message: google_protobuf_DescriptorProto) = + message.extension_range = @[] + excl(message.hasField, [5]) + +proc hasextension_range*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 5) or (len(message.extension_range) > 0) + +proc setextension_range*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_DescriptorProto_ExtensionRange]) = + message.extension_range = value + incl(message.hasField, 5) + +proc addextension_range*(message: google_protobuf_DescriptorProto, value: google_protobuf_DescriptorProto_ExtensionRange) = + add(message.extension_range, value) + incl(message.hasField, 5) + +proc extension_range*(message: google_protobuf_DescriptorProto): seq[google_protobuf_DescriptorProto_ExtensionRange] {.inline.} = + message.extension_range + +proc `extension_range=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_DescriptorProto_ExtensionRange]) {.inline.} = + setextension_range(message, value) + +proc clearoneof_decl*(message: google_protobuf_DescriptorProto) = + message.oneof_decl = @[] + excl(message.hasField, [8]) + +proc hasoneof_decl*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 8) or (len(message.oneof_decl) > 0) + +proc setoneof_decl*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_OneofDescriptorProto]) = + message.oneof_decl = value + incl(message.hasField, 8) + +proc addoneof_decl*(message: google_protobuf_DescriptorProto, value: google_protobuf_OneofDescriptorProto) = + add(message.oneof_decl, value) + incl(message.hasField, 8) + +proc oneof_decl*(message: google_protobuf_DescriptorProto): seq[google_protobuf_OneofDescriptorProto] {.inline.} = + message.oneof_decl + +proc `oneof_decl=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_OneofDescriptorProto]) {.inline.} = + setoneof_decl(message, value) + +proc clearoptions*(message: google_protobuf_DescriptorProto) = + message.options = nil + excl(message.hasField, [7]) + +proc hasoptions*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 7) + +proc setoptions*(message: google_protobuf_DescriptorProto, value: google_protobuf_MessageOptions) = + message.options = value + incl(message.hasField, 7) + +proc options*(message: google_protobuf_DescriptorProto): google_protobuf_MessageOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_DescriptorProto, value: google_protobuf_MessageOptions) {.inline.} = + setoptions(message, value) + +proc clearreserved_range*(message: google_protobuf_DescriptorProto) = + message.reserved_range = @[] + excl(message.hasField, [9]) + +proc hasreserved_range*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 9) or (len(message.reserved_range) > 0) + +proc setreserved_range*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_DescriptorProto_ReservedRange]) = + message.reserved_range = value + incl(message.hasField, 9) + +proc addreserved_range*(message: google_protobuf_DescriptorProto, value: google_protobuf_DescriptorProto_ReservedRange) = + add(message.reserved_range, value) + incl(message.hasField, 9) + +proc reserved_range*(message: google_protobuf_DescriptorProto): seq[google_protobuf_DescriptorProto_ReservedRange] {.inline.} = + message.reserved_range + +proc `reserved_range=`*(message: google_protobuf_DescriptorProto, value: seq[google_protobuf_DescriptorProto_ReservedRange]) {.inline.} = + setreserved_range(message, value) + +proc clearreserved_name*(message: google_protobuf_DescriptorProto) = + message.reserved_name = @[] + excl(message.hasField, [10]) + +proc hasreserved_name*(message: google_protobuf_DescriptorProto): bool = + result = contains(message.hasField, 10) or (len(message.reserved_name) > 0) + +proc setreserved_name*(message: google_protobuf_DescriptorProto, value: seq[string]) = + message.reserved_name = value + incl(message.hasField, 10) + +proc addreserved_name*(message: google_protobuf_DescriptorProto, value: string) = + add(message.reserved_name, value) + incl(message.hasField, 10) + +proc reserved_name*(message: google_protobuf_DescriptorProto): seq[string] {.inline.} = + message.reserved_name + +proc `reserved_name=`*(message: google_protobuf_DescriptorProto, value: seq[string]) {.inline.} = + setreserved_name(message, value) + +proc sizeOfgoogle_protobuf_DescriptorProto*(message: google_protobuf_DescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + for value in message.field: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_FieldDescriptorProto(value)) + for value in message.extension: + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_FieldDescriptorProto(value)) + for value in message.nested_type: + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_DescriptorProto(value)) + for value in message.enum_type: + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumDescriptorProto(value)) + for value in message.extension_range: + result = result + sizeOfTag(5, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_DescriptorProto_ExtensionRange(value)) + for value in message.oneof_decl: + result = result + sizeOfTag(8, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_OneofDescriptorProto(value)) + if hasoptions(message): + result = result + sizeOfTag(7, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_MessageOptions(message.options)) + for value in message.reserved_range: + result = result + sizeOfTag(9, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_DescriptorProto_ReservedRange(value)) + for value in message.reserved_name: + result = result + sizeOfTag(10, WireType.LengthDelimited) + result = result + sizeOfString(value) + +proc writegoogle_protobuf_DescriptorProto*(stream: ProtobufStream, message: google_protobuf_DescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + for value in message.field: + writeMessage(stream, value, 2) + for value in message.extension: + writeMessage(stream, value, 6) + for value in message.nested_type: + writeMessage(stream, value, 3) + for value in message.enum_type: + writeMessage(stream, value, 4) + for value in message.extension_range: + writeMessage(stream, value, 5) + for value in message.oneof_decl: + writeMessage(stream, value, 8) + if hasoptions(message): + writeMessage(stream, message.options, 7) + for value in message.reserved_range: + writeMessage(stream, value, 9) + for value in message.reserved_name: + writeString(stream, value, 10) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_DescriptorProto*(stream: ProtobufStream): google_protobuf_DescriptorProto = + result = newgoogle_protobuf_DescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addfield(result, newgoogle_protobuf_FieldDescriptorProto(data)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addextension(result, newgoogle_protobuf_FieldDescriptorProto(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addnested_type(result, newgoogle_protobuf_DescriptorProto(data)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addenum_type(result, newgoogle_protobuf_EnumDescriptorProto(data)) + of 5: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addextension_range(result, newgoogle_protobuf_DescriptorProto_ExtensionRange(data)) + of 8: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addoneof_decl(result, newgoogle_protobuf_OneofDescriptorProto(data)) + of 7: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_MessageOptions(data)) + of 9: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addreserved_range(result, newgoogle_protobuf_DescriptorProto_ReservedRange(data)) + of 10: + expectWireType(wireType, WireType.LengthDelimited) + addreserved_name(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_DescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_DescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_DescriptorProto*(data: string): google_protobuf_DescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_DescriptorProto(pbs) + + +proc newgoogle_protobuf_FileOptions*(): google_protobuf_FileOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.java_package = "" + result.java_outer_classname = "" + result.java_multiple_files = false + result.java_generate_equals_and_hash = false + result.java_string_check_utf8 = false + result.optimize_for = google_protobuf_FileOptions_OptimizeMode.SPEED + result.go_package = "" + result.cc_generic_services = false + result.java_generic_services = false + result.py_generic_services = false + result.php_generic_services = false + result.deprecated = false + result.cc_enable_arenas = false + result.objc_class_prefix = "" + result.csharp_namespace = "" + result.swift_prefix = "" + result.php_class_prefix = "" + result.php_namespace = "" + result.uninterpreted_option = @[] + +proc clearjava_package*(message: google_protobuf_FileOptions) = + message.java_package = "" + excl(message.hasField, [1]) + +proc hasjava_package*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 1) + +proc setjava_package*(message: google_protobuf_FileOptions, value: string) = + message.java_package = value + incl(message.hasField, 1) + +proc java_package*(message: google_protobuf_FileOptions): string {.inline.} = + message.java_package + +proc `java_package=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setjava_package(message, value) + +proc clearjava_outer_classname*(message: google_protobuf_FileOptions) = + message.java_outer_classname = "" + excl(message.hasField, [8]) + +proc hasjava_outer_classname*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 8) + +proc setjava_outer_classname*(message: google_protobuf_FileOptions, value: string) = + message.java_outer_classname = value + incl(message.hasField, 8) + +proc java_outer_classname*(message: google_protobuf_FileOptions): string {.inline.} = + message.java_outer_classname + +proc `java_outer_classname=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setjava_outer_classname(message, value) + +proc clearjava_multiple_files*(message: google_protobuf_FileOptions) = + message.java_multiple_files = false + excl(message.hasField, [10]) + +proc hasjava_multiple_files*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 10) + +proc setjava_multiple_files*(message: google_protobuf_FileOptions, value: bool) = + message.java_multiple_files = value + incl(message.hasField, 10) + +proc java_multiple_files*(message: google_protobuf_FileOptions): bool {.inline.} = + message.java_multiple_files + +proc `java_multiple_files=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setjava_multiple_files(message, value) + +proc clearjava_generate_equals_and_hash*(message: google_protobuf_FileOptions) = + message.java_generate_equals_and_hash = false + excl(message.hasField, [20]) + +proc hasjava_generate_equals_and_hash*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 20) + +proc setjava_generate_equals_and_hash*(message: google_protobuf_FileOptions, value: bool) = + message.java_generate_equals_and_hash = value + incl(message.hasField, 20) + +proc java_generate_equals_and_hash*(message: google_protobuf_FileOptions): bool {.inline.} = + message.java_generate_equals_and_hash + +proc `java_generate_equals_and_hash=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setjava_generate_equals_and_hash(message, value) + +proc clearjava_string_check_utf8*(message: google_protobuf_FileOptions) = + message.java_string_check_utf8 = false + excl(message.hasField, [27]) + +proc hasjava_string_check_utf8*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 27) + +proc setjava_string_check_utf8*(message: google_protobuf_FileOptions, value: bool) = + message.java_string_check_utf8 = value + incl(message.hasField, 27) + +proc java_string_check_utf8*(message: google_protobuf_FileOptions): bool {.inline.} = + message.java_string_check_utf8 + +proc `java_string_check_utf8=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setjava_string_check_utf8(message, value) + +proc clearoptimize_for*(message: google_protobuf_FileOptions) = + message.optimize_for = google_protobuf_FileOptions_OptimizeMode.SPEED + excl(message.hasField, [9]) + +proc hasoptimize_for*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 9) + +proc setoptimize_for*(message: google_protobuf_FileOptions, value: google_protobuf_FileOptions_OptimizeMode) = + message.optimize_for = value + incl(message.hasField, 9) + +proc optimize_for*(message: google_protobuf_FileOptions): google_protobuf_FileOptions_OptimizeMode {.inline.} = + message.optimize_for + +proc `optimize_for=`*(message: google_protobuf_FileOptions, value: google_protobuf_FileOptions_OptimizeMode) {.inline.} = + setoptimize_for(message, value) + +proc cleargo_package*(message: google_protobuf_FileOptions) = + message.go_package = "" + excl(message.hasField, [11]) + +proc hasgo_package*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 11) + +proc setgo_package*(message: google_protobuf_FileOptions, value: string) = + message.go_package = value + incl(message.hasField, 11) + +proc go_package*(message: google_protobuf_FileOptions): string {.inline.} = + message.go_package + +proc `go_package=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setgo_package(message, value) + +proc clearcc_generic_services*(message: google_protobuf_FileOptions) = + message.cc_generic_services = false + excl(message.hasField, [16]) + +proc hascc_generic_services*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 16) + +proc setcc_generic_services*(message: google_protobuf_FileOptions, value: bool) = + message.cc_generic_services = value + incl(message.hasField, 16) + +proc cc_generic_services*(message: google_protobuf_FileOptions): bool {.inline.} = + message.cc_generic_services + +proc `cc_generic_services=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setcc_generic_services(message, value) + +proc clearjava_generic_services*(message: google_protobuf_FileOptions) = + message.java_generic_services = false + excl(message.hasField, [17]) + +proc hasjava_generic_services*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 17) + +proc setjava_generic_services*(message: google_protobuf_FileOptions, value: bool) = + message.java_generic_services = value + incl(message.hasField, 17) + +proc java_generic_services*(message: google_protobuf_FileOptions): bool {.inline.} = + message.java_generic_services + +proc `java_generic_services=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setjava_generic_services(message, value) + +proc clearpy_generic_services*(message: google_protobuf_FileOptions) = + message.py_generic_services = false + excl(message.hasField, [18]) + +proc haspy_generic_services*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 18) + +proc setpy_generic_services*(message: google_protobuf_FileOptions, value: bool) = + message.py_generic_services = value + incl(message.hasField, 18) + +proc py_generic_services*(message: google_protobuf_FileOptions): bool {.inline.} = + message.py_generic_services + +proc `py_generic_services=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setpy_generic_services(message, value) + +proc clearphp_generic_services*(message: google_protobuf_FileOptions) = + message.php_generic_services = false + excl(message.hasField, [42]) + +proc hasphp_generic_services*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 42) + +proc setphp_generic_services*(message: google_protobuf_FileOptions, value: bool) = + message.php_generic_services = value + incl(message.hasField, 42) + +proc php_generic_services*(message: google_protobuf_FileOptions): bool {.inline.} = + message.php_generic_services + +proc `php_generic_services=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setphp_generic_services(message, value) + +proc cleardeprecated*(message: google_protobuf_FileOptions) = + message.deprecated = false + excl(message.hasField, [23]) + +proc hasdeprecated*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 23) + +proc setdeprecated*(message: google_protobuf_FileOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 23) + +proc deprecated*(message: google_protobuf_FileOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearcc_enable_arenas*(message: google_protobuf_FileOptions) = + message.cc_enable_arenas = false + excl(message.hasField, [31]) + +proc hascc_enable_arenas*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 31) + +proc setcc_enable_arenas*(message: google_protobuf_FileOptions, value: bool) = + message.cc_enable_arenas = value + incl(message.hasField, 31) + +proc cc_enable_arenas*(message: google_protobuf_FileOptions): bool {.inline.} = + message.cc_enable_arenas + +proc `cc_enable_arenas=`*(message: google_protobuf_FileOptions, value: bool) {.inline.} = + setcc_enable_arenas(message, value) + +proc clearobjc_class_prefix*(message: google_protobuf_FileOptions) = + message.objc_class_prefix = "" + excl(message.hasField, [36]) + +proc hasobjc_class_prefix*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 36) + +proc setobjc_class_prefix*(message: google_protobuf_FileOptions, value: string) = + message.objc_class_prefix = value + incl(message.hasField, 36) + +proc objc_class_prefix*(message: google_protobuf_FileOptions): string {.inline.} = + message.objc_class_prefix + +proc `objc_class_prefix=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setobjc_class_prefix(message, value) + +proc clearcsharp_namespace*(message: google_protobuf_FileOptions) = + message.csharp_namespace = "" + excl(message.hasField, [37]) + +proc hascsharp_namespace*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 37) + +proc setcsharp_namespace*(message: google_protobuf_FileOptions, value: string) = + message.csharp_namespace = value + incl(message.hasField, 37) + +proc csharp_namespace*(message: google_protobuf_FileOptions): string {.inline.} = + message.csharp_namespace + +proc `csharp_namespace=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setcsharp_namespace(message, value) + +proc clearswift_prefix*(message: google_protobuf_FileOptions) = + message.swift_prefix = "" + excl(message.hasField, [39]) + +proc hasswift_prefix*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 39) + +proc setswift_prefix*(message: google_protobuf_FileOptions, value: string) = + message.swift_prefix = value + incl(message.hasField, 39) + +proc swift_prefix*(message: google_protobuf_FileOptions): string {.inline.} = + message.swift_prefix + +proc `swift_prefix=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setswift_prefix(message, value) + +proc clearphp_class_prefix*(message: google_protobuf_FileOptions) = + message.php_class_prefix = "" + excl(message.hasField, [40]) + +proc hasphp_class_prefix*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 40) + +proc setphp_class_prefix*(message: google_protobuf_FileOptions, value: string) = + message.php_class_prefix = value + incl(message.hasField, 40) + +proc php_class_prefix*(message: google_protobuf_FileOptions): string {.inline.} = + message.php_class_prefix + +proc `php_class_prefix=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setphp_class_prefix(message, value) + +proc clearphp_namespace*(message: google_protobuf_FileOptions) = + message.php_namespace = "" + excl(message.hasField, [41]) + +proc hasphp_namespace*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 41) + +proc setphp_namespace*(message: google_protobuf_FileOptions, value: string) = + message.php_namespace = value + incl(message.hasField, 41) + +proc php_namespace*(message: google_protobuf_FileOptions): string {.inline.} = + message.php_namespace + +proc `php_namespace=`*(message: google_protobuf_FileOptions, value: string) {.inline.} = + setphp_namespace(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_FileOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_FileOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_FileOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_FileOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_FileOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_FileOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_FileOptions*(message: google_protobuf_FileOptions): uint64 = + if hasjava_package(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.java_package) + if hasjava_outer_classname(message): + result = result + sizeOfTag(8, WireType.LengthDelimited) + result = result + sizeOfString(message.java_outer_classname) + if hasjava_multiple_files(message): + result = result + sizeOfTag(10, WireType.Varint) + result = result + sizeOfBool(message.java_multiple_files) + if hasjava_generate_equals_and_hash(message): + result = result + sizeOfTag(20, WireType.Varint) + result = result + sizeOfBool(message.java_generate_equals_and_hash) + if hasjava_string_check_utf8(message): + result = result + sizeOfTag(27, WireType.Varint) + result = result + sizeOfBool(message.java_string_check_utf8) + if hasoptimize_for(message): + result = result + sizeOfTag(9, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_FileOptions_OptimizeMode](message.optimize_for) + if hasgo_package(message): + result = result + sizeOfTag(11, WireType.LengthDelimited) + result = result + sizeOfString(message.go_package) + if hascc_generic_services(message): + result = result + sizeOfTag(16, WireType.Varint) + result = result + sizeOfBool(message.cc_generic_services) + if hasjava_generic_services(message): + result = result + sizeOfTag(17, WireType.Varint) + result = result + sizeOfBool(message.java_generic_services) + if haspy_generic_services(message): + result = result + sizeOfTag(18, WireType.Varint) + result = result + sizeOfBool(message.py_generic_services) + if hasphp_generic_services(message): + result = result + sizeOfTag(42, WireType.Varint) + result = result + sizeOfBool(message.php_generic_services) + if hasdeprecated(message): + result = result + sizeOfTag(23, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + if hascc_enable_arenas(message): + result = result + sizeOfTag(31, WireType.Varint) + result = result + sizeOfBool(message.cc_enable_arenas) + if hasobjc_class_prefix(message): + result = result + sizeOfTag(36, WireType.LengthDelimited) + result = result + sizeOfString(message.objc_class_prefix) + if hascsharp_namespace(message): + result = result + sizeOfTag(37, WireType.LengthDelimited) + result = result + sizeOfString(message.csharp_namespace) + if hasswift_prefix(message): + result = result + sizeOfTag(39, WireType.LengthDelimited) + result = result + sizeOfString(message.swift_prefix) + if hasphp_class_prefix(message): + result = result + sizeOfTag(40, WireType.LengthDelimited) + result = result + sizeOfString(message.php_class_prefix) + if hasphp_namespace(message): + result = result + sizeOfTag(41, WireType.LengthDelimited) + result = result + sizeOfString(message.php_namespace) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_FileOptions*(stream: ProtobufStream, message: google_protobuf_FileOptions) = + if hasjava_package(message): + writeString(stream, message.java_package, 1) + if hasjava_outer_classname(message): + writeString(stream, message.java_outer_classname, 8) + if hasjava_multiple_files(message): + writeBool(stream, message.java_multiple_files, 10) + if hasjava_generate_equals_and_hash(message): + writeBool(stream, message.java_generate_equals_and_hash, 20) + if hasjava_string_check_utf8(message): + writeBool(stream, message.java_string_check_utf8, 27) + if hasoptimize_for(message): + writeEnum(stream, message.optimize_for, 9) + if hasgo_package(message): + writeString(stream, message.go_package, 11) + if hascc_generic_services(message): + writeBool(stream, message.cc_generic_services, 16) + if hasjava_generic_services(message): + writeBool(stream, message.java_generic_services, 17) + if haspy_generic_services(message): + writeBool(stream, message.py_generic_services, 18) + if hasphp_generic_services(message): + writeBool(stream, message.php_generic_services, 42) + if hasdeprecated(message): + writeBool(stream, message.deprecated, 23) + if hascc_enable_arenas(message): + writeBool(stream, message.cc_enable_arenas, 31) + if hasobjc_class_prefix(message): + writeString(stream, message.objc_class_prefix, 36) + if hascsharp_namespace(message): + writeString(stream, message.csharp_namespace, 37) + if hasswift_prefix(message): + writeString(stream, message.swift_prefix, 39) + if hasphp_class_prefix(message): + writeString(stream, message.php_class_prefix, 40) + if hasphp_namespace(message): + writeString(stream, message.php_namespace, 41) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FileOptions*(stream: ProtobufStream): google_protobuf_FileOptions = + result = newgoogle_protobuf_FileOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setjava_package(result, readString(stream)) + of 8: + expectWireType(wireType, WireType.LengthDelimited) + setjava_outer_classname(result, readString(stream)) + of 10: + expectWireType(wireType, WireType.Varint) + setjava_multiple_files(result, readBool(stream)) + of 20: + expectWireType(wireType, WireType.Varint) + setjava_generate_equals_and_hash(result, readBool(stream)) + of 27: + expectWireType(wireType, WireType.Varint) + setjava_string_check_utf8(result, readBool(stream)) + of 9: + expectWireType(wireType, WireType.Varint) + setoptimize_for(result, readEnum[google_protobuf_FileOptions_OptimizeMode](stream)) + of 11: + expectWireType(wireType, WireType.LengthDelimited) + setgo_package(result, readString(stream)) + of 16: + expectWireType(wireType, WireType.Varint) + setcc_generic_services(result, readBool(stream)) + of 17: + expectWireType(wireType, WireType.Varint) + setjava_generic_services(result, readBool(stream)) + of 18: + expectWireType(wireType, WireType.Varint) + setpy_generic_services(result, readBool(stream)) + of 42: + expectWireType(wireType, WireType.Varint) + setphp_generic_services(result, readBool(stream)) + of 23: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 31: + expectWireType(wireType, WireType.Varint) + setcc_enable_arenas(result, readBool(stream)) + of 36: + expectWireType(wireType, WireType.LengthDelimited) + setobjc_class_prefix(result, readString(stream)) + of 37: + expectWireType(wireType, WireType.LengthDelimited) + setcsharp_namespace(result, readString(stream)) + of 39: + expectWireType(wireType, WireType.LengthDelimited) + setswift_prefix(result, readString(stream)) + of 40: + expectWireType(wireType, WireType.LengthDelimited) + setphp_class_prefix(result, readString(stream)) + of 41: + expectWireType(wireType, WireType.LengthDelimited) + setphp_namespace(result, readString(stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FileOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FileOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FileOptions*(data: string): google_protobuf_FileOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FileOptions(pbs) + + +proc newgoogle_protobuf_ServiceOptions*(): google_protobuf_ServiceOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.deprecated = false + result.uninterpreted_option = @[] + +proc cleardeprecated*(message: google_protobuf_ServiceOptions) = + message.deprecated = false + excl(message.hasField, [33]) + +proc hasdeprecated*(message: google_protobuf_ServiceOptions): bool = + result = contains(message.hasField, 33) + +proc setdeprecated*(message: google_protobuf_ServiceOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 33) + +proc deprecated*(message: google_protobuf_ServiceOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_ServiceOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_ServiceOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_ServiceOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_ServiceOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_ServiceOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_ServiceOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_ServiceOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_ServiceOptions*(message: google_protobuf_ServiceOptions): uint64 = + if hasdeprecated(message): + result = result + sizeOfTag(33, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_ServiceOptions*(stream: ProtobufStream, message: google_protobuf_ServiceOptions) = + if hasdeprecated(message): + writeBool(stream, message.deprecated, 33) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_ServiceOptions*(stream: ProtobufStream): google_protobuf_ServiceOptions = + result = newgoogle_protobuf_ServiceOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 33: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_ServiceOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_ServiceOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_ServiceOptions*(data: string): google_protobuf_ServiceOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_ServiceOptions(pbs) + + +proc newgoogle_protobuf_MethodOptions*(): google_protobuf_MethodOptions = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.deprecated = false + result.idempotency_level = google_protobuf_MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN + result.uninterpreted_option = @[] + +proc cleardeprecated*(message: google_protobuf_MethodOptions) = + message.deprecated = false + excl(message.hasField, [33]) + +proc hasdeprecated*(message: google_protobuf_MethodOptions): bool = + result = contains(message.hasField, 33) + +proc setdeprecated*(message: google_protobuf_MethodOptions, value: bool) = + message.deprecated = value + incl(message.hasField, 33) + +proc deprecated*(message: google_protobuf_MethodOptions): bool {.inline.} = + message.deprecated + +proc `deprecated=`*(message: google_protobuf_MethodOptions, value: bool) {.inline.} = + setdeprecated(message, value) + +proc clearidempotency_level*(message: google_protobuf_MethodOptions) = + message.idempotency_level = google_protobuf_MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN + excl(message.hasField, [34]) + +proc hasidempotency_level*(message: google_protobuf_MethodOptions): bool = + result = contains(message.hasField, 34) + +proc setidempotency_level*(message: google_protobuf_MethodOptions, value: google_protobuf_MethodOptions_IdempotencyLevel) = + message.idempotency_level = value + incl(message.hasField, 34) + +proc idempotency_level*(message: google_protobuf_MethodOptions): google_protobuf_MethodOptions_IdempotencyLevel {.inline.} = + message.idempotency_level + +proc `idempotency_level=`*(message: google_protobuf_MethodOptions, value: google_protobuf_MethodOptions_IdempotencyLevel) {.inline.} = + setidempotency_level(message, value) + +proc clearuninterpreted_option*(message: google_protobuf_MethodOptions) = + message.uninterpreted_option = @[] + excl(message.hasField, [999]) + +proc hasuninterpreted_option*(message: google_protobuf_MethodOptions): bool = + result = contains(message.hasField, 999) or (len(message.uninterpreted_option) > 0) + +proc setuninterpreted_option*(message: google_protobuf_MethodOptions, value: seq[google_protobuf_UninterpretedOption]) = + message.uninterpreted_option = value + incl(message.hasField, 999) + +proc adduninterpreted_option*(message: google_protobuf_MethodOptions, value: google_protobuf_UninterpretedOption) = + add(message.uninterpreted_option, value) + incl(message.hasField, 999) + +proc uninterpreted_option*(message: google_protobuf_MethodOptions): seq[google_protobuf_UninterpretedOption] {.inline.} = + message.uninterpreted_option + +proc `uninterpreted_option=`*(message: google_protobuf_MethodOptions, value: seq[google_protobuf_UninterpretedOption]) {.inline.} = + setuninterpreted_option(message, value) + +proc sizeOfgoogle_protobuf_MethodOptions*(message: google_protobuf_MethodOptions): uint64 = + if hasdeprecated(message): + result = result + sizeOfTag(33, WireType.Varint) + result = result + sizeOfBool(message.deprecated) + if hasidempotency_level(message): + result = result + sizeOfTag(34, WireType.Varint) + result = result + sizeOfEnum[google_protobuf_MethodOptions_IdempotencyLevel](message.idempotency_level) + for value in message.uninterpreted_option: + result = result + sizeOfTag(999, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_UninterpretedOption(value)) + +proc writegoogle_protobuf_MethodOptions*(stream: ProtobufStream, message: google_protobuf_MethodOptions) = + if hasdeprecated(message): + writeBool(stream, message.deprecated, 33) + if hasidempotency_level(message): + writeEnum(stream, message.idempotency_level, 34) + for value in message.uninterpreted_option: + writeMessage(stream, value, 999) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_MethodOptions*(stream: ProtobufStream): google_protobuf_MethodOptions = + result = newgoogle_protobuf_MethodOptions() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 33: + expectWireType(wireType, WireType.Varint) + setdeprecated(result, readBool(stream)) + of 34: + expectWireType(wireType, WireType.Varint) + setidempotency_level(result, readEnum[google_protobuf_MethodOptions_IdempotencyLevel](stream)) + of 999: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + adduninterpreted_option(result, newgoogle_protobuf_UninterpretedOption(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_MethodOptions): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_MethodOptions(pbs, message) + result = ss.data + +proc newgoogle_protobuf_MethodOptions*(data: string): google_protobuf_MethodOptions = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_MethodOptions(pbs) + + +proc newgoogle_protobuf_MethodDescriptorProto*(): google_protobuf_MethodDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.input_type = "" + result.output_type = "" + result.options = nil + result.client_streaming = false + result.server_streaming = false + +proc clearname*(message: google_protobuf_MethodDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_MethodDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_MethodDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_MethodDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_MethodDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearinput_type*(message: google_protobuf_MethodDescriptorProto) = + message.input_type = "" + excl(message.hasField, [2]) + +proc hasinput_type*(message: google_protobuf_MethodDescriptorProto): bool = + result = contains(message.hasField, 2) + +proc setinput_type*(message: google_protobuf_MethodDescriptorProto, value: string) = + message.input_type = value + incl(message.hasField, 2) + +proc input_type*(message: google_protobuf_MethodDescriptorProto): string {.inline.} = + message.input_type + +proc `input_type=`*(message: google_protobuf_MethodDescriptorProto, value: string) {.inline.} = + setinput_type(message, value) + +proc clearoutput_type*(message: google_protobuf_MethodDescriptorProto) = + message.output_type = "" + excl(message.hasField, [3]) + +proc hasoutput_type*(message: google_protobuf_MethodDescriptorProto): bool = + result = contains(message.hasField, 3) + +proc setoutput_type*(message: google_protobuf_MethodDescriptorProto, value: string) = + message.output_type = value + incl(message.hasField, 3) + +proc output_type*(message: google_protobuf_MethodDescriptorProto): string {.inline.} = + message.output_type + +proc `output_type=`*(message: google_protobuf_MethodDescriptorProto, value: string) {.inline.} = + setoutput_type(message, value) + +proc clearoptions*(message: google_protobuf_MethodDescriptorProto) = + message.options = nil + excl(message.hasField, [4]) + +proc hasoptions*(message: google_protobuf_MethodDescriptorProto): bool = + result = contains(message.hasField, 4) + +proc setoptions*(message: google_protobuf_MethodDescriptorProto, value: google_protobuf_MethodOptions) = + message.options = value + incl(message.hasField, 4) + +proc options*(message: google_protobuf_MethodDescriptorProto): google_protobuf_MethodOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_MethodDescriptorProto, value: google_protobuf_MethodOptions) {.inline.} = + setoptions(message, value) + +proc clearclient_streaming*(message: google_protobuf_MethodDescriptorProto) = + message.client_streaming = false + excl(message.hasField, [5]) + +proc hasclient_streaming*(message: google_protobuf_MethodDescriptorProto): bool = + result = contains(message.hasField, 5) + +proc setclient_streaming*(message: google_protobuf_MethodDescriptorProto, value: bool) = + message.client_streaming = value + incl(message.hasField, 5) + +proc client_streaming*(message: google_protobuf_MethodDescriptorProto): bool {.inline.} = + message.client_streaming + +proc `client_streaming=`*(message: google_protobuf_MethodDescriptorProto, value: bool) {.inline.} = + setclient_streaming(message, value) + +proc clearserver_streaming*(message: google_protobuf_MethodDescriptorProto) = + message.server_streaming = false + excl(message.hasField, [6]) + +proc hasserver_streaming*(message: google_protobuf_MethodDescriptorProto): bool = + result = contains(message.hasField, 6) + +proc setserver_streaming*(message: google_protobuf_MethodDescriptorProto, value: bool) = + message.server_streaming = value + incl(message.hasField, 6) + +proc server_streaming*(message: google_protobuf_MethodDescriptorProto): bool {.inline.} = + message.server_streaming + +proc `server_streaming=`*(message: google_protobuf_MethodDescriptorProto, value: bool) {.inline.} = + setserver_streaming(message, value) + +proc sizeOfgoogle_protobuf_MethodDescriptorProto*(message: google_protobuf_MethodDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if hasinput_type(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfString(message.input_type) + if hasoutput_type(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfString(message.output_type) + if hasoptions(message): + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_MethodOptions(message.options)) + if hasclient_streaming(message): + result = result + sizeOfTag(5, WireType.Varint) + result = result + sizeOfBool(message.client_streaming) + if hasserver_streaming(message): + result = result + sizeOfTag(6, WireType.Varint) + result = result + sizeOfBool(message.server_streaming) + +proc writegoogle_protobuf_MethodDescriptorProto*(stream: ProtobufStream, message: google_protobuf_MethodDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + if hasinput_type(message): + writeString(stream, message.input_type, 2) + if hasoutput_type(message): + writeString(stream, message.output_type, 3) + if hasoptions(message): + writeMessage(stream, message.options, 4) + if hasclient_streaming(message): + writeBool(stream, message.client_streaming, 5) + if hasserver_streaming(message): + writeBool(stream, message.server_streaming, 6) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_MethodDescriptorProto*(stream: ProtobufStream): google_protobuf_MethodDescriptorProto = + result = newgoogle_protobuf_MethodDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setinput_type(result, readString(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + setoutput_type(result, readString(stream)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_MethodOptions(data)) + of 5: + expectWireType(wireType, WireType.Varint) + setclient_streaming(result, readBool(stream)) + of 6: + expectWireType(wireType, WireType.Varint) + setserver_streaming(result, readBool(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_MethodDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_MethodDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_MethodDescriptorProto*(data: string): google_protobuf_MethodDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_MethodDescriptorProto(pbs) + + +proc newgoogle_protobuf_ServiceDescriptorProto*(): google_protobuf_ServiceDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.fmethod = @[] + result.options = nil + +proc clearname*(message: google_protobuf_ServiceDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_ServiceDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_ServiceDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_ServiceDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_ServiceDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearfmethod*(message: google_protobuf_ServiceDescriptorProto) = + message.fmethod = @[] + excl(message.hasField, [2]) + +proc hasfmethod*(message: google_protobuf_ServiceDescriptorProto): bool = + result = contains(message.hasField, 2) or (len(message.fmethod) > 0) + +proc setfmethod*(message: google_protobuf_ServiceDescriptorProto, value: seq[google_protobuf_MethodDescriptorProto]) = + message.fmethod = value + incl(message.hasField, 2) + +proc addfmethod*(message: google_protobuf_ServiceDescriptorProto, value: google_protobuf_MethodDescriptorProto) = + add(message.fmethod, value) + incl(message.hasField, 2) + +proc fmethod*(message: google_protobuf_ServiceDescriptorProto): seq[google_protobuf_MethodDescriptorProto] {.inline.} = + message.fmethod + +proc `fmethod=`*(message: google_protobuf_ServiceDescriptorProto, value: seq[google_protobuf_MethodDescriptorProto]) {.inline.} = + setfmethod(message, value) + +proc clearoptions*(message: google_protobuf_ServiceDescriptorProto) = + message.options = nil + excl(message.hasField, [3]) + +proc hasoptions*(message: google_protobuf_ServiceDescriptorProto): bool = + result = contains(message.hasField, 3) + +proc setoptions*(message: google_protobuf_ServiceDescriptorProto, value: google_protobuf_ServiceOptions) = + message.options = value + incl(message.hasField, 3) + +proc options*(message: google_protobuf_ServiceDescriptorProto): google_protobuf_ServiceOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_ServiceDescriptorProto, value: google_protobuf_ServiceOptions) {.inline.} = + setoptions(message, value) + +proc sizeOfgoogle_protobuf_ServiceDescriptorProto*(message: google_protobuf_ServiceDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + for value in message.fmethod: + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_MethodDescriptorProto(value)) + if hasoptions(message): + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_ServiceOptions(message.options)) + +proc writegoogle_protobuf_ServiceDescriptorProto*(stream: ProtobufStream, message: google_protobuf_ServiceDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + for value in message.fmethod: + writeMessage(stream, value, 2) + if hasoptions(message): + writeMessage(stream, message.options, 3) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_ServiceDescriptorProto*(stream: ProtobufStream): google_protobuf_ServiceDescriptorProto = + result = newgoogle_protobuf_ServiceDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addfmethod(result, newgoogle_protobuf_MethodDescriptorProto(data)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_ServiceOptions(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_ServiceDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_ServiceDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_ServiceDescriptorProto*(data: string): google_protobuf_ServiceDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_ServiceDescriptorProto(pbs) + + +proc newgoogle_protobuf_FileDescriptorProto*(): google_protobuf_FileDescriptorProto = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.name = "" + result.package = "" + result.dependency = @[] + result.public_dependency = @[] + result.weak_dependency = @[] + result.message_type = @[] + result.enum_type = @[] + result.service = @[] + result.extension = @[] + result.options = nil + result.source_code_info = nil + result.syntax = "" + +proc clearname*(message: google_protobuf_FileDescriptorProto) = + message.name = "" + excl(message.hasField, [1]) + +proc hasname*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 1) + +proc setname*(message: google_protobuf_FileDescriptorProto, value: string) = + message.name = value + incl(message.hasField, 1) + +proc name*(message: google_protobuf_FileDescriptorProto): string {.inline.} = + message.name + +proc `name=`*(message: google_protobuf_FileDescriptorProto, value: string) {.inline.} = + setname(message, value) + +proc clearpackage*(message: google_protobuf_FileDescriptorProto) = + message.package = "" + excl(message.hasField, [2]) + +proc haspackage*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 2) + +proc setpackage*(message: google_protobuf_FileDescriptorProto, value: string) = + message.package = value + incl(message.hasField, 2) + +proc package*(message: google_protobuf_FileDescriptorProto): string {.inline.} = + message.package + +proc `package=`*(message: google_protobuf_FileDescriptorProto, value: string) {.inline.} = + setpackage(message, value) + +proc cleardependency*(message: google_protobuf_FileDescriptorProto) = + message.dependency = @[] + excl(message.hasField, [3]) + +proc hasdependency*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 3) or (len(message.dependency) > 0) + +proc setdependency*(message: google_protobuf_FileDescriptorProto, value: seq[string]) = + message.dependency = value + incl(message.hasField, 3) + +proc adddependency*(message: google_protobuf_FileDescriptorProto, value: string) = + add(message.dependency, value) + incl(message.hasField, 3) + +proc dependency*(message: google_protobuf_FileDescriptorProto): seq[string] {.inline.} = + message.dependency + +proc `dependency=`*(message: google_protobuf_FileDescriptorProto, value: seq[string]) {.inline.} = + setdependency(message, value) + +proc clearpublic_dependency*(message: google_protobuf_FileDescriptorProto) = + message.public_dependency = @[] + excl(message.hasField, [10]) + +proc haspublic_dependency*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 10) or (len(message.public_dependency) > 0) + +proc setpublic_dependency*(message: google_protobuf_FileDescriptorProto, value: seq[int32]) = + message.public_dependency = value + incl(message.hasField, 10) + +proc addpublic_dependency*(message: google_protobuf_FileDescriptorProto, value: int32) = + add(message.public_dependency, value) + incl(message.hasField, 10) + +proc public_dependency*(message: google_protobuf_FileDescriptorProto): seq[int32] {.inline.} = + message.public_dependency + +proc `public_dependency=`*(message: google_protobuf_FileDescriptorProto, value: seq[int32]) {.inline.} = + setpublic_dependency(message, value) + +proc clearweak_dependency*(message: google_protobuf_FileDescriptorProto) = + message.weak_dependency = @[] + excl(message.hasField, [11]) + +proc hasweak_dependency*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 11) or (len(message.weak_dependency) > 0) + +proc setweak_dependency*(message: google_protobuf_FileDescriptorProto, value: seq[int32]) = + message.weak_dependency = value + incl(message.hasField, 11) + +proc addweak_dependency*(message: google_protobuf_FileDescriptorProto, value: int32) = + add(message.weak_dependency, value) + incl(message.hasField, 11) + +proc weak_dependency*(message: google_protobuf_FileDescriptorProto): seq[int32] {.inline.} = + message.weak_dependency + +proc `weak_dependency=`*(message: google_protobuf_FileDescriptorProto, value: seq[int32]) {.inline.} = + setweak_dependency(message, value) + +proc clearmessage_type*(message: google_protobuf_FileDescriptorProto) = + message.message_type = @[] + excl(message.hasField, [4]) + +proc hasmessage_type*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 4) or (len(message.message_type) > 0) + +proc setmessage_type*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_DescriptorProto]) = + message.message_type = value + incl(message.hasField, 4) + +proc addmessage_type*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_DescriptorProto) = + add(message.message_type, value) + incl(message.hasField, 4) + +proc message_type*(message: google_protobuf_FileDescriptorProto): seq[google_protobuf_DescriptorProto] {.inline.} = + message.message_type + +proc `message_type=`*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_DescriptorProto]) {.inline.} = + setmessage_type(message, value) + +proc clearenum_type*(message: google_protobuf_FileDescriptorProto) = + message.enum_type = @[] + excl(message.hasField, [5]) + +proc hasenum_type*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 5) or (len(message.enum_type) > 0) + +proc setenum_type*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_EnumDescriptorProto]) = + message.enum_type = value + incl(message.hasField, 5) + +proc addenum_type*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_EnumDescriptorProto) = + add(message.enum_type, value) + incl(message.hasField, 5) + +proc enum_type*(message: google_protobuf_FileDescriptorProto): seq[google_protobuf_EnumDescriptorProto] {.inline.} = + message.enum_type + +proc `enum_type=`*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_EnumDescriptorProto]) {.inline.} = + setenum_type(message, value) + +proc clearservice*(message: google_protobuf_FileDescriptorProto) = + message.service = @[] + excl(message.hasField, [6]) + +proc hasservice*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 6) or (len(message.service) > 0) + +proc setservice*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_ServiceDescriptorProto]) = + message.service = value + incl(message.hasField, 6) + +proc addservice*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_ServiceDescriptorProto) = + add(message.service, value) + incl(message.hasField, 6) + +proc service*(message: google_protobuf_FileDescriptorProto): seq[google_protobuf_ServiceDescriptorProto] {.inline.} = + message.service + +proc `service=`*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_ServiceDescriptorProto]) {.inline.} = + setservice(message, value) + +proc clearextension*(message: google_protobuf_FileDescriptorProto) = + message.extension = @[] + excl(message.hasField, [7]) + +proc hasextension*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 7) or (len(message.extension) > 0) + +proc setextension*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_FieldDescriptorProto]) = + message.extension = value + incl(message.hasField, 7) + +proc addextension*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_FieldDescriptorProto) = + add(message.extension, value) + incl(message.hasField, 7) + +proc extension*(message: google_protobuf_FileDescriptorProto): seq[google_protobuf_FieldDescriptorProto] {.inline.} = + message.extension + +proc `extension=`*(message: google_protobuf_FileDescriptorProto, value: seq[google_protobuf_FieldDescriptorProto]) {.inline.} = + setextension(message, value) + +proc clearoptions*(message: google_protobuf_FileDescriptorProto) = + message.options = nil + excl(message.hasField, [8]) + +proc hasoptions*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 8) + +proc setoptions*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_FileOptions) = + message.options = value + incl(message.hasField, 8) + +proc options*(message: google_protobuf_FileDescriptorProto): google_protobuf_FileOptions {.inline.} = + message.options + +proc `options=`*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_FileOptions) {.inline.} = + setoptions(message, value) + +proc clearsource_code_info*(message: google_protobuf_FileDescriptorProto) = + message.source_code_info = nil + excl(message.hasField, [9]) + +proc hassource_code_info*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 9) + +proc setsource_code_info*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_SourceCodeInfo) = + message.source_code_info = value + incl(message.hasField, 9) + +proc source_code_info*(message: google_protobuf_FileDescriptorProto): google_protobuf_SourceCodeInfo {.inline.} = + message.source_code_info + +proc `source_code_info=`*(message: google_protobuf_FileDescriptorProto, value: google_protobuf_SourceCodeInfo) {.inline.} = + setsource_code_info(message, value) + +proc clearsyntax*(message: google_protobuf_FileDescriptorProto) = + message.syntax = "" + excl(message.hasField, [12]) + +proc hassyntax*(message: google_protobuf_FileDescriptorProto): bool = + result = contains(message.hasField, 12) + +proc setsyntax*(message: google_protobuf_FileDescriptorProto, value: string) = + message.syntax = value + incl(message.hasField, 12) + +proc syntax*(message: google_protobuf_FileDescriptorProto): string {.inline.} = + message.syntax + +proc `syntax=`*(message: google_protobuf_FileDescriptorProto, value: string) {.inline.} = + setsyntax(message, value) + +proc sizeOfgoogle_protobuf_FileDescriptorProto*(message: google_protobuf_FileDescriptorProto): uint64 = + if hasname(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfString(message.name) + if haspackage(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfString(message.package) + for value in message.dependency: + result = result + sizeOfTag(3, WireType.LengthDelimited) + result = result + sizeOfString(value) + if haspublic_dependency(message): + result = result + sizeOfTag(10, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(packedFieldSize(message.public_dependency, FieldType.Int32)) + if hasweak_dependency(message): + result = result + sizeOfTag(11, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(packedFieldSize(message.weak_dependency, FieldType.Int32)) + for value in message.message_type: + result = result + sizeOfTag(4, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_DescriptorProto(value)) + for value in message.enum_type: + result = result + sizeOfTag(5, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumDescriptorProto(value)) + for value in message.service: + result = result + sizeOfTag(6, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_ServiceDescriptorProto(value)) + for value in message.extension: + result = result + sizeOfTag(7, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_FieldDescriptorProto(value)) + if hasoptions(message): + result = result + sizeOfTag(8, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_FileOptions(message.options)) + if hassource_code_info(message): + result = result + sizeOfTag(9, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceCodeInfo(message.source_code_info)) + if hassyntax(message): + result = result + sizeOfTag(12, WireType.LengthDelimited) + result = result + sizeOfString(message.syntax) + +proc writegoogle_protobuf_FileDescriptorProto*(stream: ProtobufStream, message: google_protobuf_FileDescriptorProto) = + if hasname(message): + writeString(stream, message.name, 1) + if haspackage(message): + writeString(stream, message.package, 2) + for value in message.dependency: + writeString(stream, value, 3) + for value in message.public_dependency: + writeInt32(stream, value, 10) + for value in message.weak_dependency: + writeInt32(stream, value, 11) + for value in message.message_type: + writeMessage(stream, value, 4) + for value in message.enum_type: + writeMessage(stream, value, 5) + for value in message.service: + writeMessage(stream, value, 6) + for value in message.extension: + writeMessage(stream, value, 7) + if hasoptions(message): + writeMessage(stream, message.options, 8) + if hassource_code_info(message): + writeMessage(stream, message.source_code_info, 9) + if hassyntax(message): + writeString(stream, message.syntax, 12) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FileDescriptorProto*(stream: ProtobufStream): google_protobuf_FileDescriptorProto = + result = newgoogle_protobuf_FileDescriptorProto() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + setname(result, readString(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setpackage(result, readString(stream)) + of 3: + expectWireType(wireType, WireType.LengthDelimited) + adddependency(result, readString(stream)) + of 10: + expectWireType(wireType, WireType.Varint, WireType.LengthDelimited) + if wireType == WireType.LengthDelimited: + let + size = readVarint(stream) + start = uint64(getPosition(stream)) + var consumed = 0'u64 + while consumed < size: + addpublic_dependency(result, readInt32(stream)) + consumed = uint64(getPosition(stream)) - start + if consumed != size: + raise newException(Exception, "packed field size mismatch") + else: + addpublic_dependency(result, readInt32(stream)) + of 11: + expectWireType(wireType, WireType.Varint, WireType.LengthDelimited) + if wireType == WireType.LengthDelimited: + let + size = readVarint(stream) + start = uint64(getPosition(stream)) + var consumed = 0'u64 + while consumed < size: + addweak_dependency(result, readInt32(stream)) + consumed = uint64(getPosition(stream)) - start + if consumed != size: + raise newException(Exception, "packed field size mismatch") + else: + addweak_dependency(result, readInt32(stream)) + of 4: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addmessage_type(result, newgoogle_protobuf_DescriptorProto(data)) + of 5: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addenum_type(result, newgoogle_protobuf_EnumDescriptorProto(data)) + of 6: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addservice(result, newgoogle_protobuf_ServiceDescriptorProto(data)) + of 7: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addextension(result, newgoogle_protobuf_FieldDescriptorProto(data)) + of 8: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setoptions(result, newgoogle_protobuf_FileOptions(data)) + of 9: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + setsource_code_info(result, newgoogle_protobuf_SourceCodeInfo(data)) + of 12: + expectWireType(wireType, WireType.LengthDelimited) + setsyntax(result, readString(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FileDescriptorProto): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FileDescriptorProto(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FileDescriptorProto*(data: string): google_protobuf_FileDescriptorProto = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FileDescriptorProto(pbs) + + +proc newgoogle_protobuf_FileDescriptorSet*(): google_protobuf_FileDescriptorSet = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.file = @[] + +proc clearfile*(message: google_protobuf_FileDescriptorSet) = + message.file = @[] + excl(message.hasField, [1]) + +proc hasfile*(message: google_protobuf_FileDescriptorSet): bool = + result = contains(message.hasField, 1) or (len(message.file) > 0) + +proc setfile*(message: google_protobuf_FileDescriptorSet, value: seq[google_protobuf_FileDescriptorProto]) = + message.file = value + incl(message.hasField, 1) + +proc addfile*(message: google_protobuf_FileDescriptorSet, value: google_protobuf_FileDescriptorProto) = + add(message.file, value) + incl(message.hasField, 1) + +proc file*(message: google_protobuf_FileDescriptorSet): seq[google_protobuf_FileDescriptorProto] {.inline.} = + message.file + +proc `file=`*(message: google_protobuf_FileDescriptorSet, value: seq[google_protobuf_FileDescriptorProto]) {.inline.} = + setfile(message, value) + +proc sizeOfgoogle_protobuf_FileDescriptorSet*(message: google_protobuf_FileDescriptorSet): uint64 = + for value in message.file: + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_FileDescriptorProto(value)) + +proc writegoogle_protobuf_FileDescriptorSet*(stream: ProtobufStream, message: google_protobuf_FileDescriptorSet) = + for value in message.file: + writeMessage(stream, value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_FileDescriptorSet*(stream: ProtobufStream): google_protobuf_FileDescriptorSet = + result = newgoogle_protobuf_FileDescriptorSet() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addfile(result, newgoogle_protobuf_FileDescriptorProto(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_FileDescriptorSet): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_FileDescriptorSet(pbs, message) + result = ss.data + +proc newgoogle_protobuf_FileDescriptorSet*(data: string): google_protobuf_FileDescriptorSet = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_FileDescriptorSet(pbs) + + +proc newgoogle_protobuf_GeneratedCodeInfo_Annotation*(): google_protobuf_GeneratedCodeInfo_Annotation = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.path = @[] + result.source_file = "" + result.begin = 0 + result.fend = 0 + +proc clearpath*(message: google_protobuf_GeneratedCodeInfo_Annotation) = + message.path = @[] + excl(message.hasField, [1]) + +proc haspath*(message: google_protobuf_GeneratedCodeInfo_Annotation): bool = + result = contains(message.hasField, 1) or (len(message.path) > 0) + +proc setpath*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: seq[int32]) = + message.path = value + incl(message.hasField, 1) + +proc addpath*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: int32) = + add(message.path, value) + incl(message.hasField, 1) + +proc path*(message: google_protobuf_GeneratedCodeInfo_Annotation): seq[int32] {.inline.} = + message.path + +proc `path=`*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: seq[int32]) {.inline.} = + setpath(message, value) + +proc clearsource_file*(message: google_protobuf_GeneratedCodeInfo_Annotation) = + message.source_file = "" + excl(message.hasField, [2]) + +proc hassource_file*(message: google_protobuf_GeneratedCodeInfo_Annotation): bool = + result = contains(message.hasField, 2) + +proc setsource_file*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: string) = + message.source_file = value + incl(message.hasField, 2) + +proc source_file*(message: google_protobuf_GeneratedCodeInfo_Annotation): string {.inline.} = + message.source_file + +proc `source_file=`*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: string) {.inline.} = + setsource_file(message, value) + +proc clearbegin*(message: google_protobuf_GeneratedCodeInfo_Annotation) = + message.begin = 0 + excl(message.hasField, [3]) + +proc hasbegin*(message: google_protobuf_GeneratedCodeInfo_Annotation): bool = + result = contains(message.hasField, 3) + +proc setbegin*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: int32) = + message.begin = value + incl(message.hasField, 3) + +proc begin*(message: google_protobuf_GeneratedCodeInfo_Annotation): int32 {.inline.} = + message.begin + +proc `begin=`*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: int32) {.inline.} = + setbegin(message, value) + +proc clearfend*(message: google_protobuf_GeneratedCodeInfo_Annotation) = + message.fend = 0 + excl(message.hasField, [4]) + +proc hasfend*(message: google_protobuf_GeneratedCodeInfo_Annotation): bool = + result = contains(message.hasField, 4) + +proc setfend*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: int32) = + message.fend = value + incl(message.hasField, 4) + +proc fend*(message: google_protobuf_GeneratedCodeInfo_Annotation): int32 {.inline.} = + message.fend + +proc `fend=`*(message: google_protobuf_GeneratedCodeInfo_Annotation, value: int32) {.inline.} = + setfend(message, value) + +proc sizeOfgoogle_protobuf_GeneratedCodeInfo_Annotation*(message: google_protobuf_GeneratedCodeInfo_Annotation): uint64 = + if haspath(message): + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(packedFieldSize(message.path, FieldType.Int32)) + if hassource_file(message): + result = result + sizeOfTag(2, WireType.LengthDelimited) + result = result + sizeOfString(message.source_file) + if hasbegin(message): + result = result + sizeOfTag(3, WireType.Varint) + result = result + sizeOfInt32(message.begin) + if hasfend(message): + result = result + sizeOfTag(4, WireType.Varint) + result = result + sizeOfInt32(message.fend) + +proc writegoogle_protobuf_GeneratedCodeInfo_Annotation*(stream: ProtobufStream, message: google_protobuf_GeneratedCodeInfo_Annotation) = + if haspath(message): + writeTag(stream, 1, WireType.LengthDelimited) + writeVarint(stream, packedFieldSize(message.path, FieldType.Int32)) + for value in message.path: + writeInt32(stream, value) + if hassource_file(message): + writeString(stream, message.source_file, 2) + if hasbegin(message): + writeInt32(stream, message.begin, 3) + if hasfend(message): + writeInt32(stream, message.fend, 4) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_GeneratedCodeInfo_Annotation*(stream: ProtobufStream): google_protobuf_GeneratedCodeInfo_Annotation = + result = newgoogle_protobuf_GeneratedCodeInfo_Annotation() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.Varint, WireType.LengthDelimited) + if wireType == WireType.LengthDelimited: + let + size = readVarint(stream) + start = uint64(getPosition(stream)) + var consumed = 0'u64 + while consumed < size: + addpath(result, readInt32(stream)) + consumed = uint64(getPosition(stream)) - start + if consumed != size: + raise newException(Exception, "packed field size mismatch") + else: + addpath(result, readInt32(stream)) + of 2: + expectWireType(wireType, WireType.LengthDelimited) + setsource_file(result, readString(stream)) + of 3: + expectWireType(wireType, WireType.Varint) + setbegin(result, readInt32(stream)) + of 4: + expectWireType(wireType, WireType.Varint) + setfend(result, readInt32(stream)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_GeneratedCodeInfo_Annotation): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_GeneratedCodeInfo_Annotation(pbs, message) + result = ss.data + +proc newgoogle_protobuf_GeneratedCodeInfo_Annotation*(data: string): google_protobuf_GeneratedCodeInfo_Annotation = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_GeneratedCodeInfo_Annotation(pbs) + + +proc newgoogle_protobuf_GeneratedCodeInfo*(): google_protobuf_GeneratedCodeInfo = + new(result) + result.hasField = initIntSet() + result.unknownFields = @[] + result.annotation = @[] + +proc clearannotation*(message: google_protobuf_GeneratedCodeInfo) = + message.annotation = @[] + excl(message.hasField, [1]) + +proc hasannotation*(message: google_protobuf_GeneratedCodeInfo): bool = + result = contains(message.hasField, 1) or (len(message.annotation) > 0) + +proc setannotation*(message: google_protobuf_GeneratedCodeInfo, value: seq[google_protobuf_GeneratedCodeInfo_Annotation]) = + message.annotation = value + incl(message.hasField, 1) + +proc addannotation*(message: google_protobuf_GeneratedCodeInfo, value: google_protobuf_GeneratedCodeInfo_Annotation) = + add(message.annotation, value) + incl(message.hasField, 1) + +proc annotation*(message: google_protobuf_GeneratedCodeInfo): seq[google_protobuf_GeneratedCodeInfo_Annotation] {.inline.} = + message.annotation + +proc `annotation=`*(message: google_protobuf_GeneratedCodeInfo, value: seq[google_protobuf_GeneratedCodeInfo_Annotation]) {.inline.} = + setannotation(message, value) + +proc sizeOfgoogle_protobuf_GeneratedCodeInfo*(message: google_protobuf_GeneratedCodeInfo): uint64 = + for value in message.annotation: + result = result + sizeOfTag(1, WireType.LengthDelimited) + result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_GeneratedCodeInfo_Annotation(value)) + +proc writegoogle_protobuf_GeneratedCodeInfo*(stream: ProtobufStream, message: google_protobuf_GeneratedCodeInfo) = + for value in message.annotation: + writeMessage(stream, value, 1) + writeUnknownFields(stream, message.unknownFields) + +proc readgoogle_protobuf_GeneratedCodeInfo*(stream: ProtobufStream): google_protobuf_GeneratedCodeInfo = + result = newgoogle_protobuf_GeneratedCodeInfo() + while not atEnd(stream): + let + tag = readTag(stream) + wireType = wireType(tag) + case fieldNumber(tag) + of 0: + raise newException(InvalidFieldNumberError, "Invalid field number: 0") + of 1: + expectWireType(wireType, WireType.LengthDelimited) + let data = readLengthDelimited(stream) + addannotation(result, newgoogle_protobuf_GeneratedCodeInfo_Annotation(data)) + else: readUnknownField(stream, tag, result.unknownFields) + +proc serialize*(message: google_protobuf_GeneratedCodeInfo): string = + let + ss = newStringStream() + pbs = newProtobufStream(ss) + writegoogle_protobuf_GeneratedCodeInfo(pbs, message) + result = ss.data + +proc newgoogle_protobuf_GeneratedCodeInfo*(data: string): google_protobuf_GeneratedCodeInfo = + let + ss = newStringStream(data) + pbs = newProtobufStream(ss) + result = readgoogle_protobuf_GeneratedCodeInfo(pbs) + + diff --git a/nimpb/compiler/plugin.nim b/nimpb/compiler/plugin.nim new file mode 100644 index 0000000..abdad07 --- /dev/null +++ b/nimpb/compiler/plugin.nim @@ -0,0 +1,1084 @@ +import algorithm +import os +import pegs +import sequtils +import sets +import strformat +import strutils +import tables + +import descriptor_pb + +import nimpb/nimpb + +type + Names = distinct seq[string] + + Enum = ref object + names: Names + values: seq[tuple[name: string, number: int]] + defaultValue: string + + Field = ref object + number: int + name: string + label: google_protobuf_FieldDescriptorProto_Label + ftype: google_protobuf_FieldDescriptorProto_Type + typeName: string + packed: bool + oneof: Oneof + mapEntry: Message + defaultValue: string + message: Message + jsonName: string + + Message = ref object + names: Names + fields: seq[Field] + oneofs: seq[Oneof] + mapEntry: bool + file: ProtoFile + + Oneof = ref object + name: string + fields: seq[Field] + + ProcessedFile = ref object + name: string + data: string + + ProtoFile = ref object + fdesc: google_protobuf_FileDescriptorProto + enums: seq[Enum] + messages: seq[Message] + syntax: Syntax + dependencies: seq[ProtoFile] + serviceGenerator: ServiceGenerator + + Syntax {.pure.} = enum + Proto2 + Proto3 + + ServiceGenerator* = proc (service: Service): string + + Service* = ref object + name*: string + package*: string + methods*: seq[ServiceMethod] + + ServiceMethod* = ref object + name*: string + inputType*: string + outputType*: string + clientStreaming*: bool + serverStreaming*: bool + +when defined(debug): + proc log(msg: string) = + stderr.write(msg) + stderr.write("\n") +else: + proc log(msg: string) = discard + +proc initNamesFromTypeName(typename: string): Names = + if typename[0] != '.': + raise newException(Exception, "relative names not supported") + let parts = split(typename[1..^1], ".") + result = Names(parts) + +proc `$`(names: Names): string = + let n = seq[string](names) + result = join(n, "_") + +proc add(names: var Names, s: string) = + add(seq[string](names), s) + +proc `&`(names: Names, s: string): Names = + result = names + add(result, s) + +proc isRepeated(field: Field): bool = + result = field.label == google_protobuf_FieldDescriptorProtoLabel.LabelRepeated + +proc isMessage(field: Field): bool = + result = field.ftype == google_protobuf_FieldDescriptorProtoType.TypeMessage + +proc isEnum(field: Field): bool = + result = field.ftype == google_protobuf_FieldDescriptorProtoType.TypeEnum + +proc isNumeric(field: Field): bool = + case field.ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble, google_protobuf_FieldDescriptorProtoType.TypeFloat, + google_protobuf_FieldDescriptorProtoType.TypeInt64, google_protobuf_FieldDescriptorProtoType.TypeUInt64, + google_protobuf_FieldDescriptorProtoType.TypeInt32, google_protobuf_FieldDescriptorProtoType.TypeFixed64, + google_protobuf_FieldDescriptorProtoType.TypeFixed32, google_protobuf_FieldDescriptorProtoType.TypeBool, + google_protobuf_FieldDescriptorProtoType.TypeUInt32, google_protobuf_FieldDescriptorProtoType.TypeEnum, + google_protobuf_FieldDescriptorProtoType.TypeSFixed32, google_protobuf_FieldDescriptorProtoType.TypeSFixed64, + google_protobuf_FieldDescriptorProtoType.TypeSInt32, google_protobuf_FieldDescriptorProtoType.TypeSInt64: + result = true + else: discard + +proc isMapEntry(message: Message): bool = + result = message.mapEntry + +proc isMapEntry(field: Field): bool = + result = field.mapEntry != nil + +proc nimTypeName(field: Field): string = + case field.ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "float64" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "float32" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "int64" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "uint64" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "int32" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "uint64" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "uint32" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "bool" + of google_protobuf_FieldDescriptorProtoType.TypeString: result = "string" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = field.typeName + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "bytes" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "uint32" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = field.typeName + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "int32" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "int64" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "int32" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "int64" + +proc mapKeyType(field: Field): string = + for f in field.mapEntry.fields: + if f.name == "key": + return f.nimTypeName + +proc mapValueField(field: Field): Field = + for f in field.mapEntry.fields: + if f.name == "value": + return f + +proc mapValueType(field: Field): string = + for f in field.mapEntry.fields: + if f.name == "value": + return f.nimTypeName + +proc `$`(ft: google_protobuf_FieldDescriptorProtoType): string = + case ft + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "Double" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "Float" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "Int64" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "UInt64" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "Int32" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "Bool" + of google_protobuf_FieldDescriptorProtoType.TypeString: result = "String" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "Group" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = "Message" + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "Bytes" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "UInt32" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = "Enum" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "SFixed32" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "SFixed64" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "SInt32" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "SInt64" + +proc defaultValue(ftype: google_protobuf_FieldDescriptorProto_Type): string = + case ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "false" + of google_protobuf_FieldDescriptorProtoType.TypeString: result = "\"\"" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = "nil" + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "bytes(\"\")" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "0" + +proc findEnum(file: ProtoFile, typeName: string): Enum = + for e in file.enums: + if $e.names == typeName: + return e + for dep in file.dependencies: + result = findEnum(dep, typeName) + if result != nil: + break + +proc defaultValue(field: Field): string = + if field.defaultValue != nil: + if isEnum(field): + return &"{field.typeName}.{field.defaultValue}" + elif field.ftype == google_protobuf_FieldDescriptorProtoType.TypeString: + return escape(field.defaultValue) + else: + return field.defaultValue + elif isMapEntry(field): + return &"newTable[{field.mapKeyType}, {field.mapValueType}]()" + elif isRepeated(field): + return "@[]" + elif isEnum(field): + let e = findEnum(field.message.file, field.typeName) + if e != nil: + result = e.defaultValue + else: + result = &"cast[{field.typeName}](0)" + else: + result = defaultValue(field.ftype) + +proc wiretypeStr(field: Field): string = + result = "WireType." + case field.ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result &= "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result &= "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result &= "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result &= "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeString: result &= "LengthDelimited" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result &= "" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result &= "LengthDelimited" + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result &= "LengthDelimited" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result &= &"Varint" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result &= "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result &= "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result &= "Varint" + +proc fieldTypeStr(field: Field): string = + result = "FieldType." & $field.ftype + +proc isKeyword(s: string): bool = + case s + of "addr", "and", "as", "asm", "bind", "block", "break", "case", "cast", + "concept", "const", "continue", "converter", "defer", "discard", + "distinct", "div", "do", "elif", "else", "end", "enum", "except", + "export", "finally", "for", "from", "func", "if", "import", "in", + "include", "interface", "is", "isnot", "iterator", "let", "macro", + "method", "mixin", "mod", "nil", "not", "notin", "object", "of", "or", + "out", "proc", "ptr", "raise", "ref", "return", "shl", "shr", "static", + "template", "try", "tuple", "type", "using", "var", "when", "while", + "xor", "yield": + result = true + else: + result = false + +proc writeProc(field: Field): string = + if isMapEntry(field): + result = &"write{field.typeName}KV" + elif isMessage(field): + result = "writeMessage" + elif isEnum(field): + result = "writeEnum" + else: + result = &"write{field.typeName}" + +proc readProc(field: Field): string = + if isMapEntry(field): + result = &"read{field.typeName}KV" + elif isEnum(field): + result = &"readEnum[{field.typeName}]" + else: + result = &"read{field.typeName}" + +proc sizeOfProc(field: Field): string = + if isMapEntry(field): + result = &"sizeOf{field.typeName}KV" + elif isEnum(field): + result = &"sizeOfEnum[{field.typeName}]" + else: + result = &"sizeOf{field.typeName}" + +proc newField(file: ProtoFile, message: Message, desc: google_protobuf_FieldDescriptorProto): Field = + new(result) + + result.name = desc.name + result.number = desc.number + result.label = desc.label + result.ftype = desc.ftype + result.typeName = "" + result.packed = false + result.mapEntry = nil + result.message = message + + # Identifiers cannot start/end with underscore + removePrefix(result.name, '_') + removeSuffix(result.name, '_') + + # Consecutive underscores are not allowed + result.name = replace(result.name, peg"'_' '_'+", "_") + + if isKeyword(result.name): + result.name = "f" & result.name + + if isRepeated(result) and isNumeric(result): + if hasOptions(desc): + if hasPacked(desc.options): + result.packed = desc.options.packed + else: + result.packed = + if file.syntax == Syntax.Proto2: + false + else: + true + else: + result.packed = + if file.syntax == Syntax.Proto2: + false + else: + true + + if hasOneof_index(desc): + result.oneof = message.oneofs[desc.oneof_index] + add(result.oneof.fields, result) + + if isMessage(result) or isEnum(result): + result.typeName = $initNamesFromTypeName(desc.type_name) + else: + result.typeName = $result.ftype + + if hasDefaultValue(desc): + result.defaultValue = desc.default_value + + if hasJsonName(desc): + result.jsonName = desc.jsonName + + log(&"newField {result.name} {$result.ftype} {result.typeName} PACKED={result.packed} SYNTAX={file.syntax}") + +proc newOneof(name: string): Oneof = + new(result) + result.fields = @[] + result.name = name + +proc newMessage(file: ProtoFile, names: Names, desc: google_protobuf_DescriptorProto): Message = + new(result) + + result.names = names + result.fields = @[] + result.oneofs = @[] + result.mapEntry = false + result.file = file + + if hasOptions(desc) and hasMapEntry(desc.options): + result.mapEntry = desc.options.mapEntry + + log(&"newMessage {$result.names}") + + for oneof in desc.oneof_decl: + add(result.oneofs, newOneof(oneof.name)) + + for field in desc.field: + add(result.fields, newField(file, result, field)) + +proc fixMapEntry(file: ProtoFile, message: Message): bool = + for field in message.fields: + for msg in file.messages: + if $msg.names == field.typeName: + if msg.mapEntry: + log(&"fixing map {field.name} {msg.names}") + field.mapEntry = msg + result = true + +proc newEnum(names: Names, desc: google_protobuf_EnumDescriptorProto): Enum = + new(result) + + result.names = names & desc.name + result.values = @[] + + log(&"newEnum {$result.names}") + + for value in desc.value: + add(result.values, (value.name, int(value.number))) + + result.defaultValue = &"{result.names}.{result.values[0].name}" + + type EnumValue = tuple[name: string, number: int] + + sort(result.values, proc (x, y: EnumValue): int = + system.cmp(x.number, y.number) + ) + +proc newService(service: google_protobuf_ServiceDescriptorProto, + file: ProtoFile): Service = + new(result) + result.name = service.name + result.package = file.fdesc.package + result.methods = @[] + + for meth in service.fmethod: + var m: ServiceMethod + new(m) + + m.name = meth.name + m.inputType = $initNamesFromTypeName(meth.inputType) + m.outputType = $initNamesFromTypeName(meth.outputType) + m.clientStreaming = meth.clientStreaming + m.serverStreaming = meth.serverStreaming + + add(result.methods, m) + +iterator messages(desc: google_protobuf_DescriptorProto, names: Names): tuple[names: Names, desc: google_protobuf_DescriptorProto] = + var stack: seq[tuple[names: Names, desc: google_protobuf_DescriptorProto]] = @[] + + for nested in desc.nested_type: + add(stack, (names, nested)) + + while len(stack) > 0: + let (names, submsg) = pop(stack) + + let subnames = names & submsg.name + yield (subnames, submsg) + + for desc in submsg.nested_type: + add(stack, (subnames, desc)) + +iterator messages(fdesc: google_protobuf_FileDescriptorProto, names: Names): tuple[names: Names, desc: google_protobuf_DescriptorProto] = + for desc in fdesc.message_type: + let subnames = names & desc.name + yield (subnames, desc) + + for x in messages(desc, subnames): + yield x + +proc quoteReserved(name: string): string = + case name + of "type": result = &"`{name}`" + else: result = name + +proc accessor(field: Field): string = + if field.oneof != nil: + result = &"{field.oneof.name}.{quoteReserved(field.name)}" + else: + result = quoteReserved(field.name) + +proc dependencies(field: Field): seq[string] = + result = @[] + + if isMessage(field) or isEnum(field): + add(result, field.typeName) + +proc dependencies(message: Message): seq[string] = + result = @[] + + for field in message.fields: + add(result, dependencies(field)) + +proc toposort(graph: TableRef[string, HashSet[string]]): seq[string] = + type State = enum Unknown, Gray, Black + + var + enter = toSeq(keys(graph)) + state = newTable[string, State]() + order: seq[string] = @[] + + proc dfs(node: string) = + state[node] = Gray + if node in graph: + for k in graph[node]: + let sk = + if k in state: + state[k] + else: + Unknown + + if sk == Gray: + # cycle + continue + elif sk == Black: + continue + + let idx = find(enter, k) + if idx != -1: + delete(enter, idx) + + dfs(k) + insert(order, node, 0) + state[node] = Black + + while len(enter) > 0: + dfs(pop(enter)) + + result = order + +iterator sortDependencies(messages: seq[Message]): Message = + let + deps = newTable[string, HashSet[string]]() + byname = newTable[string, Message]() + + for message in messages: + deps[$message.names] = toSet(dependencies(message)) + byname[$message.names] = message + + let order = reversed(toposort(deps)) + + for name in order: + if name in byname: + yield byname[name] + +proc parseFile(name: string, fdesc: google_protobuf_FileDescriptorProto): ProtoFile = + log(&"parsing {name}") + + new(result) + + result.fdesc = fdesc + result.messages = @[] + result.enums = @[] + result.dependencies = @[] + + if hasSyntax(fdesc): + if fdesc.syntax == "proto2": + result.syntax = Syntax.Proto2 + elif fdesc.syntax == "proto3": + result.syntax = Syntax.Proto3 + else: + raise newException(Exception, "unrecognized syntax: " & fdesc.syntax) + else: + result.syntax = Syntax.Proto2 + + let basename = + if hasPackage(fdesc): + Names(split(fdesc.package, ".")) + else: + Names(@[]) + + for e in fdesc.enum_type: + add(result.enums, newEnum(basename, e)) + + for name, message in messages(fdesc, basename): + add(result.messages, newMessage(result, name, message)) + + for e in message.enum_type: + add(result.enums, newEnum(name, e)) + +proc addLine(s: var string, line: string) = + if not isNilOrWhitespace(line): + s &= line + s &= "\n" + +iterator genType(e: Enum): string = + yield &"{e.names}* {{.pure.}} = enum" + for item in e.values: + let (name, number) = item + yield indent(&"{name} = {number}", 4) + +proc fullType(field: Field): string = + if isMapEntry(field): + result = &"TableRef[{field.mapKeyType}, {field.mapValueType}]" + else: + result = field.nimTypeName + if isRepeated(field): + result = &"seq[{result}]" + +proc mapKeyField(message: Message): Field = + for field in message.fields: + if field.name == "key": + return field + +proc mapValueField(message: Message): Field = + for field in message.fields: + if field.name == "value": + return field + +iterator genType(message: Message): string = + if not isMapEntry(message): + yield &"{message.names}* = ref {message.names}Obj" + yield &"{message.names}Obj* = object of RootObj" + yield indent(&"hasField: IntSet", 4) + yield indent(&"unknownFields: seq[UnknownField]", 4) + + for field in message.fields: + if isMapEntry(field): + yield indent(&"{field.name}: TableRef[{mapKeyType(field)}, {mapValueType(field)}]", 4) + elif field.oneof == nil: + yield indent(&"{quoteReserved(field.name)}: {field.fullType}", 4) + + for oneof in message.oneofs: + yield indent(&"{oneof.name}: {message.names}_{oneof.name}_OneOf", 4) + + for oneof in message.oneofs: + yield "" + yield &"{message.names}_{oneof.name}_OneOf* {{.union.}} = object" + for field in oneof.fields: + yield indent(&"{quoteReserved(field.name)}: {field.fullType}", 4) + +iterator genNewMessageProc(msg: Message): string = + yield &"proc new{msg.names}*(): {msg.names} =" + yield indent("new(result)", 4) + yield indent("result.hasField = initIntSet()", 4) + yield indent("result.unknownFields = @[]", 4) + for field in msg.fields: + yield indent(&"result.{field.accessor} = {defaultValue(field)}", 4) + yield "" + +iterator oneofSiblings(field: Field): Field = + if field.oneof != nil: + for sibling in field.oneof.fields: + if sibling == field: + continue + yield sibling + +iterator genClearFieldProc(msg: Message, field: Field): string = + yield &"proc clear{field.name}*(message: {msg.names}) =" + yield indent(&"message.{field.accessor} = {defaultValue(field)}", 4) + var numbers: seq[int] = @[field.number] + for sibling in oneofSiblings(field): + add(numbers, sibling.number) + yield indent(&"excl(message.hasField, [{join(numbers, \", \")}])", 4) + yield "" + +iterator genHasFieldProc(msg: Message, field: Field): string = + yield &"proc has{field.name}*(message: {msg.names}): bool =" + var check = indent(&"result = contains(message.hasField, {field.number})", 4) + if isRepeated(field) or isMapEntry(field): + check = &"{check} or (len(message.{field.accessor}) > 0)" + yield check + yield "" + +iterator genSetFieldProc(msg: Message, field: Field): string = + yield &"proc set{field.name}*(message: {msg.names}, value: {field.fullType}) =" + yield indent(&"message.{field.accessor} = value", 4) + yield indent(&"incl(message.hasField, {field.number})", 4) + var numbers: seq[int] = @[] + for sibling in oneofSiblings(field): + add(numbers, sibling.number) + if len(numbers) > 0: + yield indent(&"excl(message.hasField, [{join(numbers, \", \")}])", 4) + yield "" + +iterator genAddToFieldProc(msg: Message, field: Field): string = + yield &"proc add{field.name}*(message: {msg.names}, value: {field.nimTypeName}) =" + yield indent(&"add(message.{field.name}, value)", 4) + yield indent(&"incl(message.hasField, {field.number})", 4) + yield "" + +iterator genFieldAccessorProcs(msg: Message, field: Field): string = + yield &"proc {quoteReserved(field.name)}*(message: {msg.names}): {field.fullType} {{.inline.}} =" + yield indent(&"message.{field.accessor}", 4) + yield "" + + yield &"proc `{field.name}=`*(message: {msg.names}, value: {field.fullType}) {{.inline.}} =" + yield indent(&"set{field.name}(message, value)", 4) + yield "" + +iterator genWriteMapKVProc(msg: Message): string = + let + key = mapKeyField(msg) + value = mapValueField(msg) + + yield &"proc write{msg.names}KV(stream: ProtobufStream, key: {key.fullType}, value: {value.fullType}) =" + yield indent(&"{key.writeProc}(stream, key, {key.number})", 4) + yield indent(&"{value.writeProc}(stream, value, {value.number})", 4) + yield "" + +iterator genWriteMessageProc(msg: Message): string = + yield &"proc write{msg.names}*(stream: ProtobufStream, message: {msg.names}) =" + + for field in msg.fields: + if isMapEntry(field): + yield indent(&"for key, value in message.{field.name}:", 4) + yield indent(&"writeTag(stream, {field.number}, {wiretypeStr(field)})", 8) + yield indent(&"writeVarint(stream, {field.sizeOfProc}(key, value))", 8) + yield indent(&"{field.writeProc}(stream, key, value)", 8) + elif isRepeated(field): + if field.packed: + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"writeTag(stream, {field.number}, WireType.LengthDelimited)", 8) + yield indent(&"writeVarint(stream, packedFieldSize(message.{field.name}, {field.fieldTypeStr}))", 8) + yield indent(&"for value in message.{field.name}:", 8) + yield indent(&"{field.writeProc}(stream, value)", 12) + else: + yield indent(&"for value in message.{field.name}:", 4) + yield indent(&"{field.writeProc}(stream, value, {field.number})", 8) + else: + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"{field.writeProc}(stream, message.{field.accessor}, {field.number})", 8) + + yield indent("writeUnknownFields(stream, message.unknownFields)", 4) + + yield "" + +iterator genReadMapKVProc(msg: Message): string = + let + key = mapKeyField(msg) + value = mapValueField(msg) + + yield &"proc read{msg.names}KV(stream: ProtobufStream, tbl: TableRef[{key.fullType}, {value.fullType}]) =" + + yield indent(&"var", 4) + yield indent(&"key: {key.fullType}", 8) + yield indent("gotKey = false", 8) + yield indent(&"value: {value.fullType}", 8) + yield indent("gotValue = false", 8) + yield indent("while not atEnd(stream):", 4) + yield indent("let", 8) + yield indent("tag = readTag(stream)", 12) + yield indent("wireType = wireType(tag)", 12) + yield indent("case fieldNumber(tag)", 8) + yield indent(&"of {key.number}:", 8) + yield indent(&"key = {key.readProc}(stream)", 12) + yield indent("gotKey = true", 12) + yield indent(&"of {value.number}:", 8) + if isMessage(value): + yield indent("let", 12) + yield indent("size = readVarint(stream)", 16) + yield indent("data = safeReadStr(stream, int(size))", 16) + yield indent("pbs = newProtobufStream(newStringStream(data))", 16) + yield indent(&"value = {value.readProc}(pbs)", 12) + else: + yield indent(&"value = {value.readProc}(stream)", 12) + yield indent("gotValue = true", 12) + yield indent("else: skipField(stream, wireType)", 8) + yield indent("if not gotKey:", 4) + yield indent(&"raise newException(Exception, \"missing key\")", 8) + yield indent("if not gotValue:", 4) + yield indent(&"raise newException(Exception, \"missing value\")", 8) + yield indent("tbl[key] = value", 4) + yield "" + +iterator genReadMessageProc(msg: Message): string = + yield &"proc read{msg.names}*(stream: ProtobufStream): {msg.names} =" + yield indent(&"result = new{msg.names}()", 4) + yield indent("while not atEnd(stream):", 4) + yield indent("let", 8) + yield indent("tag = readTag(stream)", 12) + yield indent("wireType = wireType(tag)", 12) + yield indent("case fieldNumber(tag)", 8) + yield indent("of 0:", 8) + yield indent("raise newException(InvalidFieldNumberError, \"Invalid field number: 0\")", 12) + for field in msg.fields: + let + setter = + if isRepeated(field): + &"add{field.name}" + else: + &"set{field.name}" + yield indent(&"of {field.number}:", 8) + if isRepeated(field): + if isMapEntry(field): + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + yield indent("let", 12) + yield indent("size = readVarint(stream)", 16) + yield indent("data = safeReadStr(stream, int(size))", 16) + yield indent("pbs = newProtobufStream(newStringStream(data))", 16) + yield indent(&"{field.readProc}(pbs, result.{field.name})", 12) + elif isNumeric(field): + yield indent(&"expectWireType(wireType, {field.wiretypeStr}, WireType.LengthDelimited)", 12) + yield indent("if wireType == WireType.LengthDelimited:", 12) + yield indent("let", 16) + yield indent("size = readVarint(stream)", 20) + yield indent("start = uint64(getPosition(stream))", 20) + yield indent("var consumed = 0'u64", 16) + yield indent("while consumed < size:", 16) + yield indent(&"{setter}(result, {field.readProc}(stream))", 20) + yield indent("consumed = uint64(getPosition(stream)) - start", 20) + yield indent("if consumed != size:", 16) + yield indent("raise newException(Exception, \"packed field size mismatch\")", 20) + yield indent("else:", 12) + yield indent(&"{setter}(result, {field.readProc}(stream))", 16) + elif isMessage(field): + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + yield indent(&"let data = readLengthDelimited(stream)", 12) + yield indent(&"{setter}(result, new{field.typeName}(data))", 12) + else: + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + yield indent(&"{setter}(result, {field.readProc}(stream))", 12) + else: + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + if isMessage(field): + yield indent("let data = readLengthDelimited(stream)", 12) + yield indent(&"{setter}(result, new{field.typeName}(data))", 12) + else: + yield indent(&"{setter}(result, {field.readProc}(stream))", 12) + yield indent("else: readUnknownField(stream, tag, result.unknownFields)", 8) + yield "" + +iterator genSizeOfMapKVProc(message: Message): string = + let + key = mapKeyField(message) + value = mapValueField(message) + + yield &"proc sizeOf{message.names}KV(key: {key.fullType}, value: {value.fullType}): uint64 =" + + # Key (cannot be message or other complex field) + yield indent(&"result = result + sizeOfTag({key.number}, {key.wiretypeStr})", 4) + yield indent(&"result = result + {key.sizeOfProc}(key)", 4) + + # Value + yield indent(&"result = result + sizeOfTag({value.number}, {value.wiretypeStr})", 4) + if isMessage(value): + yield indent(&"result = result + sizeOfLengthDelimited({value.sizeOfProc}(value))", 4) + else: + yield indent(&"result = result + {value.sizeOfProc}(value)", 4) + + yield "" + +iterator genSizeOfMessageProc(msg: Message): string = + yield &"proc sizeOf{msg.names}*(message: {msg.names}): uint64 =" + for field in msg.fields: + if isMapEntry(field): + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"var sizeOfKV = 0'u64", 8) + yield indent(&"for key, value in message.{field.name}:", 8) + yield indent(&"sizeOfKV = sizeOfKV + {field.sizeOfProc}(key, value)", 12) + yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) + yield indent(&"result = result + sizeOfLengthDelimited(sizeOfKV)", 8) + elif isRepeated(field): + if isNumeric(field): + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"result = result + sizeOfTag({field.number}, WireType.LengthDelimited)", 8) + yield indent(&"result = result + sizeOfLengthDelimited(packedFieldSize(message.{field.name}, {field.fieldTypeStr}))", 8) + else: + yield indent(&"for value in message.{field.name}:", 4) + yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) + if isMessage(field): + yield indent(&"result = result + sizeOfLengthDelimited({field.sizeOfProc}(value))", 8) + else: + yield indent(&"result = result + {field.sizeOfProc}(value)", 8) + else: + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) + if isMessage(field): + yield indent(&"result = result + sizeOfLengthDelimited({field.sizeOfProc}(message.{field.accessor}))", 8) + else: + yield indent(&"result = result + {field.sizeOfProc}(message.{field.accessor})", 8) + + yield indent("for field in message.unknownFields:", 4) + yield indent("result = result + sizeOfUnknownField(field)", 8) + + yield "" + +proc shouldGenerateJsonProcs(typeName: string): bool = + const wktsHavingCustomProcs = [ + "google_protobuf_Any", + "google_protobuf_BoolValue", + "google_protobuf_BytesValue", + "google_protobuf_DoubleValue", + "google_protobuf_Duration", + "google_protobuf_FieldMask", + "google_protobuf_FloatValue", + "google_protobuf_Int32Value", + "google_protobuf_Int64Value", + "google_protobuf_ListValue", + "google_protobuf_NullValue", + "google_protobuf_StringValue", + "google_protobuf_Struct", + "google_protobuf_Timestamp", + "google_protobuf_UInt32Value", + "google_protobuf_UInt64Value", + "google_protobuf_Value", + ] + + return typeName notin wktsHavingCustomProcs + +iterator genMessageToJsonProc(msg: Message): string = + yield &"proc toJson*(message: {msg.names}): JsonNode =" + yield indent("result = newJObject()", 4) + + proc fieldToJson(field: Field, v: string): string = + case field.ftype + of google_protobuf_FieldDescriptorProto_Type.TypeMessage, + google_protobuf_FieldDescriptorProto_Type.TypeInt64, + google_protobuf_FieldDescriptorProto_Type.TypeUInt64, + google_protobuf_FieldDescriptorProto_Type.TypeSFixed64, + google_protobuf_FieldDescriptorProto_Type.TypeFixed64, + google_protobuf_FieldDescriptorProto_Type.TypeDouble, + google_protobuf_FieldDescriptorProto_Type.TypeFloat: + result = &"toJson({v})" + of google_protobuf_FieldDescriptorProto_Type.TypeEnum: + result = &"%(${v})" + else: + result = &"%{v}" + + for field in msg.fields: + yield indent(&"if has{field.name}(message):", 4) + if isMapEntry(field): + yield indent("let obj = newJObject()", 8) + yield indent(&"for key, value in message.{field.name}:", 8) + let f = mapValueField(field) + let j = fieldToJson(f, "value") + yield indent(&"obj[$key] = {j}", 12) + yield indent(&"result[\"{field.jsonName}\"] = obj", 8) + elif isRepeated(field): + yield indent(&"let arr = newJArray()", 8) + yield indent(&"for value in message.{field.name}:", 8) + let v = fieldToJson(field, "value") + yield indent(&"add(arr, {v})", 12) + yield indent(&"result[\"{field.jsonName}\"] = arr", 8) + else: + let v = fieldToJson(field, &"message.{field.name}") + yield indent(&"result[\"{field.jsonName}\"] = {v}", 8) + + yield "" + +iterator genMessageProcForwards(msg: Message): string = + # TODO: can we be more intelligent and only forward declare the minimum set + # of procs? + if not isMapEntry(msg): + yield &"proc new{msg.names}*(): {msg.names}" + yield &"proc new{msg.names}*(data: string): {msg.names}" + yield &"proc write{msg.names}*(stream: ProtobufStream, message: {msg.names})" + yield &"proc read{msg.names}*(stream: ProtobufStream): {msg.names}" + yield &"proc sizeOf{msg.names}*(message: {msg.names}): uint64" + if shouldGenerateJsonProcs($msg.names): + yield &"proc toJson*(message: {msg.names}): JsonNode" + else: + let + key = mapKeyField(msg) + value = mapValueField(msg) + + yield &"proc write{msg.names}KV(stream: ProtobufStream, key: {key.fullType}, value: {value.fullType})" + yield &"proc read{msg.names}KV(stream: ProtobufStream, tbl: TableRef[{key.fullType}, {value.fullType}])" + yield &"proc sizeOf{msg.names}KV(key: {key.fullType}, value: {value.fullType}): uint64" + +iterator genProcs(msg: Message): string = + if isMapEntry(msg): + for line in genSizeOfMapKVProc(msg): yield line + for line in genWriteMapKVProc(msg): yield line + for line in genReadMapKVProc(msg): yield line + else: + for line in genNewMessageProc(msg): yield line + + for field in msg.fields: + for line in genClearFieldProc(msg, field): yield line + for line in genHasFieldProc(msg, field): yield line + for line in genSetFieldProc(msg, field): yield line + + if isRepeated(field) and not isMapEntry(field): + for line in genAddToFieldProc(msg, field): yield line + + for line in genFieldAccessorProcs(msg, field): yield line + + for line in genSizeOfMessageProc(msg): yield line + for line in genWriteMessageProc(msg): yield line + for line in genReadMessageProc(msg): yield line + + if shouldGenerateJsonProcs($msg.names): + for line in genMessageToJsonProc(msg): yield line + + yield &"proc serialize*(message: {msg.names}): string =" + yield indent("let", 4) + yield indent("ss = newStringStream()", 8) + yield indent("pbs = newProtobufStream(ss)", 8) + yield indent(&"write{msg.names}(pbs, message)", 4) + yield indent("result = ss.data", 4) + yield "" + + yield &"proc new{msg.names}*(data: string): {msg.names} =" + yield indent("let", 4) + yield indent("ss = newStringStream(data)", 8) + yield indent("pbs = newProtobufStream(ss)", 8) + yield indent(&"result = read{msg.names}(pbs)", 4) + yield "" + +proc processFile(fdesc: google_protobuf_FileDescriptorProto, + otherFiles: TableRef[string, ProtoFile], + serviceGenerator: ServiceGenerator): ProcessedFile = + var (dir, name, _) = splitFile(fdesc.name) + var pbfilename = (dir / name) & "_pb.nim" + + log(&"processing {fdesc.name}: {pbfilename}") + + new(result) + result.name = pbfilename + result.data = "" + + let parsed = parseFile(fdesc.name, fdesc) + + for dep in fdesc.dependency: + if dep in otherFiles: + add(parsed.dependencies, otherFiles[dep]) + + var hasMaps = false + for message in parsed.messages: + let tmp = fixMapEntry(parsed, message) + if tmp: + hasMaps = true + + addLine(result.data, "# Generated by protoc_gen_nim. Do not edit!") + addLine(result.data, "") + addLine(result.data, "import base64") + addLine(result.data, "import intsets") + addLine(result.data, "import json") + if hasMaps: + addLine(result.data, "import tables") + addLine(result.data, "export tables") + addLine(result.data, "") + addLine(result.data, "import nimpb/nimpb") + addLine(result.data, "import nimpb/json as nimpb_json") + addLine(result.data, "") + + for dep in fdesc.dependency: + var (dir, depname, _) = splitFile(dep) + + if dir == "google/protobuf": + dir = "nimpb/wkt" + + var deppbname = (dir / depname) & "_pb" + addLine(result.data, &"import {deppbname}") + + if hasDependency(fdesc): + addLine(result.data, "") + + addLine(result.data, "type") + + for e in parsed.enums: + for line in genType(e): addLine(result.data, indent(line, 4)) + + for message in parsed.messages: + for line in genType(message): addLine(result.data, indent(line, 4)) + + addLine(result.data, "") + + for message in sortDependencies(parsed.messages): + for line in genMessageProcForwards(message): + addLine(result.data, line) + addLine(result.data, "") + + for message in sortDependencies(parsed.messages): + for line in genProcs(message): + addLine(result.data, line) + addLine(result.data, "") + + if serviceGenerator != nil: + for serviceDesc in fdesc.service: + let service = newService(serviceDesc, parsed) + addLine(result.data, "") + add(result.data, serviceGenerator(service)) + +proc processFileDescriptorSet*(filename: string, + outdir: string, + protos: openArray[string], + serviceGenerator: ServiceGenerator) = + let s = newProtobufStream(newFileStream(filename, fmRead)) + + let fileSet = readgoogle_protobuf_FileDescriptorSet(s) + + var otherFiles = newTable[string, ProtoFile]() + + for file in fileSet.file: + add(otherFiles, file.name, parseFile(file.name, file)) + + # Protoc does not provide full paths for files in FileDescriptorSet. So it + # can be that fileSet.file.name might match any file in protos. So we will + # try to match the bare name and the named joined with the path of the first + # file. + let basePath = parentDir(protos[0]) + + for file in fileSet.file: + if (file.name in protos) or ((basePath / file.name) in protos): + let processedFile = processFile(file, otherFiles, serviceGenerator) + + let fullPath = outdir / processedFile.name + + createDir(parentDir(fullPath)) + + writeFile(fullPath, processedFile.data) -- cgit v1.2.3 From ad3a344c8f3c79ba487d45b70b269fa55423670a Mon Sep 17 00:00:00 2001 From: Oskari Timperi Date: Wed, 11 Apr 2018 19:37:14 +0300 Subject: Changes to finding the protoc compiler Now there are three ways we can find the protoc compiler: 1. The user tells us the full path to it with NIMPB_PROTOC env var 2. The user puts protoc in PATH 3. The user installs nimpb_protoc (renamed from nimpb_build) with Nimble These are listed in current precedence order. --- nimpb.nimble | 2 + nimpb/compiler/compiler.nim | 92 ++-- nimpb/compiler/generator.nim | 1084 ++++++++++++++++++++++++++++++++++++++++++ nimpb/compiler/plugin.nim | 1084 ------------------------------------------ 4 files changed, 1129 insertions(+), 1133 deletions(-) create mode 100644 nimpb/compiler/generator.nim delete mode 100644 nimpb/compiler/plugin.nim diff --git a/nimpb.nimble b/nimpb.nimble index 7f55df3..28247db 100644 --- a/nimpb.nimble +++ b/nimpb.nimble @@ -5,4 +5,6 @@ license = "MIT" skipDirs = @["examples", "tests"] +bin = @["nimpb/compiler/compiler"] + requires "nim >= 0.18.0" diff --git a/nimpb/compiler/compiler.nim b/nimpb/compiler/compiler.nim index b93d158..fe0a5e4 100644 --- a/nimpb/compiler/compiler.nim +++ b/nimpb/compiler/compiler.nim @@ -1,64 +1,58 @@ +import macros import os import osproc -import streams import strformat -import strtabs import strutils -from plugin import processFileDescriptorSet, ServiceGenerator, Service, ServiceMethod - +from generator import processFileDescriptorSet, ServiceGenerator, Service, ServiceMethod export Service, ServiceMethod -when defined(windows): - const compilerId = "win32" -elif defined(linux): - when defined(i386): - const arch = "x86_32" - elif defined(amd64): - const arch = "x86_64" - elif defined(arm64): - const arch = "aarch_64" - else: - {.fatal:"unsupported architecture".} - const compilerId = "linux-" & arch -elif defined(macosx): - when defined(amd64): - const arch = "x86_64" - else: - {.fatal:"unsupported architecture".} - const compilerId = "osx-" & arch -else: - {.fatal:"unsupported platform".} - -when defined(windows): - const exeSuffix = ".exe" -else: - const exeSuffix = "" - -proc findCompiler(): string = - let - compilerName = &"protoc-{compilerId}{exeSuffix}" - paths = @[ - getAppDir() / "src" / "nimpb_buildpkg" / "protobuf", - getAppDir() / "nimpb_buildpkg" / "protobuf", - parentDir(currentSourcePath()) / "nimpb_buildpkg" / "protobuf", - ] - - for path in paths: - if fileExists(path / compilerName): - return path / compilerName - - raise newException(Exception, &"{compilerName} not found!") +const + nimpbBuildInfo = gorgeEx("nimble dump nimpb_protoc") + isNimpbBuildAvailable = nimpbBuildInfo[1] == 0 + +when isNimpbBuildAvailable: + import nimpb_protoc/nimpb_protoc + +proc findCompiler*(): string = + result = "" + + if existsEnv("NIMPB_PROTOC"): + result = getEnv("NIMPB_PROTOC") + if not fileExists(result): + result = "" + + if result == "": + result = findExe("protoc") + + when isNimpbBuildAvailable: + if result == "": + result = nimpb_protoc.getCompilerPath() + + if result == "": + let msg = """ +error: protoc compiler not found + +Now you have three options to make this work: + +1. Tell me the full path to the protoc executable by using NIMPB_PROTOC + environment variable + +2. You can also make sure that protoc is in PATH, which will make me find it + +3. Install nimpb_protoc with nimble, which includes the protoc compiler for the + most common platforms (Windows, Linux, macOS) and I should be able to pick + it up after a recompile + +""" + + raise newException(Exception, msg) proc builtinIncludeDir(compilerPath: string): string = parentDir(compilerPath) / "include" -template verboseEcho(x: untyped): untyped = - if verbose: - echo(x) - proc myTempDir(): string = - result = getTempDir() / "nimpb_build_tmp" + result = getTempDir() / "nimpb_protoc_tmp" proc compileProtos*(protos: openArray[string], includes: openArray[string], diff --git a/nimpb/compiler/generator.nim b/nimpb/compiler/generator.nim new file mode 100644 index 0000000..abdad07 --- /dev/null +++ b/nimpb/compiler/generator.nim @@ -0,0 +1,1084 @@ +import algorithm +import os +import pegs +import sequtils +import sets +import strformat +import strutils +import tables + +import descriptor_pb + +import nimpb/nimpb + +type + Names = distinct seq[string] + + Enum = ref object + names: Names + values: seq[tuple[name: string, number: int]] + defaultValue: string + + Field = ref object + number: int + name: string + label: google_protobuf_FieldDescriptorProto_Label + ftype: google_protobuf_FieldDescriptorProto_Type + typeName: string + packed: bool + oneof: Oneof + mapEntry: Message + defaultValue: string + message: Message + jsonName: string + + Message = ref object + names: Names + fields: seq[Field] + oneofs: seq[Oneof] + mapEntry: bool + file: ProtoFile + + Oneof = ref object + name: string + fields: seq[Field] + + ProcessedFile = ref object + name: string + data: string + + ProtoFile = ref object + fdesc: google_protobuf_FileDescriptorProto + enums: seq[Enum] + messages: seq[Message] + syntax: Syntax + dependencies: seq[ProtoFile] + serviceGenerator: ServiceGenerator + + Syntax {.pure.} = enum + Proto2 + Proto3 + + ServiceGenerator* = proc (service: Service): string + + Service* = ref object + name*: string + package*: string + methods*: seq[ServiceMethod] + + ServiceMethod* = ref object + name*: string + inputType*: string + outputType*: string + clientStreaming*: bool + serverStreaming*: bool + +when defined(debug): + proc log(msg: string) = + stderr.write(msg) + stderr.write("\n") +else: + proc log(msg: string) = discard + +proc initNamesFromTypeName(typename: string): Names = + if typename[0] != '.': + raise newException(Exception, "relative names not supported") + let parts = split(typename[1..^1], ".") + result = Names(parts) + +proc `$`(names: Names): string = + let n = seq[string](names) + result = join(n, "_") + +proc add(names: var Names, s: string) = + add(seq[string](names), s) + +proc `&`(names: Names, s: string): Names = + result = names + add(result, s) + +proc isRepeated(field: Field): bool = + result = field.label == google_protobuf_FieldDescriptorProtoLabel.LabelRepeated + +proc isMessage(field: Field): bool = + result = field.ftype == google_protobuf_FieldDescriptorProtoType.TypeMessage + +proc isEnum(field: Field): bool = + result = field.ftype == google_protobuf_FieldDescriptorProtoType.TypeEnum + +proc isNumeric(field: Field): bool = + case field.ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble, google_protobuf_FieldDescriptorProtoType.TypeFloat, + google_protobuf_FieldDescriptorProtoType.TypeInt64, google_protobuf_FieldDescriptorProtoType.TypeUInt64, + google_protobuf_FieldDescriptorProtoType.TypeInt32, google_protobuf_FieldDescriptorProtoType.TypeFixed64, + google_protobuf_FieldDescriptorProtoType.TypeFixed32, google_protobuf_FieldDescriptorProtoType.TypeBool, + google_protobuf_FieldDescriptorProtoType.TypeUInt32, google_protobuf_FieldDescriptorProtoType.TypeEnum, + google_protobuf_FieldDescriptorProtoType.TypeSFixed32, google_protobuf_FieldDescriptorProtoType.TypeSFixed64, + google_protobuf_FieldDescriptorProtoType.TypeSInt32, google_protobuf_FieldDescriptorProtoType.TypeSInt64: + result = true + else: discard + +proc isMapEntry(message: Message): bool = + result = message.mapEntry + +proc isMapEntry(field: Field): bool = + result = field.mapEntry != nil + +proc nimTypeName(field: Field): string = + case field.ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "float64" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "float32" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "int64" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "uint64" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "int32" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "uint64" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "uint32" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "bool" + of google_protobuf_FieldDescriptorProtoType.TypeString: result = "string" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = field.typeName + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "bytes" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "uint32" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = field.typeName + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "int32" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "int64" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "int32" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "int64" + +proc mapKeyType(field: Field): string = + for f in field.mapEntry.fields: + if f.name == "key": + return f.nimTypeName + +proc mapValueField(field: Field): Field = + for f in field.mapEntry.fields: + if f.name == "value": + return f + +proc mapValueType(field: Field): string = + for f in field.mapEntry.fields: + if f.name == "value": + return f.nimTypeName + +proc `$`(ft: google_protobuf_FieldDescriptorProtoType): string = + case ft + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "Double" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "Float" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "Int64" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "UInt64" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "Int32" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "Bool" + of google_protobuf_FieldDescriptorProtoType.TypeString: result = "String" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "Group" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = "Message" + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "Bytes" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "UInt32" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = "Enum" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "SFixed32" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "SFixed64" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "SInt32" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "SInt64" + +proc defaultValue(ftype: google_protobuf_FieldDescriptorProto_Type): string = + case ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "false" + of google_protobuf_FieldDescriptorProtoType.TypeString: result = "\"\"" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = "nil" + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "bytes(\"\")" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "0" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "0" + +proc findEnum(file: ProtoFile, typeName: string): Enum = + for e in file.enums: + if $e.names == typeName: + return e + for dep in file.dependencies: + result = findEnum(dep, typeName) + if result != nil: + break + +proc defaultValue(field: Field): string = + if field.defaultValue != nil: + if isEnum(field): + return &"{field.typeName}.{field.defaultValue}" + elif field.ftype == google_protobuf_FieldDescriptorProtoType.TypeString: + return escape(field.defaultValue) + else: + return field.defaultValue + elif isMapEntry(field): + return &"newTable[{field.mapKeyType}, {field.mapValueType}]()" + elif isRepeated(field): + return "@[]" + elif isEnum(field): + let e = findEnum(field.message.file, field.typeName) + if e != nil: + result = e.defaultValue + else: + result = &"cast[{field.typeName}](0)" + else: + result = defaultValue(field.ftype) + +proc wiretypeStr(field: Field): string = + result = "WireType." + case field.ftype + of google_protobuf_FieldDescriptorProtoType.TypeDouble: result &= "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeFloat: result &= "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeInt64: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeInt32: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result &= "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result &= "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeBool: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeString: result &= "LengthDelimited" + of google_protobuf_FieldDescriptorProtoType.TypeGroup: result &= "" + of google_protobuf_FieldDescriptorProtoType.TypeMessage: result &= "LengthDelimited" + of google_protobuf_FieldDescriptorProtoType.TypeBytes: result &= "LengthDelimited" + of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeEnum: result &= &"Varint" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result &= "Fixed32" + of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result &= "Fixed64" + of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result &= "Varint" + of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result &= "Varint" + +proc fieldTypeStr(field: Field): string = + result = "FieldType." & $field.ftype + +proc isKeyword(s: string): bool = + case s + of "addr", "and", "as", "asm", "bind", "block", "break", "case", "cast", + "concept", "const", "continue", "converter", "defer", "discard", + "distinct", "div", "do", "elif", "else", "end", "enum", "except", + "export", "finally", "for", "from", "func", "if", "import", "in", + "include", "interface", "is", "isnot", "iterator", "let", "macro", + "method", "mixin", "mod", "nil", "not", "notin", "object", "of", "or", + "out", "proc", "ptr", "raise", "ref", "return", "shl", "shr", "static", + "template", "try", "tuple", "type", "using", "var", "when", "while", + "xor", "yield": + result = true + else: + result = false + +proc writeProc(field: Field): string = + if isMapEntry(field): + result = &"write{field.typeName}KV" + elif isMessage(field): + result = "writeMessage" + elif isEnum(field): + result = "writeEnum" + else: + result = &"write{field.typeName}" + +proc readProc(field: Field): string = + if isMapEntry(field): + result = &"read{field.typeName}KV" + elif isEnum(field): + result = &"readEnum[{field.typeName}]" + else: + result = &"read{field.typeName}" + +proc sizeOfProc(field: Field): string = + if isMapEntry(field): + result = &"sizeOf{field.typeName}KV" + elif isEnum(field): + result = &"sizeOfEnum[{field.typeName}]" + else: + result = &"sizeOf{field.typeName}" + +proc newField(file: ProtoFile, message: Message, desc: google_protobuf_FieldDescriptorProto): Field = + new(result) + + result.name = desc.name + result.number = desc.number + result.label = desc.label + result.ftype = desc.ftype + result.typeName = "" + result.packed = false + result.mapEntry = nil + result.message = message + + # Identifiers cannot start/end with underscore + removePrefix(result.name, '_') + removeSuffix(result.name, '_') + + # Consecutive underscores are not allowed + result.name = replace(result.name, peg"'_' '_'+", "_") + + if isKeyword(result.name): + result.name = "f" & result.name + + if isRepeated(result) and isNumeric(result): + if hasOptions(desc): + if hasPacked(desc.options): + result.packed = desc.options.packed + else: + result.packed = + if file.syntax == Syntax.Proto2: + false + else: + true + else: + result.packed = + if file.syntax == Syntax.Proto2: + false + else: + true + + if hasOneof_index(desc): + result.oneof = message.oneofs[desc.oneof_index] + add(result.oneof.fields, result) + + if isMessage(result) or isEnum(result): + result.typeName = $initNamesFromTypeName(desc.type_name) + else: + result.typeName = $result.ftype + + if hasDefaultValue(desc): + result.defaultValue = desc.default_value + + if hasJsonName(desc): + result.jsonName = desc.jsonName + + log(&"newField {result.name} {$result.ftype} {result.typeName} PACKED={result.packed} SYNTAX={file.syntax}") + +proc newOneof(name: string): Oneof = + new(result) + result.fields = @[] + result.name = name + +proc newMessage(file: ProtoFile, names: Names, desc: google_protobuf_DescriptorProto): Message = + new(result) + + result.names = names + result.fields = @[] + result.oneofs = @[] + result.mapEntry = false + result.file = file + + if hasOptions(desc) and hasMapEntry(desc.options): + result.mapEntry = desc.options.mapEntry + + log(&"newMessage {$result.names}") + + for oneof in desc.oneof_decl: + add(result.oneofs, newOneof(oneof.name)) + + for field in desc.field: + add(result.fields, newField(file, result, field)) + +proc fixMapEntry(file: ProtoFile, message: Message): bool = + for field in message.fields: + for msg in file.messages: + if $msg.names == field.typeName: + if msg.mapEntry: + log(&"fixing map {field.name} {msg.names}") + field.mapEntry = msg + result = true + +proc newEnum(names: Names, desc: google_protobuf_EnumDescriptorProto): Enum = + new(result) + + result.names = names & desc.name + result.values = @[] + + log(&"newEnum {$result.names}") + + for value in desc.value: + add(result.values, (value.name, int(value.number))) + + result.defaultValue = &"{result.names}.{result.values[0].name}" + + type EnumValue = tuple[name: string, number: int] + + sort(result.values, proc (x, y: EnumValue): int = + system.cmp(x.number, y.number) + ) + +proc newService(service: google_protobuf_ServiceDescriptorProto, + file: ProtoFile): Service = + new(result) + result.name = service.name + result.package = file.fdesc.package + result.methods = @[] + + for meth in service.fmethod: + var m: ServiceMethod + new(m) + + m.name = meth.name + m.inputType = $initNamesFromTypeName(meth.inputType) + m.outputType = $initNamesFromTypeName(meth.outputType) + m.clientStreaming = meth.clientStreaming + m.serverStreaming = meth.serverStreaming + + add(result.methods, m) + +iterator messages(desc: google_protobuf_DescriptorProto, names: Names): tuple[names: Names, desc: google_protobuf_DescriptorProto] = + var stack: seq[tuple[names: Names, desc: google_protobuf_DescriptorProto]] = @[] + + for nested in desc.nested_type: + add(stack, (names, nested)) + + while len(stack) > 0: + let (names, submsg) = pop(stack) + + let subnames = names & submsg.name + yield (subnames, submsg) + + for desc in submsg.nested_type: + add(stack, (subnames, desc)) + +iterator messages(fdesc: google_protobuf_FileDescriptorProto, names: Names): tuple[names: Names, desc: google_protobuf_DescriptorProto] = + for desc in fdesc.message_type: + let subnames = names & desc.name + yield (subnames, desc) + + for x in messages(desc, subnames): + yield x + +proc quoteReserved(name: string): string = + case name + of "type": result = &"`{name}`" + else: result = name + +proc accessor(field: Field): string = + if field.oneof != nil: + result = &"{field.oneof.name}.{quoteReserved(field.name)}" + else: + result = quoteReserved(field.name) + +proc dependencies(field: Field): seq[string] = + result = @[] + + if isMessage(field) or isEnum(field): + add(result, field.typeName) + +proc dependencies(message: Message): seq[string] = + result = @[] + + for field in message.fields: + add(result, dependencies(field)) + +proc toposort(graph: TableRef[string, HashSet[string]]): seq[string] = + type State = enum Unknown, Gray, Black + + var + enter = toSeq(keys(graph)) + state = newTable[string, State]() + order: seq[string] = @[] + + proc dfs(node: string) = + state[node] = Gray + if node in graph: + for k in graph[node]: + let sk = + if k in state: + state[k] + else: + Unknown + + if sk == Gray: + # cycle + continue + elif sk == Black: + continue + + let idx = find(enter, k) + if idx != -1: + delete(enter, idx) + + dfs(k) + insert(order, node, 0) + state[node] = Black + + while len(enter) > 0: + dfs(pop(enter)) + + result = order + +iterator sortDependencies(messages: seq[Message]): Message = + let + deps = newTable[string, HashSet[string]]() + byname = newTable[string, Message]() + + for message in messages: + deps[$message.names] = toSet(dependencies(message)) + byname[$message.names] = message + + let order = reversed(toposort(deps)) + + for name in order: + if name in byname: + yield byname[name] + +proc parseFile(name: string, fdesc: google_protobuf_FileDescriptorProto): ProtoFile = + log(&"parsing {name}") + + new(result) + + result.fdesc = fdesc + result.messages = @[] + result.enums = @[] + result.dependencies = @[] + + if hasSyntax(fdesc): + if fdesc.syntax == "proto2": + result.syntax = Syntax.Proto2 + elif fdesc.syntax == "proto3": + result.syntax = Syntax.Proto3 + else: + raise newException(Exception, "unrecognized syntax: " & fdesc.syntax) + else: + result.syntax = Syntax.Proto2 + + let basename = + if hasPackage(fdesc): + Names(split(fdesc.package, ".")) + else: + Names(@[]) + + for e in fdesc.enum_type: + add(result.enums, newEnum(basename, e)) + + for name, message in messages(fdesc, basename): + add(result.messages, newMessage(result, name, message)) + + for e in message.enum_type: + add(result.enums, newEnum(name, e)) + +proc addLine(s: var string, line: string) = + if not isNilOrWhitespace(line): + s &= line + s &= "\n" + +iterator genType(e: Enum): string = + yield &"{e.names}* {{.pure.}} = enum" + for item in e.values: + let (name, number) = item + yield indent(&"{name} = {number}", 4) + +proc fullType(field: Field): string = + if isMapEntry(field): + result = &"TableRef[{field.mapKeyType}, {field.mapValueType}]" + else: + result = field.nimTypeName + if isRepeated(field): + result = &"seq[{result}]" + +proc mapKeyField(message: Message): Field = + for field in message.fields: + if field.name == "key": + return field + +proc mapValueField(message: Message): Field = + for field in message.fields: + if field.name == "value": + return field + +iterator genType(message: Message): string = + if not isMapEntry(message): + yield &"{message.names}* = ref {message.names}Obj" + yield &"{message.names}Obj* = object of RootObj" + yield indent(&"hasField: IntSet", 4) + yield indent(&"unknownFields: seq[UnknownField]", 4) + + for field in message.fields: + if isMapEntry(field): + yield indent(&"{field.name}: TableRef[{mapKeyType(field)}, {mapValueType(field)}]", 4) + elif field.oneof == nil: + yield indent(&"{quoteReserved(field.name)}: {field.fullType}", 4) + + for oneof in message.oneofs: + yield indent(&"{oneof.name}: {message.names}_{oneof.name}_OneOf", 4) + + for oneof in message.oneofs: + yield "" + yield &"{message.names}_{oneof.name}_OneOf* {{.union.}} = object" + for field in oneof.fields: + yield indent(&"{quoteReserved(field.name)}: {field.fullType}", 4) + +iterator genNewMessageProc(msg: Message): string = + yield &"proc new{msg.names}*(): {msg.names} =" + yield indent("new(result)", 4) + yield indent("result.hasField = initIntSet()", 4) + yield indent("result.unknownFields = @[]", 4) + for field in msg.fields: + yield indent(&"result.{field.accessor} = {defaultValue(field)}", 4) + yield "" + +iterator oneofSiblings(field: Field): Field = + if field.oneof != nil: + for sibling in field.oneof.fields: + if sibling == field: + continue + yield sibling + +iterator genClearFieldProc(msg: Message, field: Field): string = + yield &"proc clear{field.name}*(message: {msg.names}) =" + yield indent(&"message.{field.accessor} = {defaultValue(field)}", 4) + var numbers: seq[int] = @[field.number] + for sibling in oneofSiblings(field): + add(numbers, sibling.number) + yield indent(&"excl(message.hasField, [{join(numbers, \", \")}])", 4) + yield "" + +iterator genHasFieldProc(msg: Message, field: Field): string = + yield &"proc has{field.name}*(message: {msg.names}): bool =" + var check = indent(&"result = contains(message.hasField, {field.number})", 4) + if isRepeated(field) or isMapEntry(field): + check = &"{check} or (len(message.{field.accessor}) > 0)" + yield check + yield "" + +iterator genSetFieldProc(msg: Message, field: Field): string = + yield &"proc set{field.name}*(message: {msg.names}, value: {field.fullType}) =" + yield indent(&"message.{field.accessor} = value", 4) + yield indent(&"incl(message.hasField, {field.number})", 4) + var numbers: seq[int] = @[] + for sibling in oneofSiblings(field): + add(numbers, sibling.number) + if len(numbers) > 0: + yield indent(&"excl(message.hasField, [{join(numbers, \", \")}])", 4) + yield "" + +iterator genAddToFieldProc(msg: Message, field: Field): string = + yield &"proc add{field.name}*(message: {msg.names}, value: {field.nimTypeName}) =" + yield indent(&"add(message.{field.name}, value)", 4) + yield indent(&"incl(message.hasField, {field.number})", 4) + yield "" + +iterator genFieldAccessorProcs(msg: Message, field: Field): string = + yield &"proc {quoteReserved(field.name)}*(message: {msg.names}): {field.fullType} {{.inline.}} =" + yield indent(&"message.{field.accessor}", 4) + yield "" + + yield &"proc `{field.name}=`*(message: {msg.names}, value: {field.fullType}) {{.inline.}} =" + yield indent(&"set{field.name}(message, value)", 4) + yield "" + +iterator genWriteMapKVProc(msg: Message): string = + let + key = mapKeyField(msg) + value = mapValueField(msg) + + yield &"proc write{msg.names}KV(stream: ProtobufStream, key: {key.fullType}, value: {value.fullType}) =" + yield indent(&"{key.writeProc}(stream, key, {key.number})", 4) + yield indent(&"{value.writeProc}(stream, value, {value.number})", 4) + yield "" + +iterator genWriteMessageProc(msg: Message): string = + yield &"proc write{msg.names}*(stream: ProtobufStream, message: {msg.names}) =" + + for field in msg.fields: + if isMapEntry(field): + yield indent(&"for key, value in message.{field.name}:", 4) + yield indent(&"writeTag(stream, {field.number}, {wiretypeStr(field)})", 8) + yield indent(&"writeVarint(stream, {field.sizeOfProc}(key, value))", 8) + yield indent(&"{field.writeProc}(stream, key, value)", 8) + elif isRepeated(field): + if field.packed: + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"writeTag(stream, {field.number}, WireType.LengthDelimited)", 8) + yield indent(&"writeVarint(stream, packedFieldSize(message.{field.name}, {field.fieldTypeStr}))", 8) + yield indent(&"for value in message.{field.name}:", 8) + yield indent(&"{field.writeProc}(stream, value)", 12) + else: + yield indent(&"for value in message.{field.name}:", 4) + yield indent(&"{field.writeProc}(stream, value, {field.number})", 8) + else: + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"{field.writeProc}(stream, message.{field.accessor}, {field.number})", 8) + + yield indent("writeUnknownFields(stream, message.unknownFields)", 4) + + yield "" + +iterator genReadMapKVProc(msg: Message): string = + let + key = mapKeyField(msg) + value = mapValueField(msg) + + yield &"proc read{msg.names}KV(stream: ProtobufStream, tbl: TableRef[{key.fullType}, {value.fullType}]) =" + + yield indent(&"var", 4) + yield indent(&"key: {key.fullType}", 8) + yield indent("gotKey = false", 8) + yield indent(&"value: {value.fullType}", 8) + yield indent("gotValue = false", 8) + yield indent("while not atEnd(stream):", 4) + yield indent("let", 8) + yield indent("tag = readTag(stream)", 12) + yield indent("wireType = wireType(tag)", 12) + yield indent("case fieldNumber(tag)", 8) + yield indent(&"of {key.number}:", 8) + yield indent(&"key = {key.readProc}(stream)", 12) + yield indent("gotKey = true", 12) + yield indent(&"of {value.number}:", 8) + if isMessage(value): + yield indent("let", 12) + yield indent("size = readVarint(stream)", 16) + yield indent("data = safeReadStr(stream, int(size))", 16) + yield indent("pbs = newProtobufStream(newStringStream(data))", 16) + yield indent(&"value = {value.readProc}(pbs)", 12) + else: + yield indent(&"value = {value.readProc}(stream)", 12) + yield indent("gotValue = true", 12) + yield indent("else: skipField(stream, wireType)", 8) + yield indent("if not gotKey:", 4) + yield indent(&"raise newException(Exception, \"missing key\")", 8) + yield indent("if not gotValue:", 4) + yield indent(&"raise newException(Exception, \"missing value\")", 8) + yield indent("tbl[key] = value", 4) + yield "" + +iterator genReadMessageProc(msg: Message): string = + yield &"proc read{msg.names}*(stream: ProtobufStream): {msg.names} =" + yield indent(&"result = new{msg.names}()", 4) + yield indent("while not atEnd(stream):", 4) + yield indent("let", 8) + yield indent("tag = readTag(stream)", 12) + yield indent("wireType = wireType(tag)", 12) + yield indent("case fieldNumber(tag)", 8) + yield indent("of 0:", 8) + yield indent("raise newException(InvalidFieldNumberError, \"Invalid field number: 0\")", 12) + for field in msg.fields: + let + setter = + if isRepeated(field): + &"add{field.name}" + else: + &"set{field.name}" + yield indent(&"of {field.number}:", 8) + if isRepeated(field): + if isMapEntry(field): + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + yield indent("let", 12) + yield indent("size = readVarint(stream)", 16) + yield indent("data = safeReadStr(stream, int(size))", 16) + yield indent("pbs = newProtobufStream(newStringStream(data))", 16) + yield indent(&"{field.readProc}(pbs, result.{field.name})", 12) + elif isNumeric(field): + yield indent(&"expectWireType(wireType, {field.wiretypeStr}, WireType.LengthDelimited)", 12) + yield indent("if wireType == WireType.LengthDelimited:", 12) + yield indent("let", 16) + yield indent("size = readVarint(stream)", 20) + yield indent("start = uint64(getPosition(stream))", 20) + yield indent("var consumed = 0'u64", 16) + yield indent("while consumed < size:", 16) + yield indent(&"{setter}(result, {field.readProc}(stream))", 20) + yield indent("consumed = uint64(getPosition(stream)) - start", 20) + yield indent("if consumed != size:", 16) + yield indent("raise newException(Exception, \"packed field size mismatch\")", 20) + yield indent("else:", 12) + yield indent(&"{setter}(result, {field.readProc}(stream))", 16) + elif isMessage(field): + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + yield indent(&"let data = readLengthDelimited(stream)", 12) + yield indent(&"{setter}(result, new{field.typeName}(data))", 12) + else: + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + yield indent(&"{setter}(result, {field.readProc}(stream))", 12) + else: + yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) + if isMessage(field): + yield indent("let data = readLengthDelimited(stream)", 12) + yield indent(&"{setter}(result, new{field.typeName}(data))", 12) + else: + yield indent(&"{setter}(result, {field.readProc}(stream))", 12) + yield indent("else: readUnknownField(stream, tag, result.unknownFields)", 8) + yield "" + +iterator genSizeOfMapKVProc(message: Message): string = + let + key = mapKeyField(message) + value = mapValueField(message) + + yield &"proc sizeOf{message.names}KV(key: {key.fullType}, value: {value.fullType}): uint64 =" + + # Key (cannot be message or other complex field) + yield indent(&"result = result + sizeOfTag({key.number}, {key.wiretypeStr})", 4) + yield indent(&"result = result + {key.sizeOfProc}(key)", 4) + + # Value + yield indent(&"result = result + sizeOfTag({value.number}, {value.wiretypeStr})", 4) + if isMessage(value): + yield indent(&"result = result + sizeOfLengthDelimited({value.sizeOfProc}(value))", 4) + else: + yield indent(&"result = result + {value.sizeOfProc}(value)", 4) + + yield "" + +iterator genSizeOfMessageProc(msg: Message): string = + yield &"proc sizeOf{msg.names}*(message: {msg.names}): uint64 =" + for field in msg.fields: + if isMapEntry(field): + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"var sizeOfKV = 0'u64", 8) + yield indent(&"for key, value in message.{field.name}:", 8) + yield indent(&"sizeOfKV = sizeOfKV + {field.sizeOfProc}(key, value)", 12) + yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) + yield indent(&"result = result + sizeOfLengthDelimited(sizeOfKV)", 8) + elif isRepeated(field): + if isNumeric(field): + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"result = result + sizeOfTag({field.number}, WireType.LengthDelimited)", 8) + yield indent(&"result = result + sizeOfLengthDelimited(packedFieldSize(message.{field.name}, {field.fieldTypeStr}))", 8) + else: + yield indent(&"for value in message.{field.name}:", 4) + yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) + if isMessage(field): + yield indent(&"result = result + sizeOfLengthDelimited({field.sizeOfProc}(value))", 8) + else: + yield indent(&"result = result + {field.sizeOfProc}(value)", 8) + else: + yield indent(&"if has{field.name}(message):", 4) + yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) + if isMessage(field): + yield indent(&"result = result + sizeOfLengthDelimited({field.sizeOfProc}(message.{field.accessor}))", 8) + else: + yield indent(&"result = result + {field.sizeOfProc}(message.{field.accessor})", 8) + + yield indent("for field in message.unknownFields:", 4) + yield indent("result = result + sizeOfUnknownField(field)", 8) + + yield "" + +proc shouldGenerateJsonProcs(typeName: string): bool = + const wktsHavingCustomProcs = [ + "google_protobuf_Any", + "google_protobuf_BoolValue", + "google_protobuf_BytesValue", + "google_protobuf_DoubleValue", + "google_protobuf_Duration", + "google_protobuf_FieldMask", + "google_protobuf_FloatValue", + "google_protobuf_Int32Value", + "google_protobuf_Int64Value", + "google_protobuf_ListValue", + "google_protobuf_NullValue", + "google_protobuf_StringValue", + "google_protobuf_Struct", + "google_protobuf_Timestamp", + "google_protobuf_UInt32Value", + "google_protobuf_UInt64Value", + "google_protobuf_Value", + ] + + return typeName notin wktsHavingCustomProcs + +iterator genMessageToJsonProc(msg: Message): string = + yield &"proc toJson*(message: {msg.names}): JsonNode =" + yield indent("result = newJObject()", 4) + + proc fieldToJson(field: Field, v: string): string = + case field.ftype + of google_protobuf_FieldDescriptorProto_Type.TypeMessage, + google_protobuf_FieldDescriptorProto_Type.TypeInt64, + google_protobuf_FieldDescriptorProto_Type.TypeUInt64, + google_protobuf_FieldDescriptorProto_Type.TypeSFixed64, + google_protobuf_FieldDescriptorProto_Type.TypeFixed64, + google_protobuf_FieldDescriptorProto_Type.TypeDouble, + google_protobuf_FieldDescriptorProto_Type.TypeFloat: + result = &"toJson({v})" + of google_protobuf_FieldDescriptorProto_Type.TypeEnum: + result = &"%(${v})" + else: + result = &"%{v}" + + for field in msg.fields: + yield indent(&"if has{field.name}(message):", 4) + if isMapEntry(field): + yield indent("let obj = newJObject()", 8) + yield indent(&"for key, value in message.{field.name}:", 8) + let f = mapValueField(field) + let j = fieldToJson(f, "value") + yield indent(&"obj[$key] = {j}", 12) + yield indent(&"result[\"{field.jsonName}\"] = obj", 8) + elif isRepeated(field): + yield indent(&"let arr = newJArray()", 8) + yield indent(&"for value in message.{field.name}:", 8) + let v = fieldToJson(field, "value") + yield indent(&"add(arr, {v})", 12) + yield indent(&"result[\"{field.jsonName}\"] = arr", 8) + else: + let v = fieldToJson(field, &"message.{field.name}") + yield indent(&"result[\"{field.jsonName}\"] = {v}", 8) + + yield "" + +iterator genMessageProcForwards(msg: Message): string = + # TODO: can we be more intelligent and only forward declare the minimum set + # of procs? + if not isMapEntry(msg): + yield &"proc new{msg.names}*(): {msg.names}" + yield &"proc new{msg.names}*(data: string): {msg.names}" + yield &"proc write{msg.names}*(stream: ProtobufStream, message: {msg.names})" + yield &"proc read{msg.names}*(stream: ProtobufStream): {msg.names}" + yield &"proc sizeOf{msg.names}*(message: {msg.names}): uint64" + if shouldGenerateJsonProcs($msg.names): + yield &"proc toJson*(message: {msg.names}): JsonNode" + else: + let + key = mapKeyField(msg) + value = mapValueField(msg) + + yield &"proc write{msg.names}KV(stream: ProtobufStream, key: {key.fullType}, value: {value.fullType})" + yield &"proc read{msg.names}KV(stream: ProtobufStream, tbl: TableRef[{key.fullType}, {value.fullType}])" + yield &"proc sizeOf{msg.names}KV(key: {key.fullType}, value: {value.fullType}): uint64" + +iterator genProcs(msg: Message): string = + if isMapEntry(msg): + for line in genSizeOfMapKVProc(msg): yield line + for line in genWriteMapKVProc(msg): yield line + for line in genReadMapKVProc(msg): yield line + else: + for line in genNewMessageProc(msg): yield line + + for field in msg.fields: + for line in genClearFieldProc(msg, field): yield line + for line in genHasFieldProc(msg, field): yield line + for line in genSetFieldProc(msg, field): yield line + + if isRepeated(field) and not isMapEntry(field): + for line in genAddToFieldProc(msg, field): yield line + + for line in genFieldAccessorProcs(msg, field): yield line + + for line in genSizeOfMessageProc(msg): yield line + for line in genWriteMessageProc(msg): yield line + for line in genReadMessageProc(msg): yield line + + if shouldGenerateJsonProcs($msg.names): + for line in genMessageToJsonProc(msg): yield line + + yield &"proc serialize*(message: {msg.names}): string =" + yield indent("let", 4) + yield indent("ss = newStringStream()", 8) + yield indent("pbs = newProtobufStream(ss)", 8) + yield indent(&"write{msg.names}(pbs, message)", 4) + yield indent("result = ss.data", 4) + yield "" + + yield &"proc new{msg.names}*(data: string): {msg.names} =" + yield indent("let", 4) + yield indent("ss = newStringStream(data)", 8) + yield indent("pbs = newProtobufStream(ss)", 8) + yield indent(&"result = read{msg.names}(pbs)", 4) + yield "" + +proc processFile(fdesc: google_protobuf_FileDescriptorProto, + otherFiles: TableRef[string, ProtoFile], + serviceGenerator: ServiceGenerator): ProcessedFile = + var (dir, name, _) = splitFile(fdesc.name) + var pbfilename = (dir / name) & "_pb.nim" + + log(&"processing {fdesc.name}: {pbfilename}") + + new(result) + result.name = pbfilename + result.data = "" + + let parsed = parseFile(fdesc.name, fdesc) + + for dep in fdesc.dependency: + if dep in otherFiles: + add(parsed.dependencies, otherFiles[dep]) + + var hasMaps = false + for message in parsed.messages: + let tmp = fixMapEntry(parsed, message) + if tmp: + hasMaps = true + + addLine(result.data, "# Generated by protoc_gen_nim. Do not edit!") + addLine(result.data, "") + addLine(result.data, "import base64") + addLine(result.data, "import intsets") + addLine(result.data, "import json") + if hasMaps: + addLine(result.data, "import tables") + addLine(result.data, "export tables") + addLine(result.data, "") + addLine(result.data, "import nimpb/nimpb") + addLine(result.data, "import nimpb/json as nimpb_json") + addLine(result.data, "") + + for dep in fdesc.dependency: + var (dir, depname, _) = splitFile(dep) + + if dir == "google/protobuf": + dir = "nimpb/wkt" + + var deppbname = (dir / depname) & "_pb" + addLine(result.data, &"import {deppbname}") + + if hasDependency(fdesc): + addLine(result.data, "") + + addLine(result.data, "type") + + for e in parsed.enums: + for line in genType(e): addLine(result.data, indent(line, 4)) + + for message in parsed.messages: + for line in genType(message): addLine(result.data, indent(line, 4)) + + addLine(result.data, "") + + for message in sortDependencies(parsed.messages): + for line in genMessageProcForwards(message): + addLine(result.data, line) + addLine(result.data, "") + + for message in sortDependencies(parsed.messages): + for line in genProcs(message): + addLine(result.data, line) + addLine(result.data, "") + + if serviceGenerator != nil: + for serviceDesc in fdesc.service: + let service = newService(serviceDesc, parsed) + addLine(result.data, "") + add(result.data, serviceGenerator(service)) + +proc processFileDescriptorSet*(filename: string, + outdir: string, + protos: openArray[string], + serviceGenerator: ServiceGenerator) = + let s = newProtobufStream(newFileStream(filename, fmRead)) + + let fileSet = readgoogle_protobuf_FileDescriptorSet(s) + + var otherFiles = newTable[string, ProtoFile]() + + for file in fileSet.file: + add(otherFiles, file.name, parseFile(file.name, file)) + + # Protoc does not provide full paths for files in FileDescriptorSet. So it + # can be that fileSet.file.name might match any file in protos. So we will + # try to match the bare name and the named joined with the path of the first + # file. + let basePath = parentDir(protos[0]) + + for file in fileSet.file: + if (file.name in protos) or ((basePath / file.name) in protos): + let processedFile = processFile(file, otherFiles, serviceGenerator) + + let fullPath = outdir / processedFile.name + + createDir(parentDir(fullPath)) + + writeFile(fullPath, processedFile.data) diff --git a/nimpb/compiler/plugin.nim b/nimpb/compiler/plugin.nim deleted file mode 100644 index abdad07..0000000 --- a/nimpb/compiler/plugin.nim +++ /dev/null @@ -1,1084 +0,0 @@ -import algorithm -import os -import pegs -import sequtils -import sets -import strformat -import strutils -import tables - -import descriptor_pb - -import nimpb/nimpb - -type - Names = distinct seq[string] - - Enum = ref object - names: Names - values: seq[tuple[name: string, number: int]] - defaultValue: string - - Field = ref object - number: int - name: string - label: google_protobuf_FieldDescriptorProto_Label - ftype: google_protobuf_FieldDescriptorProto_Type - typeName: string - packed: bool - oneof: Oneof - mapEntry: Message - defaultValue: string - message: Message - jsonName: string - - Message = ref object - names: Names - fields: seq[Field] - oneofs: seq[Oneof] - mapEntry: bool - file: ProtoFile - - Oneof = ref object - name: string - fields: seq[Field] - - ProcessedFile = ref object - name: string - data: string - - ProtoFile = ref object - fdesc: google_protobuf_FileDescriptorProto - enums: seq[Enum] - messages: seq[Message] - syntax: Syntax - dependencies: seq[ProtoFile] - serviceGenerator: ServiceGenerator - - Syntax {.pure.} = enum - Proto2 - Proto3 - - ServiceGenerator* = proc (service: Service): string - - Service* = ref object - name*: string - package*: string - methods*: seq[ServiceMethod] - - ServiceMethod* = ref object - name*: string - inputType*: string - outputType*: string - clientStreaming*: bool - serverStreaming*: bool - -when defined(debug): - proc log(msg: string) = - stderr.write(msg) - stderr.write("\n") -else: - proc log(msg: string) = discard - -proc initNamesFromTypeName(typename: string): Names = - if typename[0] != '.': - raise newException(Exception, "relative names not supported") - let parts = split(typename[1..^1], ".") - result = Names(parts) - -proc `$`(names: Names): string = - let n = seq[string](names) - result = join(n, "_") - -proc add(names: var Names, s: string) = - add(seq[string](names), s) - -proc `&`(names: Names, s: string): Names = - result = names - add(result, s) - -proc isRepeated(field: Field): bool = - result = field.label == google_protobuf_FieldDescriptorProtoLabel.LabelRepeated - -proc isMessage(field: Field): bool = - result = field.ftype == google_protobuf_FieldDescriptorProtoType.TypeMessage - -proc isEnum(field: Field): bool = - result = field.ftype == google_protobuf_FieldDescriptorProtoType.TypeEnum - -proc isNumeric(field: Field): bool = - case field.ftype - of google_protobuf_FieldDescriptorProtoType.TypeDouble, google_protobuf_FieldDescriptorProtoType.TypeFloat, - google_protobuf_FieldDescriptorProtoType.TypeInt64, google_protobuf_FieldDescriptorProtoType.TypeUInt64, - google_protobuf_FieldDescriptorProtoType.TypeInt32, google_protobuf_FieldDescriptorProtoType.TypeFixed64, - google_protobuf_FieldDescriptorProtoType.TypeFixed32, google_protobuf_FieldDescriptorProtoType.TypeBool, - google_protobuf_FieldDescriptorProtoType.TypeUInt32, google_protobuf_FieldDescriptorProtoType.TypeEnum, - google_protobuf_FieldDescriptorProtoType.TypeSFixed32, google_protobuf_FieldDescriptorProtoType.TypeSFixed64, - google_protobuf_FieldDescriptorProtoType.TypeSInt32, google_protobuf_FieldDescriptorProtoType.TypeSInt64: - result = true - else: discard - -proc isMapEntry(message: Message): bool = - result = message.mapEntry - -proc isMapEntry(field: Field): bool = - result = field.mapEntry != nil - -proc nimTypeName(field: Field): string = - case field.ftype - of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "float64" - of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "float32" - of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "int64" - of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "uint64" - of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "int32" - of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "uint64" - of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "uint32" - of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "bool" - of google_protobuf_FieldDescriptorProtoType.TypeString: result = "string" - of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "" - of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = field.typeName - of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "bytes" - of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "uint32" - of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = field.typeName - of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "int32" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "int64" - of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "int32" - of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "int64" - -proc mapKeyType(field: Field): string = - for f in field.mapEntry.fields: - if f.name == "key": - return f.nimTypeName - -proc mapValueField(field: Field): Field = - for f in field.mapEntry.fields: - if f.name == "value": - return f - -proc mapValueType(field: Field): string = - for f in field.mapEntry.fields: - if f.name == "value": - return f.nimTypeName - -proc `$`(ft: google_protobuf_FieldDescriptorProtoType): string = - case ft - of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "Double" - of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "Float" - of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "Int64" - of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "UInt64" - of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "Int32" - of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "Fixed64" - of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "Fixed32" - of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "Bool" - of google_protobuf_FieldDescriptorProtoType.TypeString: result = "String" - of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "Group" - of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = "Message" - of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "Bytes" - of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "UInt32" - of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = "Enum" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "SFixed32" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "SFixed64" - of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "SInt32" - of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "SInt64" - -proc defaultValue(ftype: google_protobuf_FieldDescriptorProto_Type): string = - case ftype - of google_protobuf_FieldDescriptorProtoType.TypeDouble: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeFloat: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeInt64: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeInt32: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeBool: result = "false" - of google_protobuf_FieldDescriptorProtoType.TypeString: result = "\"\"" - of google_protobuf_FieldDescriptorProtoType.TypeGroup: result = "" - of google_protobuf_FieldDescriptorProtoType.TypeMessage: result = "nil" - of google_protobuf_FieldDescriptorProtoType.TypeBytes: result = "bytes(\"\")" - of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeEnum: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result = "0" - of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result = "0" - -proc findEnum(file: ProtoFile, typeName: string): Enum = - for e in file.enums: - if $e.names == typeName: - return e - for dep in file.dependencies: - result = findEnum(dep, typeName) - if result != nil: - break - -proc defaultValue(field: Field): string = - if field.defaultValue != nil: - if isEnum(field): - return &"{field.typeName}.{field.defaultValue}" - elif field.ftype == google_protobuf_FieldDescriptorProtoType.TypeString: - return escape(field.defaultValue) - else: - return field.defaultValue - elif isMapEntry(field): - return &"newTable[{field.mapKeyType}, {field.mapValueType}]()" - elif isRepeated(field): - return "@[]" - elif isEnum(field): - let e = findEnum(field.message.file, field.typeName) - if e != nil: - result = e.defaultValue - else: - result = &"cast[{field.typeName}](0)" - else: - result = defaultValue(field.ftype) - -proc wiretypeStr(field: Field): string = - result = "WireType." - case field.ftype - of google_protobuf_FieldDescriptorProtoType.TypeDouble: result &= "Fixed64" - of google_protobuf_FieldDescriptorProtoType.TypeFloat: result &= "Fixed32" - of google_protobuf_FieldDescriptorProtoType.TypeInt64: result &= "Varint" - of google_protobuf_FieldDescriptorProtoType.TypeUInt64: result &= "Varint" - of google_protobuf_FieldDescriptorProtoType.TypeInt32: result &= "Varint" - of google_protobuf_FieldDescriptorProtoType.TypeFixed64: result &= "Fixed64" - of google_protobuf_FieldDescriptorProtoType.TypeFixed32: result &= "Fixed32" - of google_protobuf_FieldDescriptorProtoType.TypeBool: result &= "Varint" - of google_protobuf_FieldDescriptorProtoType.TypeString: result &= "LengthDelimited" - of google_protobuf_FieldDescriptorProtoType.TypeGroup: result &= "" - of google_protobuf_FieldDescriptorProtoType.TypeMessage: result &= "LengthDelimited" - of google_protobuf_FieldDescriptorProtoType.TypeBytes: result &= "LengthDelimited" - of google_protobuf_FieldDescriptorProtoType.TypeUInt32: result &= "Varint" - of google_protobuf_FieldDescriptorProtoType.TypeEnum: result &= &"Varint" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed32: result &= "Fixed32" - of google_protobuf_FieldDescriptorProtoType.TypeSFixed64: result &= "Fixed64" - of google_protobuf_FieldDescriptorProtoType.TypeSInt32: result &= "Varint" - of google_protobuf_FieldDescriptorProtoType.TypeSInt64: result &= "Varint" - -proc fieldTypeStr(field: Field): string = - result = "FieldType." & $field.ftype - -proc isKeyword(s: string): bool = - case s - of "addr", "and", "as", "asm", "bind", "block", "break", "case", "cast", - "concept", "const", "continue", "converter", "defer", "discard", - "distinct", "div", "do", "elif", "else", "end", "enum", "except", - "export", "finally", "for", "from", "func", "if", "import", "in", - "include", "interface", "is", "isnot", "iterator", "let", "macro", - "method", "mixin", "mod", "nil", "not", "notin", "object", "of", "or", - "out", "proc", "ptr", "raise", "ref", "return", "shl", "shr", "static", - "template", "try", "tuple", "type", "using", "var", "when", "while", - "xor", "yield": - result = true - else: - result = false - -proc writeProc(field: Field): string = - if isMapEntry(field): - result = &"write{field.typeName}KV" - elif isMessage(field): - result = "writeMessage" - elif isEnum(field): - result = "writeEnum" - else: - result = &"write{field.typeName}" - -proc readProc(field: Field): string = - if isMapEntry(field): - result = &"read{field.typeName}KV" - elif isEnum(field): - result = &"readEnum[{field.typeName}]" - else: - result = &"read{field.typeName}" - -proc sizeOfProc(field: Field): string = - if isMapEntry(field): - result = &"sizeOf{field.typeName}KV" - elif isEnum(field): - result = &"sizeOfEnum[{field.typeName}]" - else: - result = &"sizeOf{field.typeName}" - -proc newField(file: ProtoFile, message: Message, desc: google_protobuf_FieldDescriptorProto): Field = - new(result) - - result.name = desc.name - result.number = desc.number - result.label = desc.label - result.ftype = desc.ftype - result.typeName = "" - result.packed = false - result.mapEntry = nil - result.message = message - - # Identifiers cannot start/end with underscore - removePrefix(result.name, '_') - removeSuffix(result.name, '_') - - # Consecutive underscores are not allowed - result.name = replace(result.name, peg"'_' '_'+", "_") - - if isKeyword(result.name): - result.name = "f" & result.name - - if isRepeated(result) and isNumeric(result): - if hasOptions(desc): - if hasPacked(desc.options): - result.packed = desc.options.packed - else: - result.packed = - if file.syntax == Syntax.Proto2: - false - else: - true - else: - result.packed = - if file.syntax == Syntax.Proto2: - false - else: - true - - if hasOneof_index(desc): - result.oneof = message.oneofs[desc.oneof_index] - add(result.oneof.fields, result) - - if isMessage(result) or isEnum(result): - result.typeName = $initNamesFromTypeName(desc.type_name) - else: - result.typeName = $result.ftype - - if hasDefaultValue(desc): - result.defaultValue = desc.default_value - - if hasJsonName(desc): - result.jsonName = desc.jsonName - - log(&"newField {result.name} {$result.ftype} {result.typeName} PACKED={result.packed} SYNTAX={file.syntax}") - -proc newOneof(name: string): Oneof = - new(result) - result.fields = @[] - result.name = name - -proc newMessage(file: ProtoFile, names: Names, desc: google_protobuf_DescriptorProto): Message = - new(result) - - result.names = names - result.fields = @[] - result.oneofs = @[] - result.mapEntry = false - result.file = file - - if hasOptions(desc) and hasMapEntry(desc.options): - result.mapEntry = desc.options.mapEntry - - log(&"newMessage {$result.names}") - - for oneof in desc.oneof_decl: - add(result.oneofs, newOneof(oneof.name)) - - for field in desc.field: - add(result.fields, newField(file, result, field)) - -proc fixMapEntry(file: ProtoFile, message: Message): bool = - for field in message.fields: - for msg in file.messages: - if $msg.names == field.typeName: - if msg.mapEntry: - log(&"fixing map {field.name} {msg.names}") - field.mapEntry = msg - result = true - -proc newEnum(names: Names, desc: google_protobuf_EnumDescriptorProto): Enum = - new(result) - - result.names = names & desc.name - result.values = @[] - - log(&"newEnum {$result.names}") - - for value in desc.value: - add(result.values, (value.name, int(value.number))) - - result.defaultValue = &"{result.names}.{result.values[0].name}" - - type EnumValue = tuple[name: string, number: int] - - sort(result.values, proc (x, y: EnumValue): int = - system.cmp(x.number, y.number) - ) - -proc newService(service: google_protobuf_ServiceDescriptorProto, - file: ProtoFile): Service = - new(result) - result.name = service.name - result.package = file.fdesc.package - result.methods = @[] - - for meth in service.fmethod: - var m: ServiceMethod - new(m) - - m.name = meth.name - m.inputType = $initNamesFromTypeName(meth.inputType) - m.outputType = $initNamesFromTypeName(meth.outputType) - m.clientStreaming = meth.clientStreaming - m.serverStreaming = meth.serverStreaming - - add(result.methods, m) - -iterator messages(desc: google_protobuf_DescriptorProto, names: Names): tuple[names: Names, desc: google_protobuf_DescriptorProto] = - var stack: seq[tuple[names: Names, desc: google_protobuf_DescriptorProto]] = @[] - - for nested in desc.nested_type: - add(stack, (names, nested)) - - while len(stack) > 0: - let (names, submsg) = pop(stack) - - let subnames = names & submsg.name - yield (subnames, submsg) - - for desc in submsg.nested_type: - add(stack, (subnames, desc)) - -iterator messages(fdesc: google_protobuf_FileDescriptorProto, names: Names): tuple[names: Names, desc: google_protobuf_DescriptorProto] = - for desc in fdesc.message_type: - let subnames = names & desc.name - yield (subnames, desc) - - for x in messages(desc, subnames): - yield x - -proc quoteReserved(name: string): string = - case name - of "type": result = &"`{name}`" - else: result = name - -proc accessor(field: Field): string = - if field.oneof != nil: - result = &"{field.oneof.name}.{quoteReserved(field.name)}" - else: - result = quoteReserved(field.name) - -proc dependencies(field: Field): seq[string] = - result = @[] - - if isMessage(field) or isEnum(field): - add(result, field.typeName) - -proc dependencies(message: Message): seq[string] = - result = @[] - - for field in message.fields: - add(result, dependencies(field)) - -proc toposort(graph: TableRef[string, HashSet[string]]): seq[string] = - type State = enum Unknown, Gray, Black - - var - enter = toSeq(keys(graph)) - state = newTable[string, State]() - order: seq[string] = @[] - - proc dfs(node: string) = - state[node] = Gray - if node in graph: - for k in graph[node]: - let sk = - if k in state: - state[k] - else: - Unknown - - if sk == Gray: - # cycle - continue - elif sk == Black: - continue - - let idx = find(enter, k) - if idx != -1: - delete(enter, idx) - - dfs(k) - insert(order, node, 0) - state[node] = Black - - while len(enter) > 0: - dfs(pop(enter)) - - result = order - -iterator sortDependencies(messages: seq[Message]): Message = - let - deps = newTable[string, HashSet[string]]() - byname = newTable[string, Message]() - - for message in messages: - deps[$message.names] = toSet(dependencies(message)) - byname[$message.names] = message - - let order = reversed(toposort(deps)) - - for name in order: - if name in byname: - yield byname[name] - -proc parseFile(name: string, fdesc: google_protobuf_FileDescriptorProto): ProtoFile = - log(&"parsing {name}") - - new(result) - - result.fdesc = fdesc - result.messages = @[] - result.enums = @[] - result.dependencies = @[] - - if hasSyntax(fdesc): - if fdesc.syntax == "proto2": - result.syntax = Syntax.Proto2 - elif fdesc.syntax == "proto3": - result.syntax = Syntax.Proto3 - else: - raise newException(Exception, "unrecognized syntax: " & fdesc.syntax) - else: - result.syntax = Syntax.Proto2 - - let basename = - if hasPackage(fdesc): - Names(split(fdesc.package, ".")) - else: - Names(@[]) - - for e in fdesc.enum_type: - add(result.enums, newEnum(basename, e)) - - for name, message in messages(fdesc, basename): - add(result.messages, newMessage(result, name, message)) - - for e in message.enum_type: - add(result.enums, newEnum(name, e)) - -proc addLine(s: var string, line: string) = - if not isNilOrWhitespace(line): - s &= line - s &= "\n" - -iterator genType(e: Enum): string = - yield &"{e.names}* {{.pure.}} = enum" - for item in e.values: - let (name, number) = item - yield indent(&"{name} = {number}", 4) - -proc fullType(field: Field): string = - if isMapEntry(field): - result = &"TableRef[{field.mapKeyType}, {field.mapValueType}]" - else: - result = field.nimTypeName - if isRepeated(field): - result = &"seq[{result}]" - -proc mapKeyField(message: Message): Field = - for field in message.fields: - if field.name == "key": - return field - -proc mapValueField(message: Message): Field = - for field in message.fields: - if field.name == "value": - return field - -iterator genType(message: Message): string = - if not isMapEntry(message): - yield &"{message.names}* = ref {message.names}Obj" - yield &"{message.names}Obj* = object of RootObj" - yield indent(&"hasField: IntSet", 4) - yield indent(&"unknownFields: seq[UnknownField]", 4) - - for field in message.fields: - if isMapEntry(field): - yield indent(&"{field.name}: TableRef[{mapKeyType(field)}, {mapValueType(field)}]", 4) - elif field.oneof == nil: - yield indent(&"{quoteReserved(field.name)}: {field.fullType}", 4) - - for oneof in message.oneofs: - yield indent(&"{oneof.name}: {message.names}_{oneof.name}_OneOf", 4) - - for oneof in message.oneofs: - yield "" - yield &"{message.names}_{oneof.name}_OneOf* {{.union.}} = object" - for field in oneof.fields: - yield indent(&"{quoteReserved(field.name)}: {field.fullType}", 4) - -iterator genNewMessageProc(msg: Message): string = - yield &"proc new{msg.names}*(): {msg.names} =" - yield indent("new(result)", 4) - yield indent("result.hasField = initIntSet()", 4) - yield indent("result.unknownFields = @[]", 4) - for field in msg.fields: - yield indent(&"result.{field.accessor} = {defaultValue(field)}", 4) - yield "" - -iterator oneofSiblings(field: Field): Field = - if field.oneof != nil: - for sibling in field.oneof.fields: - if sibling == field: - continue - yield sibling - -iterator genClearFieldProc(msg: Message, field: Field): string = - yield &"proc clear{field.name}*(message: {msg.names}) =" - yield indent(&"message.{field.accessor} = {defaultValue(field)}", 4) - var numbers: seq[int] = @[field.number] - for sibling in oneofSiblings(field): - add(numbers, sibling.number) - yield indent(&"excl(message.hasField, [{join(numbers, \", \")}])", 4) - yield "" - -iterator genHasFieldProc(msg: Message, field: Field): string = - yield &"proc has{field.name}*(message: {msg.names}): bool =" - var check = indent(&"result = contains(message.hasField, {field.number})", 4) - if isRepeated(field) or isMapEntry(field): - check = &"{check} or (len(message.{field.accessor}) > 0)" - yield check - yield "" - -iterator genSetFieldProc(msg: Message, field: Field): string = - yield &"proc set{field.name}*(message: {msg.names}, value: {field.fullType}) =" - yield indent(&"message.{field.accessor} = value", 4) - yield indent(&"incl(message.hasField, {field.number})", 4) - var numbers: seq[int] = @[] - for sibling in oneofSiblings(field): - add(numbers, sibling.number) - if len(numbers) > 0: - yield indent(&"excl(message.hasField, [{join(numbers, \", \")}])", 4) - yield "" - -iterator genAddToFieldProc(msg: Message, field: Field): string = - yield &"proc add{field.name}*(message: {msg.names}, value: {field.nimTypeName}) =" - yield indent(&"add(message.{field.name}, value)", 4) - yield indent(&"incl(message.hasField, {field.number})", 4) - yield "" - -iterator genFieldAccessorProcs(msg: Message, field: Field): string = - yield &"proc {quoteReserved(field.name)}*(message: {msg.names}): {field.fullType} {{.inline.}} =" - yield indent(&"message.{field.accessor}", 4) - yield "" - - yield &"proc `{field.name}=`*(message: {msg.names}, value: {field.fullType}) {{.inline.}} =" - yield indent(&"set{field.name}(message, value)", 4) - yield "" - -iterator genWriteMapKVProc(msg: Message): string = - let - key = mapKeyField(msg) - value = mapValueField(msg) - - yield &"proc write{msg.names}KV(stream: ProtobufStream, key: {key.fullType}, value: {value.fullType}) =" - yield indent(&"{key.writeProc}(stream, key, {key.number})", 4) - yield indent(&"{value.writeProc}(stream, value, {value.number})", 4) - yield "" - -iterator genWriteMessageProc(msg: Message): string = - yield &"proc write{msg.names}*(stream: ProtobufStream, message: {msg.names}) =" - - for field in msg.fields: - if isMapEntry(field): - yield indent(&"for key, value in message.{field.name}:", 4) - yield indent(&"writeTag(stream, {field.number}, {wiretypeStr(field)})", 8) - yield indent(&"writeVarint(stream, {field.sizeOfProc}(key, value))", 8) - yield indent(&"{field.writeProc}(stream, key, value)", 8) - elif isRepeated(field): - if field.packed: - yield indent(&"if has{field.name}(message):", 4) - yield indent(&"writeTag(stream, {field.number}, WireType.LengthDelimited)", 8) - yield indent(&"writeVarint(stream, packedFieldSize(message.{field.name}, {field.fieldTypeStr}))", 8) - yield indent(&"for value in message.{field.name}:", 8) - yield indent(&"{field.writeProc}(stream, value)", 12) - else: - yield indent(&"for value in message.{field.name}:", 4) - yield indent(&"{field.writeProc}(stream, value, {field.number})", 8) - else: - yield indent(&"if has{field.name}(message):", 4) - yield indent(&"{field.writeProc}(stream, message.{field.accessor}, {field.number})", 8) - - yield indent("writeUnknownFields(stream, message.unknownFields)", 4) - - yield "" - -iterator genReadMapKVProc(msg: Message): string = - let - key = mapKeyField(msg) - value = mapValueField(msg) - - yield &"proc read{msg.names}KV(stream: ProtobufStream, tbl: TableRef[{key.fullType}, {value.fullType}]) =" - - yield indent(&"var", 4) - yield indent(&"key: {key.fullType}", 8) - yield indent("gotKey = false", 8) - yield indent(&"value: {value.fullType}", 8) - yield indent("gotValue = false", 8) - yield indent("while not atEnd(stream):", 4) - yield indent("let", 8) - yield indent("tag = readTag(stream)", 12) - yield indent("wireType = wireType(tag)", 12) - yield indent("case fieldNumber(tag)", 8) - yield indent(&"of {key.number}:", 8) - yield indent(&"key = {key.readProc}(stream)", 12) - yield indent("gotKey = true", 12) - yield indent(&"of {value.number}:", 8) - if isMessage(value): - yield indent("let", 12) - yield indent("size = readVarint(stream)", 16) - yield indent("data = safeReadStr(stream, int(size))", 16) - yield indent("pbs = newProtobufStream(newStringStream(data))", 16) - yield indent(&"value = {value.readProc}(pbs)", 12) - else: - yield indent(&"value = {value.readProc}(stream)", 12) - yield indent("gotValue = true", 12) - yield indent("else: skipField(stream, wireType)", 8) - yield indent("if not gotKey:", 4) - yield indent(&"raise newException(Exception, \"missing key\")", 8) - yield indent("if not gotValue:", 4) - yield indent(&"raise newException(Exception, \"missing value\")", 8) - yield indent("tbl[key] = value", 4) - yield "" - -iterator genReadMessageProc(msg: Message): string = - yield &"proc read{msg.names}*(stream: ProtobufStream): {msg.names} =" - yield indent(&"result = new{msg.names}()", 4) - yield indent("while not atEnd(stream):", 4) - yield indent("let", 8) - yield indent("tag = readTag(stream)", 12) - yield indent("wireType = wireType(tag)", 12) - yield indent("case fieldNumber(tag)", 8) - yield indent("of 0:", 8) - yield indent("raise newException(InvalidFieldNumberError, \"Invalid field number: 0\")", 12) - for field in msg.fields: - let - setter = - if isRepeated(field): - &"add{field.name}" - else: - &"set{field.name}" - yield indent(&"of {field.number}:", 8) - if isRepeated(field): - if isMapEntry(field): - yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) - yield indent("let", 12) - yield indent("size = readVarint(stream)", 16) - yield indent("data = safeReadStr(stream, int(size))", 16) - yield indent("pbs = newProtobufStream(newStringStream(data))", 16) - yield indent(&"{field.readProc}(pbs, result.{field.name})", 12) - elif isNumeric(field): - yield indent(&"expectWireType(wireType, {field.wiretypeStr}, WireType.LengthDelimited)", 12) - yield indent("if wireType == WireType.LengthDelimited:", 12) - yield indent("let", 16) - yield indent("size = readVarint(stream)", 20) - yield indent("start = uint64(getPosition(stream))", 20) - yield indent("var consumed = 0'u64", 16) - yield indent("while consumed < size:", 16) - yield indent(&"{setter}(result, {field.readProc}(stream))", 20) - yield indent("consumed = uint64(getPosition(stream)) - start", 20) - yield indent("if consumed != size:", 16) - yield indent("raise newException(Exception, \"packed field size mismatch\")", 20) - yield indent("else:", 12) - yield indent(&"{setter}(result, {field.readProc}(stream))", 16) - elif isMessage(field): - yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) - yield indent(&"let data = readLengthDelimited(stream)", 12) - yield indent(&"{setter}(result, new{field.typeName}(data))", 12) - else: - yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) - yield indent(&"{setter}(result, {field.readProc}(stream))", 12) - else: - yield indent(&"expectWireType(wireType, {field.wiretypeStr})", 12) - if isMessage(field): - yield indent("let data = readLengthDelimited(stream)", 12) - yield indent(&"{setter}(result, new{field.typeName}(data))", 12) - else: - yield indent(&"{setter}(result, {field.readProc}(stream))", 12) - yield indent("else: readUnknownField(stream, tag, result.unknownFields)", 8) - yield "" - -iterator genSizeOfMapKVProc(message: Message): string = - let - key = mapKeyField(message) - value = mapValueField(message) - - yield &"proc sizeOf{message.names}KV(key: {key.fullType}, value: {value.fullType}): uint64 =" - - # Key (cannot be message or other complex field) - yield indent(&"result = result + sizeOfTag({key.number}, {key.wiretypeStr})", 4) - yield indent(&"result = result + {key.sizeOfProc}(key)", 4) - - # Value - yield indent(&"result = result + sizeOfTag({value.number}, {value.wiretypeStr})", 4) - if isMessage(value): - yield indent(&"result = result + sizeOfLengthDelimited({value.sizeOfProc}(value))", 4) - else: - yield indent(&"result = result + {value.sizeOfProc}(value)", 4) - - yield "" - -iterator genSizeOfMessageProc(msg: Message): string = - yield &"proc sizeOf{msg.names}*(message: {msg.names}): uint64 =" - for field in msg.fields: - if isMapEntry(field): - yield indent(&"if has{field.name}(message):", 4) - yield indent(&"var sizeOfKV = 0'u64", 8) - yield indent(&"for key, value in message.{field.name}:", 8) - yield indent(&"sizeOfKV = sizeOfKV + {field.sizeOfProc}(key, value)", 12) - yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) - yield indent(&"result = result + sizeOfLengthDelimited(sizeOfKV)", 8) - elif isRepeated(field): - if isNumeric(field): - yield indent(&"if has{field.name}(message):", 4) - yield indent(&"result = result + sizeOfTag({field.number}, WireType.LengthDelimited)", 8) - yield indent(&"result = result + sizeOfLengthDelimited(packedFieldSize(message.{field.name}, {field.fieldTypeStr}))", 8) - else: - yield indent(&"for value in message.{field.name}:", 4) - yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) - if isMessage(field): - yield indent(&"result = result + sizeOfLengthDelimited({field.sizeOfProc}(value))", 8) - else: - yield indent(&"result = result + {field.sizeOfProc}(value)", 8) - else: - yield indent(&"if has{field.name}(message):", 4) - yield indent(&"result = result + sizeOfTag({field.number}, {field.wiretypeStr})", 8) - if isMessage(field): - yield indent(&"result = result + sizeOfLengthDelimited({field.sizeOfProc}(message.{field.accessor}))", 8) - else: - yield indent(&"result = result + {field.sizeOfProc}(message.{field.accessor})", 8) - - yield indent("for field in message.unknownFields:", 4) - yield indent("result = result + sizeOfUnknownField(field)", 8) - - yield "" - -proc shouldGenerateJsonProcs(typeName: string): bool = - const wktsHavingCustomProcs = [ - "google_protobuf_Any", - "google_protobuf_BoolValue", - "google_protobuf_BytesValue", - "google_protobuf_DoubleValue", - "google_protobuf_Duration", - "google_protobuf_FieldMask", - "google_protobuf_FloatValue", - "google_protobuf_Int32Value", - "google_protobuf_Int64Value", - "google_protobuf_ListValue", - "google_protobuf_NullValue", - "google_protobuf_StringValue", - "google_protobuf_Struct", - "google_protobuf_Timestamp", - "google_protobuf_UInt32Value", - "google_protobuf_UInt64Value", - "google_protobuf_Value", - ] - - return typeName notin wktsHavingCustomProcs - -iterator genMessageToJsonProc(msg: Message): string = - yield &"proc toJson*(message: {msg.names}): JsonNode =" - yield indent("result = newJObject()", 4) - - proc fieldToJson(field: Field, v: string): string = - case field.ftype - of google_protobuf_FieldDescriptorProto_Type.TypeMessage, - google_protobuf_FieldDescriptorProto_Type.TypeInt64, - google_protobuf_FieldDescriptorProto_Type.TypeUInt64, - google_protobuf_FieldDescriptorProto_Type.TypeSFixed64, - google_protobuf_FieldDescriptorProto_Type.TypeFixed64, - google_protobuf_FieldDescriptorProto_Type.TypeDouble, - google_protobuf_FieldDescriptorProto_Type.TypeFloat: - result = &"toJson({v})" - of google_protobuf_FieldDescriptorProto_Type.TypeEnum: - result = &"%(${v})" - else: - result = &"%{v}" - - for field in msg.fields: - yield indent(&"if has{field.name}(message):", 4) - if isMapEntry(field): - yield indent("let obj = newJObject()", 8) - yield indent(&"for key, value in message.{field.name}:", 8) - let f = mapValueField(field) - let j = fieldToJson(f, "value") - yield indent(&"obj[$key] = {j}", 12) - yield indent(&"result[\"{field.jsonName}\"] = obj", 8) - elif isRepeated(field): - yield indent(&"let arr = newJArray()", 8) - yield indent(&"for value in message.{field.name}:", 8) - let v = fieldToJson(field, "value") - yield indent(&"add(arr, {v})", 12) - yield indent(&"result[\"{field.jsonName}\"] = arr", 8) - else: - let v = fieldToJson(field, &"message.{field.name}") - yield indent(&"result[\"{field.jsonName}\"] = {v}", 8) - - yield "" - -iterator genMessageProcForwards(msg: Message): string = - # TODO: can we be more intelligent and only forward declare the minimum set - # of procs? - if not isMapEntry(msg): - yield &"proc new{msg.names}*(): {msg.names}" - yield &"proc new{msg.names}*(data: string): {msg.names}" - yield &"proc write{msg.names}*(stream: ProtobufStream, message: {msg.names})" - yield &"proc read{msg.names}*(stream: ProtobufStream): {msg.names}" - yield &"proc sizeOf{msg.names}*(message: {msg.names}): uint64" - if shouldGenerateJsonProcs($msg.names): - yield &"proc toJson*(message: {msg.names}): JsonNode" - else: - let - key = mapKeyField(msg) - value = mapValueField(msg) - - yield &"proc write{msg.names}KV(stream: ProtobufStream, key: {key.fullType}, value: {value.fullType})" - yield &"proc read{msg.names}KV(stream: ProtobufStream, tbl: TableRef[{key.fullType}, {value.fullType}])" - yield &"proc sizeOf{msg.names}KV(key: {key.fullType}, value: {value.fullType}): uint64" - -iterator genProcs(msg: Message): string = - if isMapEntry(msg): - for line in genSizeOfMapKVProc(msg): yield line - for line in genWriteMapKVProc(msg): yield line - for line in genReadMapKVProc(msg): yield line - else: - for line in genNewMessageProc(msg): yield line - - for field in msg.fields: - for line in genClearFieldProc(msg, field): yield line - for line in genHasFieldProc(msg, field): yield line - for line in genSetFieldProc(msg, field): yield line - - if isRepeated(field) and not isMapEntry(field): - for line in genAddToFieldProc(msg, field): yield line - - for line in genFieldAccessorProcs(msg, field): yield line - - for line in genSizeOfMessageProc(msg): yield line - for line in genWriteMessageProc(msg): yield line - for line in genReadMessageProc(msg): yield line - - if shouldGenerateJsonProcs($msg.names): - for line in genMessageToJsonProc(msg): yield line - - yield &"proc serialize*(message: {msg.names}): string =" - yield indent("let", 4) - yield indent("ss = newStringStream()", 8) - yield indent("pbs = newProtobufStream(ss)", 8) - yield indent(&"write{msg.names}(pbs, message)", 4) - yield indent("result = ss.data", 4) - yield "" - - yield &"proc new{msg.names}*(data: string): {msg.names} =" - yield indent("let", 4) - yield indent("ss = newStringStream(data)", 8) - yield indent("pbs = newProtobufStream(ss)", 8) - yield indent(&"result = read{msg.names}(pbs)", 4) - yield "" - -proc processFile(fdesc: google_protobuf_FileDescriptorProto, - otherFiles: TableRef[string, ProtoFile], - serviceGenerator: ServiceGenerator): ProcessedFile = - var (dir, name, _) = splitFile(fdesc.name) - var pbfilename = (dir / name) & "_pb.nim" - - log(&"processing {fdesc.name}: {pbfilename}") - - new(result) - result.name = pbfilename - result.data = "" - - let parsed = parseFile(fdesc.name, fdesc) - - for dep in fdesc.dependency: - if dep in otherFiles: - add(parsed.dependencies, otherFiles[dep]) - - var hasMaps = false - for message in parsed.messages: - let tmp = fixMapEntry(parsed, message) - if tmp: - hasMaps = true - - addLine(result.data, "# Generated by protoc_gen_nim. Do not edit!") - addLine(result.data, "") - addLine(result.data, "import base64") - addLine(result.data, "import intsets") - addLine(result.data, "import json") - if hasMaps: - addLine(result.data, "import tables") - addLine(result.data, "export tables") - addLine(result.data, "") - addLine(result.data, "import nimpb/nimpb") - addLine(result.data, "import nimpb/json as nimpb_json") - addLine(result.data, "") - - for dep in fdesc.dependency: - var (dir, depname, _) = splitFile(dep) - - if dir == "google/protobuf": - dir = "nimpb/wkt" - - var deppbname = (dir / depname) & "_pb" - addLine(result.data, &"import {deppbname}") - - if hasDependency(fdesc): - addLine(result.data, "") - - addLine(result.data, "type") - - for e in parsed.enums: - for line in genType(e): addLine(result.data, indent(line, 4)) - - for message in parsed.messages: - for line in genType(message): addLine(result.data, indent(line, 4)) - - addLine(result.data, "") - - for message in sortDependencies(parsed.messages): - for line in genMessageProcForwards(message): - addLine(result.data, line) - addLine(result.data, "") - - for message in sortDependencies(parsed.messages): - for line in genProcs(message): - addLine(result.data, line) - addLine(result.data, "") - - if serviceGenerator != nil: - for serviceDesc in fdesc.service: - let service = newService(serviceDesc, parsed) - addLine(result.data, "") - add(result.data, serviceGenerator(service)) - -proc processFileDescriptorSet*(filename: string, - outdir: string, - protos: openArray[string], - serviceGenerator: ServiceGenerator) = - let s = newProtobufStream(newFileStream(filename, fmRead)) - - let fileSet = readgoogle_protobuf_FileDescriptorSet(s) - - var otherFiles = newTable[string, ProtoFile]() - - for file in fileSet.file: - add(otherFiles, file.name, parseFile(file.name, file)) - - # Protoc does not provide full paths for files in FileDescriptorSet. So it - # can be that fileSet.file.name might match any file in protos. So we will - # try to match the bare name and the named joined with the path of the first - # file. - let basePath = parentDir(protos[0]) - - for file in fileSet.file: - if (file.name in protos) or ((basePath / file.name) in protos): - let processedFile = processFile(file, otherFiles, serviceGenerator) - - let fullPath = outdir / processedFile.name - - createDir(parentDir(fullPath)) - - writeFile(fullPath, processedFile.data) -- cgit v1.2.3 From c67a380be0dea5961d99fb8573f891980236ce2b Mon Sep 17 00:00:00 2001 From: Oskari Timperi Date: Wed, 11 Apr 2018 19:47:24 +0300 Subject: Fix imports --- nimpb/compiler/descriptor_pb.nim | 2 +- nimpb/compiler/generator.nim | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nimpb/compiler/descriptor_pb.nim b/nimpb/compiler/descriptor_pb.nim index b6ed832..968ff57 100644 --- a/nimpb/compiler/descriptor_pb.nim +++ b/nimpb/compiler/descriptor_pb.nim @@ -2,7 +2,7 @@ import intsets -import nimpb/nimpb +import ../nimpb type google_protobuf_FieldDescriptorProto_Type* {.pure.} = enum diff --git a/nimpb/compiler/generator.nim b/nimpb/compiler/generator.nim index abdad07..ea3531a 100644 --- a/nimpb/compiler/generator.nim +++ b/nimpb/compiler/generator.nim @@ -9,7 +9,7 @@ import tables import descriptor_pb -import nimpb/nimpb +import ../nimpb type Names = distinct seq[string] -- cgit v1.2.3 From 466d8d1d2e878330ff36c2aacd640092e7fba738 Mon Sep 17 00:00:00 2001 From: Oskari Timperi Date: Wed, 11 Apr 2018 21:28:54 +0300 Subject: Move binary part of compiler to nimpb_build So that the binary nimble builds/installs for us is not named "compiler"... :-) --- nimpb.nimble | 8 +++++- nimpb/compiler/compiler.nim | 56 ++++++------------------------------------ nimpb/compiler/nimpb_build.nim | 44 +++++++++++++++++++++++++++++++++ 3 files changed, 58 insertions(+), 50 deletions(-) create mode 100644 nimpb/compiler/nimpb_build.nim diff --git a/nimpb.nimble b/nimpb.nimble index 28247db..067245e 100644 --- a/nimpb.nimble +++ b/nimpb.nimble @@ -5,6 +5,12 @@ license = "MIT" skipDirs = @["examples", "tests"] -bin = @["nimpb/compiler/compiler"] +bin = @["nimpb/compiler/nimpb_build"] requires "nim >= 0.18.0" + +# Hard dependency for now. In the future we could make nimpb_protoc download +# stuff on-demand which would make the dependency a bit lighter. Especially +# if a user already has the protoc compiler somewhere, in which case +# nimpb_protoc might be unnecessary. +requires "nimpb_protoc" diff --git a/nimpb/compiler/compiler.nim b/nimpb/compiler/compiler.nim index fe0a5e4..c44ade6 100644 --- a/nimpb/compiler/compiler.nim +++ b/nimpb/compiler/compiler.nim @@ -8,11 +8,11 @@ from generator import processFileDescriptorSet, ServiceGenerator, Service, Servi export Service, ServiceMethod const - nimpbBuildInfo = gorgeEx("nimble dump nimpb_protoc") - isNimpbBuildAvailable = nimpbBuildInfo[1] == 0 + nimpbProtocInfo = gorgeEx("nimble dump nimpb_protoc") + isNimpbProtocAvailable = nimpbProtocInfo[1] == 0 -when isNimpbBuildAvailable: - import nimpb_protoc/nimpb_protoc +when isNimpbProtocAvailable: + import nimpb_protoc proc findCompiler*(): string = result = "" @@ -25,7 +25,7 @@ proc findCompiler*(): string = if result == "": result = findExe("protoc") - when isNimpbBuildAvailable: + when isNimpbProtocAvailable: if result == "": result = nimpb_protoc.getCompilerPath() @@ -48,9 +48,6 @@ Now you have three options to make this work: raise newException(Exception, msg) -proc builtinIncludeDir(compilerPath: string): string = - parentDir(compilerPath) / "include" - proc myTempDir(): string = result = getTempDir() / "nimpb_protoc_tmp" @@ -71,7 +68,8 @@ proc compileProtos*(protos: openArray[string], for incdir in includes: add(args, &"-I{incdir}") - add(args, &"-I{builtinIncludeDir(command)}") + when isNimpbProtocAvailable: + add(args, &"-I{getProtoIncludeDir()}") for proto in protos: add(args, proto) @@ -86,43 +84,3 @@ proc compileProtos*(protos: openArray[string], raise newException(Exception, outp) processFileDescriptorSet(outputFilename, outdir, protos, serviceGenerator) - - -when isMainModule: - proc usage() {.noreturn.} = - echo(&""" - {getAppFilename()} --out=OUTDIR [-IPATH [-IPATH]...] PROTOFILE... - - --out The output directory for the generated files - -I Add a path to the set of include paths - """) - quit(QuitFailure) - - var includes: seq[string] = @[] - var protos: seq[string] = @[] - var outdir: string - - if paramCount() == 0: - usage() - - for idx in 1..paramCount(): - let param = paramStr(idx) - - if param.startsWith("-I"): - add(includes, param[2..^1]) - elif param.startsWith("--out="): - outdir = param[6..^1] - elif param == "--help": - usage() - else: - add(protos, param) - - if outdir == nil: - echo("error: --out is required") - quit(QuitFailure) - - if len(protos) == 0: - echo("error: no input files") - quit(QuitFailure) - - compileProtos(protos, includes, outdir) diff --git a/nimpb/compiler/nimpb_build.nim b/nimpb/compiler/nimpb_build.nim new file mode 100644 index 0000000..1abb3f3 --- /dev/null +++ b/nimpb/compiler/nimpb_build.nim @@ -0,0 +1,44 @@ +import os +import osproc +import strformat +import strutils + +import compiler + +proc usage() {.noreturn.} = + echo(&""" +{getAppFilename()} --out=OUTDIR [-IPATH [-IPATH]...] PROTOFILE... + + --out The output directory for the generated files + -I Add a path to the set of include paths +""") + quit(QuitFailure) + +var includes: seq[string] = @[] +var protos: seq[string] = @[] +var outdir: string + +if paramCount() == 0: + usage() + +for idx in 1..paramCount(): + let param = paramStr(idx) + + if param.startsWith("-I"): + add(includes, param[2..^1]) + elif param.startsWith("--out="): + outdir = param[6..^1] + elif param == "--help": + usage() + else: + add(protos, param) + +if outdir == nil: + echo("error: --out is required") + quit(QuitFailure) + +if len(protos) == 0: + echo("error: no input files") + quit(QuitFailure) + +compileProtos(protos, includes, outdir) -- cgit v1.2.3