| "use strict"; |
| var $protobuf = require("../.."); |
| module.exports = exports = $protobuf.descriptor = $protobuf.Root.fromJSON(require("../../google/protobuf/descriptor.json")).lookup(".google.protobuf"); |
| |
| var Namespace = $protobuf.Namespace, |
| Root = $protobuf.Root, |
| Enum = $protobuf.Enum, |
| Type = $protobuf.Type, |
| Field = $protobuf.Field, |
| MapField = $protobuf.MapField, |
| OneOf = $protobuf.OneOf, |
| Service = $protobuf.Service, |
| Method = $protobuf.Method; |
| |
| // --- Root --- |
| |
| /** |
| * Properties of a FileDescriptorSet message. |
| * @interface IFileDescriptorSet |
| * @property {IFileDescriptorProto[]} file Files |
| */ |
| |
| /** |
| * Properties of a FileDescriptorProto message. |
| * @interface IFileDescriptorProto |
| * @property {string} [name] File name |
| * @property {string} [package] Package |
| * @property {*} [dependency] Not supported |
| * @property {*} [publicDependency] Not supported |
| * @property {*} [weakDependency] Not supported |
| * @property {IDescriptorProto[]} [messageType] Nested message types |
| * @property {IEnumDescriptorProto[]} [enumType] Nested enums |
| * @property {IServiceDescriptorProto[]} [service] Nested services |
| * @property {IFieldDescriptorProto[]} [extension] Nested extension fields |
| * @property {IFileOptions} [options] Options |
| * @property {*} [sourceCodeInfo] Not supported |
| * @property {string} [syntax="proto2"] Syntax |
| */ |
| |
| /** |
| * Properties of a FileOptions message. |
| * @interface IFileOptions |
| * @property {string} [javaPackage] |
| * @property {string} [javaOuterClassname] |
| * @property {boolean} [javaMultipleFiles] |
| * @property {boolean} [javaGenerateEqualsAndHash] |
| * @property {boolean} [javaStringCheckUtf8] |
| * @property {IFileOptionsOptimizeMode} [optimizeFor=1] |
| * @property {string} [goPackage] |
| * @property {boolean} [ccGenericServices] |
| * @property {boolean} [javaGenericServices] |
| * @property {boolean} [pyGenericServices] |
| * @property {boolean} [deprecated] |
| * @property {boolean} [ccEnableArenas] |
| * @property {string} [objcClassPrefix] |
| * @property {string} [csharpNamespace] |
| */ |
| |
| /** |
| * Values of he FileOptions.OptimizeMode enum. |
| * @typedef IFileOptionsOptimizeMode |
| * @type {number} |
| * @property {number} SPEED=1 |
| * @property {number} CODE_SIZE=2 |
| * @property {number} LITE_RUNTIME=3 |
| */ |
| |
| /** |
| * Creates a root from a descriptor set. |
| * @param {IFileDescriptorSet|Reader|Uint8Array} descriptor Descriptor |
| * @returns {Root} Root instance |
| */ |
| Root.fromDescriptor = function fromDescriptor(descriptor) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.FileDescriptorSet.decode(descriptor); |
| |
| var root = new Root(); |
| |
| if (descriptor.file) { |
| var fileDescriptor, |
| filePackage; |
| for (var j = 0, i; j < descriptor.file.length; ++j) { |
| filePackage = root; |
| if ((fileDescriptor = descriptor.file[j])["package"] && fileDescriptor["package"].length) |
| filePackage = root.define(fileDescriptor["package"]); |
| if (fileDescriptor.name && fileDescriptor.name.length) |
| root.files.push(filePackage.filename = fileDescriptor.name); |
| if (fileDescriptor.messageType) |
| for (i = 0; i < fileDescriptor.messageType.length; ++i) |
| filePackage.add(Type.fromDescriptor(fileDescriptor.messageType[i], fileDescriptor.syntax)); |
| if (fileDescriptor.enumType) |
| for (i = 0; i < fileDescriptor.enumType.length; ++i) |
| filePackage.add(Enum.fromDescriptor(fileDescriptor.enumType[i])); |
| if (fileDescriptor.extension) |
| for (i = 0; i < fileDescriptor.extension.length; ++i) |
| filePackage.add(Field.fromDescriptor(fileDescriptor.extension[i])); |
| if (fileDescriptor.service) |
| for (i = 0; i < fileDescriptor.service.length; ++i) |
| filePackage.add(Service.fromDescriptor(fileDescriptor.service[i])); |
| var opts = fromDescriptorOptions(fileDescriptor.options, exports.FileOptions); |
| if (opts) { |
| var ks = Object.keys(opts); |
| for (i = 0; i < ks.length; ++i) |
| filePackage.setOption(ks[i], opts[ks[i]]); |
| } |
| } |
| } |
| |
| return root; |
| }; |
| |
| /** |
| * Converts a root to a descriptor set. |
| * @returns {Message<IFileDescriptorSet>} Descriptor |
| * @param {string} [syntax="proto2"] Syntax |
| */ |
| Root.prototype.toDescriptor = function toDescriptor(syntax) { |
| var set = exports.FileDescriptorSet.create(); |
| Root_toDescriptorRecursive(this, set.file, syntax); |
| return set; |
| }; |
| |
| // Traverses a namespace and assembles the descriptor set |
| function Root_toDescriptorRecursive(ns, files, syntax) { |
| |
| // Create a new file |
| var file = exports.FileDescriptorProto.create({ name: ns.filename || (ns.fullName.substring(1).replace(/\./g, "_") || "root") + ".proto" }); |
| if (syntax) |
| file.syntax = syntax; |
| if (!(ns instanceof Root)) |
| file["package"] = ns.fullName.substring(1); |
| |
| // Add nested types |
| for (var i = 0, nested; i < ns.nestedArray.length; ++i) |
| if ((nested = ns._nestedArray[i]) instanceof Type) |
| file.messageType.push(nested.toDescriptor(syntax)); |
| else if (nested instanceof Enum) |
| file.enumType.push(nested.toDescriptor()); |
| else if (nested instanceof Field) |
| file.extension.push(nested.toDescriptor(syntax)); |
| else if (nested instanceof Service) |
| file.service.push(nested.toDescriptor()); |
| else if (nested instanceof /* plain */ Namespace) |
| Root_toDescriptorRecursive(nested, files, syntax); // requires new file |
| |
| // Keep package-level options |
| file.options = toDescriptorOptions(ns.options, exports.FileOptions); |
| |
| // And keep the file only if there is at least one nested object |
| if (file.messageType.length + file.enumType.length + file.extension.length + file.service.length) |
| files.push(file); |
| } |
| |
| // --- Type --- |
| |
| /** |
| * Properties of a DescriptorProto message. |
| * @interface IDescriptorProto |
| * @property {string} [name] Message type name |
| * @property {IFieldDescriptorProto[]} [field] Fields |
| * @property {IFieldDescriptorProto[]} [extension] Extension fields |
| * @property {IDescriptorProto[]} [nestedType] Nested message types |
| * @property {IEnumDescriptorProto[]} [enumType] Nested enums |
| * @property {IDescriptorProtoExtensionRange[]} [extensionRange] Extension ranges |
| * @property {IOneofDescriptorProto[]} [oneofDecl] Oneofs |
| * @property {IMessageOptions} [options] Not supported |
| * @property {IDescriptorProtoReservedRange[]} [reservedRange] Reserved ranges |
| * @property {string[]} [reservedName] Reserved names |
| */ |
| |
| /** |
| * Properties of a MessageOptions message. |
| * @interface IMessageOptions |
| * @property {boolean} [mapEntry=false] Whether this message is a map entry |
| */ |
| |
| /** |
| * Properties of an ExtensionRange message. |
| * @interface IDescriptorProtoExtensionRange |
| * @property {number} [start] Start field id |
| * @property {number} [end] End field id |
| */ |
| |
| /** |
| * Properties of a ReservedRange message. |
| * @interface IDescriptorProtoReservedRange |
| * @property {number} [start] Start field id |
| * @property {number} [end] End field id |
| */ |
| |
| var unnamedMessageIndex = 0; |
| |
| /** |
| * Creates a type from a descriptor. |
| * @param {IDescriptorProto|Reader|Uint8Array} descriptor Descriptor |
| * @param {string} [syntax="proto2"] Syntax |
| * @returns {Type} Type instance |
| */ |
| Type.fromDescriptor = function fromDescriptor(descriptor, syntax) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.DescriptorProto.decode(descriptor); |
| |
| // Create the message type |
| var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)), |
| i; |
| |
| /* Oneofs */ if (descriptor.oneofDecl) |
| for (i = 0; i < descriptor.oneofDecl.length; ++i) |
| type.add(OneOf.fromDescriptor(descriptor.oneofDecl[i])); |
| /* Fields */ if (descriptor.field) |
| for (i = 0; i < descriptor.field.length; ++i) { |
| var field = Field.fromDescriptor(descriptor.field[i], syntax); |
| type.add(field); |
| if (descriptor.field[i].hasOwnProperty("oneofIndex")) // eslint-disable-line no-prototype-builtins |
| type.oneofsArray[descriptor.field[i].oneofIndex].add(field); |
| } |
| /* Extension fields */ if (descriptor.extension) |
| for (i = 0; i < descriptor.extension.length; ++i) |
| type.add(Field.fromDescriptor(descriptor.extension[i], syntax)); |
| /* Nested types */ if (descriptor.nestedType) |
| for (i = 0; i < descriptor.nestedType.length; ++i) { |
| type.add(Type.fromDescriptor(descriptor.nestedType[i], syntax)); |
| if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry) |
| type.setOption("map_entry", true); |
| } |
| /* Nested enums */ if (descriptor.enumType) |
| for (i = 0; i < descriptor.enumType.length; ++i) |
| type.add(Enum.fromDescriptor(descriptor.enumType[i])); |
| /* Extension ranges */ if (descriptor.extensionRange && descriptor.extensionRange.length) { |
| type.extensions = []; |
| for (i = 0; i < descriptor.extensionRange.length; ++i) |
| type.extensions.push([ descriptor.extensionRange[i].start, descriptor.extensionRange[i].end ]); |
| } |
| /* Reserved... */ if (descriptor.reservedRange && descriptor.reservedRange.length || descriptor.reservedName && descriptor.reservedName.length) { |
| type.reserved = []; |
| /* Ranges */ if (descriptor.reservedRange) |
| for (i = 0; i < descriptor.reservedRange.length; ++i) |
| type.reserved.push([ descriptor.reservedRange[i].start, descriptor.reservedRange[i].end ]); |
| /* Names */ if (descriptor.reservedName) |
| for (i = 0; i < descriptor.reservedName.length; ++i) |
| type.reserved.push(descriptor.reservedName[i]); |
| } |
| |
| return type; |
| }; |
| |
| /** |
| * Converts a type to a descriptor. |
| * @returns {Message<IDescriptorProto>} Descriptor |
| * @param {string} [syntax="proto2"] Syntax |
| */ |
| Type.prototype.toDescriptor = function toDescriptor(syntax) { |
| var descriptor = exports.DescriptorProto.create({ name: this.name }), |
| i; |
| |
| /* Fields */ for (i = 0; i < this.fieldsArray.length; ++i) { |
| var fieldDescriptor; |
| descriptor.field.push(fieldDescriptor = this._fieldsArray[i].toDescriptor(syntax)); |
| if (this._fieldsArray[i] instanceof MapField) { // map fields are repeated FieldNameEntry |
| var keyType = toDescriptorType(this._fieldsArray[i].keyType, this._fieldsArray[i].resolvedKeyType), |
| valueType = toDescriptorType(this._fieldsArray[i].type, this._fieldsArray[i].resolvedType), |
| valueTypeName = valueType === /* type */ 11 || valueType === /* enum */ 14 |
| ? this._fieldsArray[i].resolvedType && shortname(this.parent, this._fieldsArray[i].resolvedType) || this._fieldsArray[i].type |
| : undefined; |
| descriptor.nestedType.push(exports.DescriptorProto.create({ |
| name: fieldDescriptor.typeName, |
| field: [ |
| exports.FieldDescriptorProto.create({ name: "key", number: 1, label: 1, type: keyType }), // can't reference a type or enum |
| exports.FieldDescriptorProto.create({ name: "value", number: 2, label: 1, type: valueType, typeName: valueTypeName }) |
| ], |
| options: exports.MessageOptions.create({ mapEntry: true }) |
| })); |
| } |
| } |
| /* Oneofs */ for (i = 0; i < this.oneofsArray.length; ++i) |
| descriptor.oneofDecl.push(this._oneofsArray[i].toDescriptor()); |
| /* Nested... */ for (i = 0; i < this.nestedArray.length; ++i) { |
| /* Extension fields */ if (this._nestedArray[i] instanceof Field) |
| descriptor.field.push(this._nestedArray[i].toDescriptor(syntax)); |
| /* Types */ else if (this._nestedArray[i] instanceof Type) |
| descriptor.nestedType.push(this._nestedArray[i].toDescriptor(syntax)); |
| /* Enums */ else if (this._nestedArray[i] instanceof Enum) |
| descriptor.enumType.push(this._nestedArray[i].toDescriptor()); |
| // plain nested namespaces become packages instead in Root#toDescriptor |
| } |
| /* Extension ranges */ if (this.extensions) |
| for (i = 0; i < this.extensions.length; ++i) |
| descriptor.extensionRange.push(exports.DescriptorProto.ExtensionRange.create({ start: this.extensions[i][0], end: this.extensions[i][1] })); |
| /* Reserved... */ if (this.reserved) |
| for (i = 0; i < this.reserved.length; ++i) |
| /* Names */ if (typeof this.reserved[i] === "string") |
| descriptor.reservedName.push(this.reserved[i]); |
| /* Ranges */ else |
| descriptor.reservedRange.push(exports.DescriptorProto.ReservedRange.create({ start: this.reserved[i][0], end: this.reserved[i][1] })); |
| |
| descriptor.options = toDescriptorOptions(this.options, exports.MessageOptions); |
| |
| return descriptor; |
| }; |
| |
| // --- Field --- |
| |
| /** |
| * Properties of a FieldDescriptorProto message. |
| * @interface IFieldDescriptorProto |
| * @property {string} [name] Field name |
| * @property {number} [number] Field id |
| * @property {IFieldDescriptorProtoLabel} [label] Field rule |
| * @property {IFieldDescriptorProtoType} [type] Field basic type |
| * @property {string} [typeName] Field type name |
| * @property {string} [extendee] Extended type name |
| * @property {string} [defaultValue] Literal default value |
| * @property {number} [oneofIndex] Oneof index if part of a oneof |
| * @property {*} [jsonName] Not supported |
| * @property {IFieldOptions} [options] Field options |
| */ |
| |
| /** |
| * Values of the FieldDescriptorProto.Label enum. |
| * @typedef IFieldDescriptorProtoLabel |
| * @type {number} |
| * @property {number} LABEL_OPTIONAL=1 |
| * @property {number} LABEL_REQUIRED=2 |
| * @property {number} LABEL_REPEATED=3 |
| */ |
| |
| /** |
| * Values of the FieldDescriptorProto.Type enum. |
| * @typedef IFieldDescriptorProtoType |
| * @type {number} |
| * @property {number} TYPE_DOUBLE=1 |
| * @property {number} TYPE_FLOAT=2 |
| * @property {number} TYPE_INT64=3 |
| * @property {number} TYPE_UINT64=4 |
| * @property {number} TYPE_INT32=5 |
| * @property {number} TYPE_FIXED64=6 |
| * @property {number} TYPE_FIXED32=7 |
| * @property {number} TYPE_BOOL=8 |
| * @property {number} TYPE_STRING=9 |
| * @property {number} TYPE_GROUP=10 |
| * @property {number} TYPE_MESSAGE=11 |
| * @property {number} TYPE_BYTES=12 |
| * @property {number} TYPE_UINT32=13 |
| * @property {number} TYPE_ENUM=14 |
| * @property {number} TYPE_SFIXED32=15 |
| * @property {number} TYPE_SFIXED64=16 |
| * @property {number} TYPE_SINT32=17 |
| * @property {number} TYPE_SINT64=18 |
| */ |
| |
| /** |
| * Properties of a FieldOptions message. |
| * @interface IFieldOptions |
| * @property {boolean} [packed] Whether packed or not (defaults to `false` for proto2 and `true` for proto3) |
| * @property {IFieldOptionsJSType} [jstype] JavaScript value type (not used by protobuf.js) |
| */ |
| |
| /** |
| * Values of the FieldOptions.JSType enum. |
| * @typedef IFieldOptionsJSType |
| * @type {number} |
| * @property {number} JS_NORMAL=0 |
| * @property {number} JS_STRING=1 |
| * @property {number} JS_NUMBER=2 |
| */ |
| |
| // copied here from parse.js |
| var numberRe = /^(?![eE])[0-9]*(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/; |
| |
| /** |
| * Creates a field from a descriptor. |
| * @param {IFieldDescriptorProto|Reader|Uint8Array} descriptor Descriptor |
| * @param {string} [syntax="proto2"] Syntax |
| * @returns {Field} Field instance |
| */ |
| Field.fromDescriptor = function fromDescriptor(descriptor, syntax) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.DescriptorProto.decode(descriptor); |
| |
| if (typeof descriptor.number !== "number") |
| throw Error("missing field id"); |
| |
| // Rewire field type |
| var fieldType; |
| if (descriptor.typeName && descriptor.typeName.length) |
| fieldType = descriptor.typeName; |
| else |
| fieldType = fromDescriptorType(descriptor.type); |
| |
| // Rewire field rule |
| var fieldRule; |
| switch (descriptor.label) { |
| // 0 is reserved for errors |
| case 1: fieldRule = undefined; break; |
| case 2: fieldRule = "required"; break; |
| case 3: fieldRule = "repeated"; break; |
| default: throw Error("illegal label: " + descriptor.label); |
| } |
| |
| var extendee = descriptor.extendee; |
| if (descriptor.extendee !== undefined) { |
| extendee = extendee.length ? extendee : undefined; |
| } |
| var field = new Field( |
| descriptor.name.length ? descriptor.name : "field" + descriptor.number, |
| descriptor.number, |
| fieldType, |
| fieldRule, |
| extendee |
| ); |
| |
| field.options = fromDescriptorOptions(descriptor.options, exports.FieldOptions); |
| |
| if (descriptor.defaultValue && descriptor.defaultValue.length) { |
| var defaultValue = descriptor.defaultValue; |
| switch (defaultValue) { |
| case "true": case "TRUE": |
| defaultValue = true; |
| break; |
| case "false": case "FALSE": |
| defaultValue = false; |
| break; |
| default: |
| var match = numberRe.exec(defaultValue); |
| if (match) |
| defaultValue = parseInt(defaultValue); // eslint-disable-line radix |
| break; |
| } |
| field.setOption("default", defaultValue); |
| } |
| |
| if (packableDescriptorType(descriptor.type)) { |
| if (syntax === "proto3") { // defaults to packed=true (internal preset is packed=true) |
| if (descriptor.options && !descriptor.options.packed) |
| field.setOption("packed", false); |
| } else if (!(descriptor.options && descriptor.options.packed)) // defaults to packed=false |
| field.setOption("packed", false); |
| } |
| |
| return field; |
| }; |
| |
| /** |
| * Converts a field to a descriptor. |
| * @returns {Message<IFieldDescriptorProto>} Descriptor |
| * @param {string} [syntax="proto2"] Syntax |
| */ |
| Field.prototype.toDescriptor = function toDescriptor(syntax) { |
| var descriptor = exports.FieldDescriptorProto.create({ name: this.name, number: this.id }); |
| |
| if (this.map) { |
| |
| descriptor.type = 11; // message |
| descriptor.typeName = $protobuf.util.ucFirst(this.name); // fieldName -> FieldNameEntry (built in Type#toDescriptor) |
| descriptor.label = 3; // repeated |
| |
| } else { |
| |
| // Rewire field type |
| switch (descriptor.type = toDescriptorType(this.type, this.resolve().resolvedType)) { |
| case 10: // group |
| case 11: // type |
| case 14: // enum |
| descriptor.typeName = this.resolvedType ? shortname(this.parent, this.resolvedType) : this.type; |
| break; |
| } |
| |
| // Rewire field rule |
| switch (this.rule) { |
| case "repeated": descriptor.label = 3; break; |
| case "required": descriptor.label = 2; break; |
| default: descriptor.label = 1; break; |
| } |
| |
| } |
| |
| // Handle extension field |
| descriptor.extendee = this.extensionField ? this.extensionField.parent.fullName : this.extend; |
| |
| // Handle part of oneof |
| if (this.partOf) |
| if ((descriptor.oneofIndex = this.parent.oneofsArray.indexOf(this.partOf)) < 0) |
| throw Error("missing oneof"); |
| |
| if (this.options) { |
| descriptor.options = toDescriptorOptions(this.options, exports.FieldOptions); |
| if (this.options["default"] != null) |
| descriptor.defaultValue = String(this.options["default"]); |
| } |
| |
| if (syntax === "proto3") { // defaults to packed=true |
| if (!this.packed) |
| (descriptor.options || (descriptor.options = exports.FieldOptions.create())).packed = false; |
| } else if (this.packed) // defaults to packed=false |
| (descriptor.options || (descriptor.options = exports.FieldOptions.create())).packed = true; |
| |
| return descriptor; |
| }; |
| |
| // --- Enum --- |
| |
| /** |
| * Properties of an EnumDescriptorProto message. |
| * @interface IEnumDescriptorProto |
| * @property {string} [name] Enum name |
| * @property {IEnumValueDescriptorProto[]} [value] Enum values |
| * @property {IEnumOptions} [options] Enum options |
| */ |
| |
| /** |
| * Properties of an EnumValueDescriptorProto message. |
| * @interface IEnumValueDescriptorProto |
| * @property {string} [name] Name |
| * @property {number} [number] Value |
| * @property {*} [options] Not supported |
| */ |
| |
| /** |
| * Properties of an EnumOptions message. |
| * @interface IEnumOptions |
| * @property {boolean} [allowAlias] Whether aliases are allowed |
| * @property {boolean} [deprecated] |
| */ |
| |
| var unnamedEnumIndex = 0; |
| |
| /** |
| * Creates an enum from a descriptor. |
| * @param {IEnumDescriptorProto|Reader|Uint8Array} descriptor Descriptor |
| * @returns {Enum} Enum instance |
| */ |
| Enum.fromDescriptor = function fromDescriptor(descriptor) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.EnumDescriptorProto.decode(descriptor); |
| |
| // Construct values object |
| var values = {}; |
| if (descriptor.value) |
| for (var i = 0; i < descriptor.value.length; ++i) { |
| var name = descriptor.value[i].name, |
| value = descriptor.value[i].number || 0; |
| values[name && name.length ? name : "NAME" + value] = value; |
| } |
| |
| return new Enum( |
| descriptor.name && descriptor.name.length ? descriptor.name : "Enum" + unnamedEnumIndex++, |
| values, |
| fromDescriptorOptions(descriptor.options, exports.EnumOptions) |
| ); |
| }; |
| |
| /** |
| * Converts an enum to a descriptor. |
| * @returns {Message<IEnumDescriptorProto>} Descriptor |
| */ |
| Enum.prototype.toDescriptor = function toDescriptor() { |
| |
| // Values |
| var values = []; |
| for (var i = 0, ks = Object.keys(this.values); i < ks.length; ++i) |
| values.push(exports.EnumValueDescriptorProto.create({ name: ks[i], number: this.values[ks[i]] })); |
| |
| return exports.EnumDescriptorProto.create({ |
| name: this.name, |
| value: values, |
| options: toDescriptorOptions(this.options, exports.EnumOptions) |
| }); |
| }; |
| |
| // --- OneOf --- |
| |
| /** |
| * Properties of a OneofDescriptorProto message. |
| * @interface IOneofDescriptorProto |
| * @property {string} [name] Oneof name |
| * @property {*} [options] Not supported |
| */ |
| |
| var unnamedOneofIndex = 0; |
| |
| /** |
| * Creates a oneof from a descriptor. |
| * @param {IOneofDescriptorProto|Reader|Uint8Array} descriptor Descriptor |
| * @returns {OneOf} OneOf instance |
| */ |
| OneOf.fromDescriptor = function fromDescriptor(descriptor) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.OneofDescriptorProto.decode(descriptor); |
| |
| return new OneOf( |
| // unnamedOneOfIndex is global, not per type, because we have no ref to a type here |
| descriptor.name && descriptor.name.length ? descriptor.name : "oneof" + unnamedOneofIndex++ |
| // fromDescriptorOptions(descriptor.options, exports.OneofOptions) - only uninterpreted_option |
| ); |
| }; |
| |
| /** |
| * Converts a oneof to a descriptor. |
| * @returns {Message<IOneofDescriptorProto>} Descriptor |
| */ |
| OneOf.prototype.toDescriptor = function toDescriptor() { |
| return exports.OneofDescriptorProto.create({ |
| name: this.name |
| // options: toDescriptorOptions(this.options, exports.OneofOptions) - only uninterpreted_option |
| }); |
| }; |
| |
| // --- Service --- |
| |
| /** |
| * Properties of a ServiceDescriptorProto message. |
| * @interface IServiceDescriptorProto |
| * @property {string} [name] Service name |
| * @property {IMethodDescriptorProto[]} [method] Methods |
| * @property {IServiceOptions} [options] Options |
| */ |
| |
| /** |
| * Properties of a ServiceOptions message. |
| * @interface IServiceOptions |
| * @property {boolean} [deprecated] |
| */ |
| |
| var unnamedServiceIndex = 0; |
| |
| /** |
| * Creates a service from a descriptor. |
| * @param {IServiceDescriptorProto|Reader|Uint8Array} descriptor Descriptor |
| * @returns {Service} Service instance |
| */ |
| Service.fromDescriptor = function fromDescriptor(descriptor) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.ServiceDescriptorProto.decode(descriptor); |
| |
| var service = new Service(descriptor.name && descriptor.name.length ? descriptor.name : "Service" + unnamedServiceIndex++, fromDescriptorOptions(descriptor.options, exports.ServiceOptions)); |
| if (descriptor.method) |
| for (var i = 0; i < descriptor.method.length; ++i) |
| service.add(Method.fromDescriptor(descriptor.method[i])); |
| |
| return service; |
| }; |
| |
| /** |
| * Converts a service to a descriptor. |
| * @returns {Message<IServiceDescriptorProto>} Descriptor |
| */ |
| Service.prototype.toDescriptor = function toDescriptor() { |
| |
| // Methods |
| var methods = []; |
| for (var i = 0; i < this.methodsArray.length; ++i) |
| methods.push(this._methodsArray[i].toDescriptor()); |
| |
| return exports.ServiceDescriptorProto.create({ |
| name: this.name, |
| method: methods, |
| options: toDescriptorOptions(this.options, exports.ServiceOptions) |
| }); |
| }; |
| |
| // --- Method --- |
| |
| /** |
| * Properties of a MethodDescriptorProto message. |
| * @interface IMethodDescriptorProto |
| * @property {string} [name] Method name |
| * @property {string} [inputType] Request type name |
| * @property {string} [outputType] Response type name |
| * @property {IMethodOptions} [options] Not supported |
| * @property {boolean} [clientStreaming=false] Whether requests are streamed |
| * @property {boolean} [serverStreaming=false] Whether responses are streamed |
| */ |
| |
| /** |
| * Properties of a MethodOptions message. |
| * @interface IMethodOptions |
| * @property {boolean} [deprecated] |
| */ |
| |
| var unnamedMethodIndex = 0; |
| |
| /** |
| * Creates a method from a descriptor. |
| * @param {IMethodDescriptorProto|Reader|Uint8Array} descriptor Descriptor |
| * @returns {Method} Reflected method instance |
| */ |
| Method.fromDescriptor = function fromDescriptor(descriptor) { |
| |
| // Decode the descriptor message if specified as a buffer: |
| if (typeof descriptor.length === "number") |
| descriptor = exports.MethodDescriptorProto.decode(descriptor); |
| |
| return new Method( |
| // unnamedMethodIndex is global, not per service, because we have no ref to a service here |
| descriptor.name && descriptor.name.length ? descriptor.name : "Method" + unnamedMethodIndex++, |
| "rpc", |
| descriptor.inputType, |
| descriptor.outputType, |
| Boolean(descriptor.clientStreaming), |
| Boolean(descriptor.serverStreaming), |
| fromDescriptorOptions(descriptor.options, exports.MethodOptions) |
| ); |
| }; |
| |
| /** |
| * Converts a method to a descriptor. |
| * @returns {Message<IMethodDescriptorProto>} Descriptor |
| */ |
| Method.prototype.toDescriptor = function toDescriptor() { |
| return exports.MethodDescriptorProto.create({ |
| name: this.name, |
| inputType: this.resolvedRequestType ? this.resolvedRequestType.fullName : this.requestType, |
| outputType: this.resolvedResponseType ? this.resolvedResponseType.fullName : this.responseType, |
| clientStreaming: this.requestStream, |
| serverStreaming: this.responseStream, |
| options: toDescriptorOptions(this.options, exports.MethodOptions) |
| }); |
| }; |
| |
| // --- utility --- |
| |
| // Converts a descriptor type to a protobuf.js basic type |
| function fromDescriptorType(type) { |
| switch (type) { |
| // 0 is reserved for errors |
| case 1: return "double"; |
| case 2: return "float"; |
| case 3: return "int64"; |
| case 4: return "uint64"; |
| case 5: return "int32"; |
| case 6: return "fixed64"; |
| case 7: return "fixed32"; |
| case 8: return "bool"; |
| case 9: return "string"; |
| case 12: return "bytes"; |
| case 13: return "uint32"; |
| case 15: return "sfixed32"; |
| case 16: return "sfixed64"; |
| case 17: return "sint32"; |
| case 18: return "sint64"; |
| } |
| throw Error("illegal type: " + type); |
| } |
| |
| // Tests if a descriptor type is packable |
| function packableDescriptorType(type) { |
| switch (type) { |
| case 1: // double |
| case 2: // float |
| case 3: // int64 |
| case 4: // uint64 |
| case 5: // int32 |
| case 6: // fixed64 |
| case 7: // fixed32 |
| case 8: // bool |
| case 13: // uint32 |
| case 14: // enum (!) |
| case 15: // sfixed32 |
| case 16: // sfixed64 |
| case 17: // sint32 |
| case 18: // sint64 |
| return true; |
| } |
| return false; |
| } |
| |
| // Converts a protobuf.js basic type to a descriptor type |
| function toDescriptorType(type, resolvedType) { |
| switch (type) { |
| // 0 is reserved for errors |
| case "double": return 1; |
| case "float": return 2; |
| case "int64": return 3; |
| case "uint64": return 4; |
| case "int32": return 5; |
| case "fixed64": return 6; |
| case "fixed32": return 7; |
| case "bool": return 8; |
| case "string": return 9; |
| case "bytes": return 12; |
| case "uint32": return 13; |
| case "sfixed32": return 15; |
| case "sfixed64": return 16; |
| case "sint32": return 17; |
| case "sint64": return 18; |
| } |
| if (resolvedType instanceof Enum) |
| return 14; |
| if (resolvedType instanceof Type) |
| return resolvedType.group ? 10 : 11; |
| throw Error("illegal type: " + type); |
| } |
| |
| // Converts descriptor options to an options object |
| function fromDescriptorOptions(options, type) { |
| if (!options) |
| return undefined; |
| var out = []; |
| for (var i = 0, field, key, val; i < type.fieldsArray.length; ++i) |
| if ((key = (field = type._fieldsArray[i]).name) !== "uninterpretedOption") |
| if (options.hasOwnProperty(key)) { // eslint-disable-line no-prototype-builtins |
| val = options[key]; |
| if (field.resolvedType instanceof Enum && typeof val === "number" && field.resolvedType.valuesById[val] !== undefined) |
| val = field.resolvedType.valuesById[val]; |
| out.push(underScore(key), val); |
| } |
| return out.length ? $protobuf.util.toObject(out) : undefined; |
| } |
| |
| // Converts an options object to descriptor options |
| function toDescriptorOptions(options, type) { |
| if (!options) |
| return undefined; |
| var out = []; |
| for (var i = 0, ks = Object.keys(options), key, val; i < ks.length; ++i) { |
| val = options[key = ks[i]]; |
| if (key === "default") |
| continue; |
| var field = type.fields[key]; |
| if (!field && !(field = type.fields[key = $protobuf.util.camelCase(key)])) |
| continue; |
| out.push(key, val); |
| } |
| return out.length ? type.fromObject($protobuf.util.toObject(out)) : undefined; |
| } |
| |
| // Calculates the shortest relative path from `from` to `to`. |
| function shortname(from, to) { |
| var fromPath = from.fullName.split("."), |
| toPath = to.fullName.split("."), |
| i = 0, |
| j = 0, |
| k = toPath.length - 1; |
| if (!(from instanceof Root) && to instanceof Namespace) |
| while (i < fromPath.length && j < k && fromPath[i] === toPath[j]) { |
| var other = to.lookup(fromPath[i++], true); |
| if (other !== null && other !== to) |
| break; |
| ++j; |
| } |
| else |
| for (; i < fromPath.length && j < k && fromPath[i] === toPath[j]; ++i, ++j); |
| return toPath.slice(j).join("."); |
| } |
| |
| // copied here from cli/targets/proto.js |
| function underScore(str) { |
| return str.substring(0,1) |
| + str.substring(1) |
| .replace(/([A-Z])(?=[a-z]|$)/g, function($0, $1) { return "_" + $1.toLowerCase(); }); |
| } |
| |
| // --- exports --- |
| |
| /** |
| * Reflected file descriptor set. |
| * @name FileDescriptorSet |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected file descriptor proto. |
| * @name FileDescriptorProto |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected descriptor proto. |
| * @name DescriptorProto |
| * @type {Type} |
| * @property {Type} ExtensionRange |
| * @property {Type} ReservedRange |
| * @const |
| * @tstype $protobuf.Type & { |
| * ExtensionRange: $protobuf.Type, |
| * ReservedRange: $protobuf.Type |
| * } |
| */ |
| |
| /** |
| * Reflected field descriptor proto. |
| * @name FieldDescriptorProto |
| * @type {Type} |
| * @property {Enum} Label |
| * @property {Enum} Type |
| * @const |
| * @tstype $protobuf.Type & { |
| * Label: $protobuf.Enum, |
| * Type: $protobuf.Enum |
| * } |
| */ |
| |
| /** |
| * Reflected oneof descriptor proto. |
| * @name OneofDescriptorProto |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected enum descriptor proto. |
| * @name EnumDescriptorProto |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected service descriptor proto. |
| * @name ServiceDescriptorProto |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected enum value descriptor proto. |
| * @name EnumValueDescriptorProto |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected method descriptor proto. |
| * @name MethodDescriptorProto |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected file options. |
| * @name FileOptions |
| * @type {Type} |
| * @property {Enum} OptimizeMode |
| * @const |
| * @tstype $protobuf.Type & { |
| * OptimizeMode: $protobuf.Enum |
| * } |
| */ |
| |
| /** |
| * Reflected message options. |
| * @name MessageOptions |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected field options. |
| * @name FieldOptions |
| * @type {Type} |
| * @property {Enum} CType |
| * @property {Enum} JSType |
| * @const |
| * @tstype $protobuf.Type & { |
| * CType: $protobuf.Enum, |
| * JSType: $protobuf.Enum |
| * } |
| */ |
| |
| /** |
| * Reflected oneof options. |
| * @name OneofOptions |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected enum options. |
| * @name EnumOptions |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected enum value options. |
| * @name EnumValueOptions |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected service options. |
| * @name ServiceOptions |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected method options. |
| * @name MethodOptions |
| * @type {Type} |
| * @const |
| * @tstype $protobuf.Type |
| */ |
| |
| /** |
| * Reflected uninterpretet option. |
| * @name UninterpretedOption |
| * @type {Type} |
| * @property {Type} NamePart |
| * @const |
| * @tstype $protobuf.Type & { |
| * NamePart: $protobuf.Type |
| * } |
| */ |
| |
| /** |
| * Reflected source code info. |
| * @name SourceCodeInfo |
| * @type {Type} |
| * @property {Type} Location |
| * @const |
| * @tstype $protobuf.Type & { |
| * Location: $protobuf.Type |
| * } |
| */ |
| |
| /** |
| * Reflected generated code info. |
| * @name GeneratedCodeInfo |
| * @type {Type} |
| * @property {Type} Annotation |
| * @const |
| * @tstype $protobuf.Type & { |
| * Annotation: $protobuf.Type |
| * } |
| */ |
