wehub-resource-sync
7254f7b4d1
Build / Build (macos-latest) (push) Has been cancelled
Build / Build (ubuntu-latest) (push) Has been cancelled
Build / Build (windows-latest) (push) Has been cancelled
Build / Analyze (javascript) (push) Has been cancelled
Build / Analyze (python) (push) Has been cancelled
959 lines
29 KiB
JavaScript
959 lines
29 KiB
JavaScript
|
|
export const uff = {};
|
|
|
|
uff.MetaGraph = class MetaGraph {
|
|
|
|
constructor() {
|
|
this.descriptors = [];
|
|
this.graphs = [];
|
|
this.referenced_data = [];
|
|
this.extra_fields = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.MetaGraph();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.version = reader.int64();
|
|
break;
|
|
case 2:
|
|
message.descriptor_core_version = reader.int64();
|
|
break;
|
|
case 3:
|
|
message.descriptors.push(uff.Descriptor.decode(reader, reader.uint32()));
|
|
break;
|
|
case 4:
|
|
message.graphs.push(uff.Graph.decode(reader, reader.uint32()));
|
|
break;
|
|
case 5:
|
|
message.referenced_data.push(uff.MetaGraph.ReferencedDataEntry.decode(reader, reader.uint32()));
|
|
break;
|
|
case 100:
|
|
message.extra_fields.push(uff.MetaGraph.ExtraFieldsEntry.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.MetaGraph();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "version":
|
|
message.version = reader.int64();
|
|
break;
|
|
case "descriptor_core_version":
|
|
message.descriptor_core_version = reader.int64();
|
|
break;
|
|
case "descriptors":
|
|
message.descriptors.push(uff.Descriptor.decodeText(reader));
|
|
break;
|
|
case "graphs":
|
|
message.graphs.push(uff.Graph.decodeText(reader));
|
|
break;
|
|
case "referenced_data":
|
|
message.referenced_data.push(uff.MetaGraph.ReferencedDataEntry.decodeText(reader));
|
|
break;
|
|
case "extra_fields":
|
|
message.extra_fields.push(uff.MetaGraph.ExtraFieldsEntry.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.MetaGraph.prototype.version = 0n;
|
|
uff.MetaGraph.prototype.descriptor_core_version = 0n;
|
|
|
|
uff.MetaGraph.ReferencedDataEntry = class ReferencedDataEntry {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.MetaGraph.ReferencedDataEntry();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case 2:
|
|
message.value = uff.Data.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.MetaGraph.ReferencedDataEntry();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.string();
|
|
break;
|
|
case "value":
|
|
message.value = uff.Data.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.MetaGraph.ReferencedDataEntry.prototype.key = "";
|
|
uff.MetaGraph.ReferencedDataEntry.prototype.value = null;
|
|
|
|
uff.MetaGraph.ExtraFieldsEntry = class ExtraFieldsEntry {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.MetaGraph.ExtraFieldsEntry();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case 2:
|
|
message.value = uff.Data.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.MetaGraph.ExtraFieldsEntry();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.string();
|
|
break;
|
|
case "value":
|
|
message.value = uff.Data.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.MetaGraph.ExtraFieldsEntry.prototype.key = "";
|
|
uff.MetaGraph.ExtraFieldsEntry.prototype.value = null;
|
|
|
|
uff.Descriptor = class Descriptor {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Descriptor();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.id = reader.string();
|
|
break;
|
|
case 2:
|
|
message.version = reader.int64();
|
|
break;
|
|
case 3:
|
|
message.optional = reader.bool();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Descriptor();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "id":
|
|
message.id = reader.string();
|
|
break;
|
|
case "version":
|
|
message.version = reader.int64();
|
|
break;
|
|
case "optional":
|
|
message.optional = reader.bool();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.Descriptor.prototype.id = "";
|
|
uff.Descriptor.prototype.version = 0n;
|
|
uff.Descriptor.prototype.optional = false;
|
|
|
|
uff.Graph = class Graph {
|
|
|
|
constructor() {
|
|
this.nodes = [];
|
|
this.extra_fields = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Graph();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.id = reader.string();
|
|
break;
|
|
case 2:
|
|
message.nodes.push(uff.Node.decode(reader, reader.uint32()));
|
|
break;
|
|
case 100:
|
|
message.extra_fields.push(uff.Graph.ExtraFieldsEntry.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Graph();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "id":
|
|
message.id = reader.string();
|
|
break;
|
|
case "nodes":
|
|
message.nodes.push(uff.Node.decodeText(reader));
|
|
break;
|
|
case "extra_fields":
|
|
message.extra_fields.push(uff.Graph.ExtraFieldsEntry.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.Graph.prototype.id = "";
|
|
|
|
uff.Graph.ExtraFieldsEntry = class ExtraFieldsEntry {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Graph.ExtraFieldsEntry();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case 2:
|
|
message.value = uff.Data.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Graph.ExtraFieldsEntry();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.string();
|
|
break;
|
|
case "value":
|
|
message.value = uff.Data.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.Graph.ExtraFieldsEntry.prototype.key = "";
|
|
uff.Graph.ExtraFieldsEntry.prototype.value = null;
|
|
|
|
uff.Node = class Node {
|
|
|
|
constructor() {
|
|
this.inputs = [];
|
|
this.fields = [];
|
|
this.extra_fields = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Node();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.id = reader.string();
|
|
break;
|
|
case 2:
|
|
message.inputs.push(reader.string());
|
|
break;
|
|
case 3:
|
|
message.operation = reader.string();
|
|
break;
|
|
case 4:
|
|
message.fields.push(uff.Node.FieldsEntry.decode(reader, reader.uint32()));
|
|
break;
|
|
case 100:
|
|
message.extra_fields.push(uff.Node.ExtraFieldsEntry.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Node();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "id":
|
|
message.id = reader.string();
|
|
break;
|
|
case "inputs":
|
|
reader.array(message.inputs, () => reader.string());
|
|
break;
|
|
case "operation":
|
|
message.operation = reader.string();
|
|
break;
|
|
case "fields":
|
|
message.fields.push(uff.Node.FieldsEntry.decodeText(reader));
|
|
break;
|
|
case "extra_fields":
|
|
message.extra_fields.push(uff.Node.ExtraFieldsEntry.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.Node.prototype.id = "";
|
|
uff.Node.prototype.operation = "";
|
|
|
|
uff.Node.FieldsEntry = class FieldsEntry {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Node.FieldsEntry();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case 2:
|
|
message.value = uff.Data.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Node.FieldsEntry();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.string();
|
|
break;
|
|
case "value":
|
|
message.value = uff.Data.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.Node.FieldsEntry.prototype.key = "";
|
|
uff.Node.FieldsEntry.prototype.value = null;
|
|
|
|
uff.Node.ExtraFieldsEntry = class ExtraFieldsEntry {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Node.ExtraFieldsEntry();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case 2:
|
|
message.value = uff.Data.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Node.ExtraFieldsEntry();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.string();
|
|
break;
|
|
case "value":
|
|
message.value = uff.Data.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.Node.ExtraFieldsEntry.prototype.key = "";
|
|
uff.Node.ExtraFieldsEntry.prototype.value = null;
|
|
|
|
uff.Data = class Data {
|
|
|
|
get type() {
|
|
uff.Data.typeSet = uff.Data.typeSet || new Set(["s", "s_list", "d", "d_list", "b", "b_list", "i", "i_list", "blob", "ref", "dtype", "dtype_list", "dim_orders", "dim_orders_list"]);
|
|
return Object.keys(this).find((key) => uff.Data.typeSet.has(key) && this[key] !== null);
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.Data();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.s = reader.string();
|
|
break;
|
|
case 2:
|
|
message.s_list = uff.ListString.decode(reader, reader.uint32());
|
|
break;
|
|
case 3:
|
|
message.d = reader.double();
|
|
break;
|
|
case 4:
|
|
message.d_list = uff.ListDouble.decode(reader, reader.uint32());
|
|
break;
|
|
case 5:
|
|
message.b = reader.bool();
|
|
break;
|
|
case 6:
|
|
message.b_list = uff.ListBool.decode(reader, reader.uint32());
|
|
break;
|
|
case 7:
|
|
message.i = reader.int64();
|
|
break;
|
|
case 8:
|
|
message.i_list = uff.ListInt64.decode(reader, reader.uint32());
|
|
break;
|
|
case 9:
|
|
message.blob = reader.bytes();
|
|
break;
|
|
case 100:
|
|
message.ref = reader.string();
|
|
break;
|
|
case 101:
|
|
message.dtype = reader.int32();
|
|
break;
|
|
case 102:
|
|
message.dtype_list = uff.ListDataType.decode(reader, reader.uint32());
|
|
break;
|
|
case 103:
|
|
message.dim_orders = uff.DimensionOrders.decode(reader, reader.uint32());
|
|
break;
|
|
case 104:
|
|
message.dim_orders_list = uff.ListDimensionOrders.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.Data();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "s":
|
|
message.s = reader.string();
|
|
break;
|
|
case "s_list":
|
|
message.s_list = uff.ListString.decodeText(reader);
|
|
break;
|
|
case "d":
|
|
message.d = reader.double();
|
|
break;
|
|
case "d_list":
|
|
message.d_list = uff.ListDouble.decodeText(reader);
|
|
break;
|
|
case "b":
|
|
message.b = reader.bool();
|
|
break;
|
|
case "b_list":
|
|
message.b_list = uff.ListBool.decodeText(reader);
|
|
break;
|
|
case "i":
|
|
message.i = reader.int64();
|
|
break;
|
|
case "i_list":
|
|
message.i_list = uff.ListInt64.decodeText(reader);
|
|
break;
|
|
case "blob":
|
|
message.blob = reader.bytes();
|
|
break;
|
|
case "ref":
|
|
message.ref = reader.string();
|
|
break;
|
|
case "dtype":
|
|
message.dtype = reader.enum(uff.DataType);
|
|
break;
|
|
case "dtype_list":
|
|
message.dtype_list = uff.ListDataType.decodeText(reader);
|
|
break;
|
|
case "dim_orders":
|
|
message.dim_orders = uff.DimensionOrders.decodeText(reader);
|
|
break;
|
|
case "dim_orders_list":
|
|
message.dim_orders_list = uff.ListDimensionOrders.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.DataType = {
|
|
"DT_INVALID": 0,
|
|
"DT_INT8": 65544,
|
|
"DT_INT16": 65552,
|
|
"DT_INT32": 65568,
|
|
"DT_INT64": 65600,
|
|
"DT_FLOAT16": 131088,
|
|
"DT_FLOAT32": 131104
|
|
};
|
|
|
|
uff.OrderEnum = {
|
|
"OE_ZERO": 0,
|
|
"OE_SPECIAL": -1,
|
|
"OE_INCREMENT": 2147483647,
|
|
"OE_DECREMENT": -2147483648
|
|
};
|
|
|
|
uff.DimensionOrders = class DimensionOrders {
|
|
|
|
constructor() {
|
|
this.orders = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.DimensionOrders();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.orders.push(uff.DimensionOrders.OrdersEntry.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.DimensionOrders();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "orders":
|
|
message.orders.push(uff.DimensionOrders.OrdersEntry.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.DimensionOrders.OrdersEntry = class OrdersEntry {
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.DimensionOrders.OrdersEntry();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.value = uff.ListInt64.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.DimensionOrders.OrdersEntry();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.enum(uff.OrderEnum);
|
|
break;
|
|
case "value":
|
|
message.value = uff.ListInt64.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.DimensionOrders.OrdersEntry.prototype.key = 0;
|
|
uff.DimensionOrders.OrdersEntry.prototype.value = null;
|
|
|
|
uff.ListString = class ListString {
|
|
|
|
constructor() {
|
|
this.val = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.ListString();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.val.push(reader.string());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.ListString();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "val":
|
|
reader.array(message.val, () => reader.string());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.ListDouble = class ListDouble {
|
|
|
|
constructor() {
|
|
this.val = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.ListDouble();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.val = reader.doubles(message.val, tag);
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.ListDouble();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "val":
|
|
reader.array(message.val, () => reader.double());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.ListBool = class ListBool {
|
|
|
|
constructor() {
|
|
this.val = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.ListBool();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.val = reader.array(message.val, () => reader.bool(), tag);
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.ListBool();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "val":
|
|
reader.array(message.val, () => reader.bool());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.ListInt64 = class ListInt64 {
|
|
|
|
constructor() {
|
|
this.val = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.ListInt64();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.val = reader.array(message.val, () => reader.int64(), tag);
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.ListInt64();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "val":
|
|
reader.array(message.val, () => reader.int64());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.ListDataType = class ListDataType {
|
|
|
|
constructor() {
|
|
this.val = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.ListDataType();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.val = reader.array(message.val, () => reader.int32(), tag);
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.ListDataType();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "val":
|
|
reader.array(message.val, () => reader.enum(uff.DataType));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
uff.ListDimensionOrders = class ListDimensionOrders {
|
|
|
|
constructor() {
|
|
this.val = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new uff.ListDimensionOrders();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.val.push(uff.DimensionOrders.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new uff.ListDimensionOrders();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "val":
|
|
message.val.push(uff.DimensionOrders.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|