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