@aptpod/iscp-ts
Version:
iSCP 2.0 client library for TypeScript
865 lines • 47.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UpstreamChunkResult = exports.UpstreamMetadataAck = exports.UpstreamMetadata = exports.UpstreamChunkAck = exports.UpstreamChunk = exports.UpstreamCloseResponse = exports.UpstreamCloseRequest = exports.UpstreamResumeResponse = exports.UpstreamResumeRequest = exports.UpstreamOpenResponse = exports.UpstreamOpenRequest = void 0;
const runtime_1 = require("@protobuf-ts/runtime");
const runtime_2 = require("@protobuf-ts/runtime");
const runtime_3 = require("@protobuf-ts/runtime");
const runtime_4 = require("@protobuf-ts/runtime");
const runtime_5 = require("@protobuf-ts/runtime");
const upstream_1 = require("./extensions/upstream");
const upstream_2 = require("./extensions/upstream");
const upstream_3 = require("./extensions/upstream");
const metadata_1 = require("./metadata");
const upstream_4 = require("./extensions/upstream");
const upstream_5 = require("./extensions/upstream");
const common_1 = require("./common");
const upstream_6 = require("./extensions/upstream");
const upstream_7 = require("./extensions/upstream");
const upstream_8 = require("./extensions/upstream");
const upstream_9 = require("./extensions/upstream");
const upstream_10 = require("./extensions/upstream");
const result_code_1 = require("./result_code");
const upstream_11 = require("./extensions/upstream");
const common_2 = require("./common");
const common_3 = require("./common");
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamOpenRequest$Type extends runtime_5.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: () => common_3.DataID },
{ no: 7, name: "qos", kind: "enum", T: () => ["iscp2.QoS", common_2.QoS] },
{ no: 8, name: "extension_fields", kind: "message", T: () => upstream_11.UpstreamOpenRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, sessionId: "", ackInterval: 0, expiryInterval: 0, dataIds: [], qos: 0 };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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(common_3.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 = upstream_11.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* string session_id = 2; */
if (message.sessionId !== "")
writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.sessionId);
/* uint32 ack_interval = 3; */
if (message.ackInterval !== 0)
writer.tag(3, runtime_1.WireType.Varint).uint32(message.ackInterval);
/* uint32 expiry_interval = 5; */
if (message.expiryInterval !== 0)
writer.tag(5, runtime_1.WireType.Varint).uint32(message.expiryInterval);
/* repeated iscp2.DataID data_ids = 6; */
for (let i = 0; i < message.dataIds.length; i++)
common_3.DataID.internalBinaryWrite(message.dataIds[i], writer.tag(6, runtime_1.WireType.LengthDelimited).fork(), options).join();
/* iscp2.QoS qos = 7; */
if (message.qos !== 0)
writer.tag(7, runtime_1.WireType.Varint).int32(message.qos);
/* iscp2.UpstreamOpenRequestExtensionFields extension_fields = 8; */
if (message.extensionFields)
upstream_11.UpstreamOpenRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(8, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamOpenRequest
*/
exports.UpstreamOpenRequest = new UpstreamOpenRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamOpenResponse$Type extends runtime_5.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: () => common_3.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", result_code_1.ResultCode] },
{ no: 7, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 8, name: "extension_fields", kind: "message", T: () => upstream_10.UpstreamOpenResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, assignedStreamId: new Uint8Array(0), assignedStreamIdAlias: 0, dataIdAliases: {}, serverTime: 0n, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_10.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 ? runtime_2.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 = common_3.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 ?? common_3.DataID.create();
}
internalBinaryWrite(message, writer, options) {
/* uint32 request_id = 1; */
if (message.requestId !== 0)
writer.tag(1, runtime_1.WireType.Varint).uint32(message.requestId);
/* bytes assigned_stream_id = 2; */
if (message.assignedStreamId.length)
writer.tag(2, runtime_1.WireType.LengthDelimited).bytes(message.assignedStreamId);
/* uint32 assigned_stream_id_alias = 3; */
if (message.assignedStreamIdAlias !== 0)
writer.tag(3, runtime_1.WireType.Varint).uint32(message.assignedStreamIdAlias);
/* map<uint32, iscp2.DataID> data_id_aliases = 4; */
for (let k of Object.keys(message.dataIdAliases)) {
writer.tag(4, runtime_1.WireType.LengthDelimited).fork().tag(1, runtime_1.WireType.Varint).uint32(parseInt(k));
writer.tag(2, runtime_1.WireType.LengthDelimited).fork();
common_3.DataID.internalBinaryWrite(message.dataIdAliases[k], writer, options);
writer.join().join();
}
/* sint64 server_time = 5; */
if (message.serverTime !== 0n)
writer.tag(5, runtime_1.WireType.Varint).sint64(message.serverTime);
/* iscp2.ResultCode result_code = 6; */
if (message.resultCode !== 0)
writer.tag(6, runtime_1.WireType.Varint).int32(message.resultCode);
/* string result_string = 7; */
if (message.resultString !== "")
writer.tag(7, runtime_1.WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamOpenResponseExtensionFields extension_fields = 8; */
if (message.extensionFields)
upstream_10.UpstreamOpenResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(8, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamOpenResponse
*/
exports.UpstreamOpenResponse = new UpstreamOpenResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamResumeRequest$Type extends runtime_5.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: () => upstream_9.UpstreamResumeRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamId: new Uint8Array(0) };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_9.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* bytes stream_id = 2; */
if (message.streamId.length)
writer.tag(2, runtime_1.WireType.LengthDelimited).bytes(message.streamId);
/* iscp2.UpstreamResumeRequestExtensionFields extension_fields = 3; */
if (message.extensionFields)
upstream_9.UpstreamResumeRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(3, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamResumeRequest
*/
exports.UpstreamResumeRequest = new UpstreamResumeRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamResumeResponse$Type extends runtime_5.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", result_code_1.ResultCode] },
{ no: 4, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 5, name: "extension_fields", kind: "message", T: () => upstream_8.UpstreamResumeResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, assignedStreamIdAlias: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_8.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* uint32 assigned_stream_id_alias = 2; */
if (message.assignedStreamIdAlias !== 0)
writer.tag(2, runtime_1.WireType.Varint).uint32(message.assignedStreamIdAlias);
/* iscp2.ResultCode result_code = 3; */
if (message.resultCode !== 0)
writer.tag(3, runtime_1.WireType.Varint).int32(message.resultCode);
/* string result_string = 4; */
if (message.resultString !== "")
writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamResumeResponseExtensionFields extension_fields = 5; */
if (message.extensionFields)
upstream_8.UpstreamResumeResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(5, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamResumeResponse
*/
exports.UpstreamResumeResponse = new UpstreamResumeResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamCloseRequest$Type extends runtime_5.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: () => upstream_7.UpstreamCloseRequestExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, streamId: new Uint8Array(0), totalDataPoints: 0n, finalSequenceNumber: 0 };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_7.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* bytes stream_id = 2; */
if (message.streamId.length)
writer.tag(2, runtime_1.WireType.LengthDelimited).bytes(message.streamId);
/* uint64 total_data_points = 3; */
if (message.totalDataPoints !== 0n)
writer.tag(3, runtime_1.WireType.Varint).uint64(message.totalDataPoints);
/* uint32 final_sequence_number = 4; */
if (message.finalSequenceNumber !== 0)
writer.tag(4, runtime_1.WireType.Varint).uint32(message.finalSequenceNumber);
/* iscp2.UpstreamCloseRequestExtensionFields extension_fields = 5; */
if (message.extensionFields)
upstream_7.UpstreamCloseRequestExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(5, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamCloseRequest
*/
exports.UpstreamCloseRequest = new UpstreamCloseRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamCloseResponse$Type extends runtime_5.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", result_code_1.ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => upstream_6.UpstreamCloseResponseExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_6.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, runtime_1.WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamCloseResponseExtensionFields extension_fields = 4; */
if (message.extensionFields)
upstream_6.UpstreamCloseResponseExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamCloseResponse
*/
exports.UpstreamCloseResponse = new UpstreamCloseResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamChunk$Type extends runtime_5.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: () => common_1.StreamChunk },
{ no: 3, name: "data_ids", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => common_3.DataID },
{ no: 4, name: "extension_fields", kind: "message", T: () => upstream_5.UpstreamChunkExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, dataIds: [] };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = common_1.StreamChunk.internalBinaryRead(reader, reader.uint32(), options, message.streamChunk);
break;
case /* repeated iscp2.DataID data_ids */ 3:
message.dataIds.push(common_3.DataID.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* iscp2.UpstreamChunkExtensionFields extension_fields */ 4:
message.extensionFields = upstream_5.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.streamIdAlias);
/* iscp2.StreamChunk stream_chunk = 2; */
if (message.streamChunk)
common_1.StreamChunk.internalBinaryWrite(message.streamChunk, writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join();
/* repeated iscp2.DataID data_ids = 3; */
for (let i = 0; i < message.dataIds.length; i++)
common_3.DataID.internalBinaryWrite(message.dataIds[i], writer.tag(3, runtime_1.WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamChunkExtensionFields extension_fields = 4; */
if (message.extensionFields)
upstream_5.UpstreamChunkExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamChunk
*/
exports.UpstreamChunk = new UpstreamChunk$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamChunkAck$Type extends runtime_5.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: () => exports.UpstreamChunkResult },
{ no: 3, name: "data_id_aliases", kind: "map", K: 13 /*ScalarType.UINT32*/, V: { kind: "message", T: () => common_3.DataID } },
{ no: 4, name: "extension_fields", kind: "message", T: () => upstream_4.UpstreamChunkAckExtensionFields }
]);
}
create(value) {
const message = { streamIdAlias: 0, results: [], dataIdAliases: {} };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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(exports.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 = upstream_4.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 ? runtime_2.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 = common_3.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 ?? common_3.DataID.create();
}
internalBinaryWrite(message, writer, options) {
/* uint32 stream_id_alias = 1; */
if (message.streamIdAlias !== 0)
writer.tag(1, runtime_1.WireType.Varint).uint32(message.streamIdAlias);
/* repeated iscp2.UpstreamChunkResult results = 2; */
for (let i = 0; i < message.results.length; i++)
exports.UpstreamChunkResult.internalBinaryWrite(message.results[i], writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join();
/* map<uint32, iscp2.DataID> data_id_aliases = 3; */
for (let k of Object.keys(message.dataIdAliases)) {
writer.tag(3, runtime_1.WireType.LengthDelimited).fork().tag(1, runtime_1.WireType.Varint).uint32(parseInt(k));
writer.tag(2, runtime_1.WireType.LengthDelimited).fork();
common_3.DataID.internalBinaryWrite(message.dataIdAliases[k], writer, options);
writer.join().join();
}
/* iscp2.UpstreamChunkAckExtensionFields extension_fields = 4; */
if (message.extensionFields)
upstream_4.UpstreamChunkAckExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamChunkAck
*/
exports.UpstreamChunkAck = new UpstreamChunkAck$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamMetadata$Type extends runtime_5.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: () => metadata_1.BaseTime },
{ no: 4, name: "extension_fields", kind: "message", T: () => upstream_3.UpstreamMetadataExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, metadata: { oneofKind: undefined } };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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: metadata_1.BaseTime.internalBinaryRead(reader, reader.uint32(), options, message.metadata.baseTime)
};
break;
case /* iscp2.UpstreamMetadataExtensionFields extension_fields */ 4:
message.extensionFields = upstream_3.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* iscp2.BaseTime base_time = 2; */
if (message.metadata.oneofKind === "baseTime")
metadata_1.BaseTime.internalBinaryWrite(message.metadata.baseTime, writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join();
/* iscp2.UpstreamMetadataExtensionFields extension_fields = 4; */
if (message.extensionFields)
upstream_3.UpstreamMetadataExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamMetadata
*/
exports.UpstreamMetadata = new UpstreamMetadata$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamMetadataAck$Type extends runtime_5.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", result_code_1.ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => upstream_2.UpstreamMetadataAckExtensionFields }
]);
}
create(value) {
const message = { requestId: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_2.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.requestId);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, runtime_1.WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamMetadataAckExtensionFields extension_fields = 4; */
if (message.extensionFields)
upstream_2.UpstreamMetadataAckExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamMetadataAck
*/
exports.UpstreamMetadataAck = new UpstreamMetadataAck$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UpstreamChunkResult$Type extends runtime_5.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", result_code_1.ResultCode] },
{ no: 3, name: "result_string", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 4, name: "extension_fields", kind: "message", T: () => upstream_1.UpstreamChunkResultExtensionFields }
]);
}
create(value) {
const message = { sequenceNumber: 0, resultCode: 0, resultString: "" };
globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this });
if (value !== undefined)
(0, runtime_3.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 = upstream_1.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 ? runtime_2.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, runtime_1.WireType.Varint).uint32(message.sequenceNumber);
/* iscp2.ResultCode result_code = 2; */
if (message.resultCode !== 0)
writer.tag(2, runtime_1.WireType.Varint).int32(message.resultCode);
/* string result_string = 3; */
if (message.resultString !== "")
writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.resultString);
/* iscp2.UpstreamChunkResultExtensionFields extension_fields = 4; */
if (message.extensionFields)
upstream_1.UpstreamChunkResultExtensionFields.internalBinaryWrite(message.extensionFields, writer.tag(4, runtime_1.WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message iscp2.UpstreamChunkResult
*/
exports.UpstreamChunkResult = new UpstreamChunkResult$Type();
//# sourceMappingURL=upstream.js.map