@aptpod/iscp-ts
Version:
iSCP 2.0 client library for TypeScript
862 lines • 45.7 kB
JavaScript
import { WireType } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { UpstreamChunkResultExtensionFields } from "./extensions/upstream";
import { UpstreamMetadataAckExtensionFields } from "./extensions/upstream";
import { UpstreamMetadataExtensionFields } from "./extensions/upstream";
import { BaseTime } from "./metadata";
import { UpstreamChunkAckExtensionFields } from "./extensions/upstream";
import { UpstreamChunkExtensionFields } from "./extensions/upstream";
import { StreamChunk } from "./common";
import { UpstreamCloseResponseExtensionFields } from "./extensions/upstream";
import { UpstreamCloseRequestExtensionFields } from "./extensions/upstream";
import { UpstreamResumeResponseExtensionFields } from "./extensions/upstream";
import { UpstreamResumeRequestExtensionFields } from "./extensions/upstream";
import { UpstreamOpenResponseExtensionFields } from "./extensions/upstream";
import { ResultCode } from "./result_code";
import { UpstreamOpenRequestExtensionFields } from "./extensions/upstream";
import { QoS } from "./common";
import { DataID } from "./common";
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamOpenRequest$Type extends MessageType {
constructor() {
super("iscp2.UpstreamOpenRequest", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "session_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 3, name: "ack_interval", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "expiry_interval", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 6, name: "data_ids", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DataID },
{ no: 7, name: "qos", kind: "enum", T: () => ["iscp2.QoS", QoS] },
{ no: 8, name: "extension_fields", kind: "message", T: () => UpstreamOpenRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, sessionId: "", ackInterval: 0, expiryInterval: 0, dataIds: [], qos: 0 };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* string session_id */ 2:
message.sessionId = reader.string();
break;
case /* uint32 ack_interval */ 3:
message.ackInterval = reader.uint32();
break;
case /* uint32 expiry_interval */ 5:
message.expiryInterval = reader.uint32();
break;
case /* repeated iscp2.DataID data_ids */ 6:
message.dataIds.push(DataID.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* iscp2.QoS qos */ 7:
message.qos = reader.int32();
break;
case /* iscp2.UpstreamOpenRequestExtensionFields extension_fields */ 8:
message.extensionFields = UpstreamOpenRequestExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* string session_id = 2; */
if (message.sessionId !== "")
writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
/* uint32 ack_interval = 3; */
if (message.ackInterval !== 0)
writer.tag(3, WireType.Varint).uint32(message.ackInterval);
/* uint32 expiry_interval = 5; */
if (message.expiryInterval !== 0)
writer.tag(5, WireType.Varint).uint32(message.expiryInterval);
/* repeated iscp2.DataID data_ids = 6; */
for (let i = 0; i < message.dataIds.length; i++)
DataID.internalBinaryWrite(message.dataIds[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
/* iscp2.QoS qos = 7; */
if (message.qos !== 0)
writer.tag(7, WireType.Varint).int32(message.qos);
/* iscp2.UpstreamOpenRequestExtensionFields extension_fields = 8; */
if (message.extensionFields)
UpstreamOpenRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamOpenRequest
*/
export const UpstreamOpenRequest = new UpstreamOpenRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamOpenResponse$Type extends MessageType {
constructor() {
super("iscp2.UpstreamOpenResponse", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "assigned_stream_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
{ no: 3, name: "assigned_stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 4, name: "data_id_aliases", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "message", T: () => DataID } },
{ no: 5, name: "server_time", kind: "scalar", T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
{ no: 6, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 7, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 8, name: "extension_fields", kind: "message", T: () => UpstreamOpenResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, assignedStreamId: new Uint8Array(0), assignedStreamIdAlias: 0, dataIdAliases: {}, serverTime: 0n, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* bytes assigned_stream_id */ 2:
message.assignedStreamId = reader.bytes();
break;
case /* uint32 assigned_stream_id_alias */ 3:
message.assignedStreamIdAlias = reader.uint32();
break;
case /* map<uint32, iscp2.DataID> data_id_aliases */ 4:
this.binaryReadMap4(message.dataIdAliases, reader, options);
break;
case /* sint64 server_time */ 5:
message.serverTime = reader.sint64().toBigInt();
break;
case /* iscp2.ResultCode result_code */ 6:
message.resultCode = reader.int32();
break;
case /* string result_string */ 7:
message.resultString = reader.string();
break;
case /* iscp2.UpstreamOpenResponseExtensionFields extension_fields */ 8:
message.extensionFields = UpstreamOpenResponseExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
binaryReadMap4(map, reader, options) {
let len = reader.uint32(), end = reader.pos + len, key, val;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case 1:
key = reader.uint32();
break;
case 2:
val = DataID.internalBinaryRead(reader, reader.uint32(), options);
break;
default: throw new globalThis.Error("unknown map entry field for field iscp2.UpstreamOpenResponse.data_id_aliases");
}
}
map[key ?? 0] = val ?? DataID.create();
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* bytes assigned_stream_id = 2; */
if (message.assignedStreamId.length)
writer.tag(2, WireType.LengthDelimited).bytes(message.assignedStreamId);
/* uint32 assigned_stream_id_alias = 3; */
if (message.assignedStreamIdAlias !== 0)
writer.tag(3, WireType.Varint).uint32(message.assignedStreamIdAlias);
/* map<uint32, iscp2.DataID> data_id_aliases = 4; */
for (let k of Object.keys(message.dataIdAliases)) {
writer.tag(4, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k));
writer.tag(2, WireType.LengthDelimited).fork();
DataID.internalBinaryWrite(message.dataIdAliases[k], writer, options);
writer.join().join();
}
/* sint64 server_time = 5; */
if (message.serverTime !== 0n)
writer.tag(5, WireType.Varint).sint64(message.serverTime);
/* iscp2.ResultCode result_code = 6; */
if (message.resultCode !== 0)
writer.tag(6, WireType.Varint).int32(message.resultCode);
/* string result_string = 7; */
if (message.resultString !== "")
writer.tag(7, WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamOpenResponseExtensionFields extension_fields = 8; */
if (message.extensionFields)
UpstreamOpenResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamOpenResponse
*/
export const UpstreamOpenResponse = new UpstreamOpenResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamResumeRequest$Type extends MessageType {
constructor() {
super("iscp2.UpstreamResumeRequest", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "stream_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
{ no: 3, name: "extension_fields", kind: "message", T: () => UpstreamResumeRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamId: new Uint8Array(0) };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* bytes stream_id */ 2:
message.streamId = reader.bytes();
break;
case /* iscp2.UpstreamResumeRequestExtensionFields extension_fields */ 3:
message.extensionFields = UpstreamResumeRequestExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* bytes stream_id = 2; */
if (message.streamId.length)
writer.tag(2, WireType.LengthDelimited).bytes(message.streamId);
/* iscp2.UpstreamResumeRequestExtensionFields extension_fields = 3; */
if (message.extensionFields)
UpstreamResumeRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamResumeRequest
*/
export const UpstreamResumeRequest = new UpstreamResumeRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamResumeResponse$Type extends MessageType {
constructor() {
super("iscp2.UpstreamResumeResponse", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "assigned_stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 3, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 4, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 5, name: "extension_fields", kind: "message", T: () => UpstreamResumeResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, assignedStreamIdAlias: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* uint32 assigned_stream_id_alias */ 2:
message.assignedStreamIdAlias = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 3:
message.resultCode = reader.int32();
break;
case /* string result_string */ 4:
message.resultString = reader.string();
break;
case /* iscp2.UpstreamResumeResponseExtensionFields extension_fields */ 5:
message.extensionFields = UpstreamResumeResponseExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* uint32 assigned_stream_id_alias = 2; */
if (message.assignedStreamIdAlias !== 0)
writer.tag(2, WireType.Varint).uint32(message.assignedStreamIdAlias);
/* iscp2.ResultCode result_code = 3; */
if (message.resultCode !== 0)
writer.tag(3, WireType.Varint).int32(message.resultCode);
/* string result_string = 4; */
if (message.resultString !== "")
writer.tag(4, WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamResumeResponseExtensionFields extension_fields = 5; */
if (message.extensionFields)
UpstreamResumeResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamResumeResponse
*/
export const UpstreamResumeResponse = new UpstreamResumeResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamCloseRequest$Type extends MessageType {
constructor() {
super("iscp2.UpstreamCloseRequest", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "stream_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
{ no: 3, name: "total_data_points", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
{ no: 4, name: "final_sequence_number", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 5, name: "extension_fields", kind: "message", T: () => UpstreamCloseRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamId: new Uint8Array(0), totalDataPoints: 0n, finalSequenceNumber: 0 };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* bytes stream_id */ 2:
message.streamId = reader.bytes();
break;
case /* uint64 total_data_points */ 3:
message.totalDataPoints = reader.uint64().toBigInt();
break;
case /* uint32 final_sequence_number */ 4:
message.finalSequenceNumber = reader.uint32();
break;
case /* iscp2.UpstreamCloseRequestExtensionFields extension_fields */ 5:
message.extensionFields = UpstreamCloseRequestExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* bytes stream_id = 2; */
if (message.streamId.length)
writer.tag(2, WireType.LengthDelimited).bytes(message.streamId);
/* uint64 total_data_points = 3; */
if (message.totalDataPoints !== 0n)
writer.tag(3, WireType.Varint).uint64(message.totalDataPoints);
/* uint32 final_sequence_number = 4; */
if (message.finalSequenceNumber !== 0)
writer.tag(4, WireType.Varint).uint32(message.finalSequenceNumber);
/* iscp2.UpstreamCloseRequestExtensionFields extension_fields = 5; */
if (message.extensionFields)
UpstreamCloseRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamCloseRequest
*/
export const UpstreamCloseRequest = new UpstreamCloseRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamCloseResponse$Type extends MessageType {
constructor() {
super("iscp2.UpstreamCloseResponse", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => UpstreamCloseResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 2:
message.resultCode = reader.int32();
break;
case /* string result_string */ 3:
message.resultString = reader.string();
break;
case /* iscp2.UpstreamCloseResponseExtensionFields extension_fields */ 4:
message.extensionFields = UpstreamCloseResponseExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamCloseResponseExtensionFields extension_fields = 4; */
if (message.extensionFields)
UpstreamCloseResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamCloseResponse
*/
export const UpstreamCloseResponse = new UpstreamCloseResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamChunk$Type extends MessageType {
constructor() {
super("iscp2.UpstreamChunk", [
{ no: 1, name: "stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "stream_chunk", kind: "message", T: () => StreamChunk },
{ no: 3, name: "data_ids", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DataID },
{ no: 4, name: "extension_fields", kind: "message", T: () => UpstreamChunkExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, dataIds: [] };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 stream_id_alias */ 1:
message.streamIdAlias = reader.uint32();
break;
case /* iscp2.StreamChunk stream_chunk */ 2:
message.streamChunk = StreamChunk.internalBinaryRead(reader, reader.uint32(), options, message.streamChunk);
break;
case /* repeated iscp2.DataID data_ids */ 3:
message.dataIds.push(DataID.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* iscp2.UpstreamChunkExtensionFields extension_fields */ 4:
message.extensionFields = UpstreamChunkExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 stream_id_alias = 1; */
if (message.streamIdAlias !== 0)
writer.tag(1, WireType.Varint).uint32(message.streamIdAlias);
/* iscp2.StreamChunk stream_chunk = 2; */
if (message.streamChunk)
StreamChunk.internalBinaryWrite(message.streamChunk, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* repeated iscp2.DataID data_ids = 3; */
for (let i = 0; i < message.dataIds.length; i++)
DataID.internalBinaryWrite(message.dataIds[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamChunkExtensionFields extension_fields = 4; */
if (message.extensionFields)
UpstreamChunkExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamChunk
*/
export const UpstreamChunk = new UpstreamChunk$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamChunkAck$Type extends MessageType {
constructor() {
super("iscp2.UpstreamChunkAck", [
{ no: 1, name: "stream_id_alias", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "results", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => UpstreamChunkResult },
{ no: 3, name: "data_id_aliases", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "message", T: () => DataID } },
{ no: 4, name: "extension_fields", kind: "message", T: () => UpstreamChunkAckExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, results: [], dataIdAliases: {} };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 stream_id_alias */ 1:
message.streamIdAlias = reader.uint32();
break;
case /* repeated iscp2.UpstreamChunkResult results */ 2:
message.results.push(UpstreamChunkResult.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* map<uint32, iscp2.DataID> data_id_aliases */ 3:
this.binaryReadMap3(message.dataIdAliases, reader, options);
break;
case /* iscp2.UpstreamChunkAckExtensionFields extension_fields */ 4:
message.extensionFields = UpstreamChunkAckExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
binaryReadMap3(map, reader, options) {
let len = reader.uint32(), end = reader.pos + len, key, val;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case 1:
key = reader.uint32();
break;
case 2:
val = DataID.internalBinaryRead(reader, reader.uint32(), options);
break;
default: throw new globalThis.Error("unknown map entry field for field iscp2.UpstreamChunkAck.data_id_aliases");
}
}
map[key ?? 0] = val ?? DataID.create();
}
internalBinaryWrite(message, writer, options) {
/* uint32 stream_id_alias = 1; */
if (message.streamIdAlias !== 0)
writer.tag(1, WireType.Varint).uint32(message.streamIdAlias);
/* repeated iscp2.UpstreamChunkResult results = 2; */
for (let i = 0; i < message.results.length; i++)
UpstreamChunkResult.internalBinaryWrite(message.results[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* map<uint32, iscp2.DataID> data_id_aliases = 3; */
for (let k of Object.keys(message.dataIdAliases)) {
writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.Varint).uint32(parseInt(k));
writer.tag(2, WireType.LengthDelimited).fork();
DataID.internalBinaryWrite(message.dataIdAliases[k], writer, options);
writer.join().join();
}
/* iscp2.UpstreamChunkAckExtensionFields extension_fields = 4; */
if (message.extensionFields)
UpstreamChunkAckExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamChunkAck
*/
export const UpstreamChunkAck = new UpstreamChunkAck$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamMetadata$Type extends MessageType {
constructor() {
super("iscp2.UpstreamMetadata", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "base_time", kind: "message", oneof: "metadata", T: () => BaseTime },
{ no: 4, name: "extension_fields", kind: "message", T: () => UpstreamMetadataExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, metadata: { oneofKind: undefined } };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* iscp2.BaseTime base_time */ 2:
message.metadata = {
oneofKind: "baseTime",
baseTime: BaseTime.internalBinaryRead(reader, reader.uint32(), options, message.metadata.baseTime)
};
break;
case /* iscp2.UpstreamMetadataExtensionFields extension_fields */ 4:
message.extensionFields = UpstreamMetadataExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* iscp2.BaseTime base_time = 2; */
if (message.metadata.oneofKind === "baseTime")
BaseTime.internalBinaryWrite(message.metadata.baseTime, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamMetadataExtensionFields extension_fields = 4; */
if (message.extensionFields)
UpstreamMetadataExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamMetadata
*/
export const UpstreamMetadata = new UpstreamMetadata$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamMetadataAck$Type extends MessageType {
constructor() {
super("iscp2.UpstreamMetadataAck", [
{ no: 1, name: "request_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => UpstreamMetadataAckExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 request_id */ 1:
message.requestId = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 2:
message.resultCode = reader.int32();
break;
case /* string result_string */ 3:
message.resultString = reader.string();
break;
case /* iscp2.UpstreamMetadataAckExtensionFields extension_fields */ 4:
message.extensionFields = UpstreamMetadataAckExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, WireType.Varint).uint32(message.requestId);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamMetadataAckExtensionFields extension_fields = 4; */
if (message.extensionFields)
UpstreamMetadataAckExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamMetadataAck
*/
export const UpstreamMetadataAck = new UpstreamMetadataAck$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamChunkResult$Type extends MessageType {
constructor() {
super("iscp2.UpstreamChunkResult", [
{ no: 1, name: "sequence_number", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
{ no: 2, name: "result_code", kind: "enum", T: () => ["iscp2.ResultCode", ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => UpstreamChunkResultExtensionFields }
]);
}
create(value) {
const message = { sequenceNumber: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
reflectionMergePartial(this, message, value);
return message;
}
internalBinaryRead(reader, length, options, target) {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* uint32 sequence_number */ 1:
message.sequenceNumber = reader.uint32();
break;
case /* iscp2.ResultCode result_code */ 2:
message.resultCode = reader.int32();
break;
case /* string result_string */ 3:
message.resultString = reader.string();
break;
case /* iscp2.UpstreamChunkResultExtensionFields extension_fields */ 4:
message.extensionFields = UpstreamChunkResultExtensionFields.internalBinaryRead(reader, reader.uint32(), options, message.extensionFields);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message, writer, options) {
/* uint32 sequence_number = 1; */
if (message.sequenceNumber !== 0)
writer.tag(1, WireType.Varint).uint32(message.sequenceNumber);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamChunkResultExtensionFields extension_fields = 4; */
if (message.extensionFields)
UpstreamChunkResultExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamChunkResult
*/
export const UpstreamChunkResult = new UpstreamChunkResult$Type();
//# sourceMappingURL=upstream.js.map