Simulator first commit
This commit is contained in:
634
node_modules/protobufjs/src/ProtoBuf/Builder.js
generated
vendored
Normal file
634
node_modules/protobufjs/src/ProtoBuf/Builder.js
generated
vendored
Normal file
@ -0,0 +1,634 @@
|
||||
/**
|
||||
* @alias ProtoBuf.Builder
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.Builder = (function(ProtoBuf, Lang, Reflect) {
|
||||
"use strict";
|
||||
|
||||
/**
|
||||
* Constructs a new Builder.
|
||||
* @exports ProtoBuf.Builder
|
||||
* @class Provides the functionality to build protocol messages.
|
||||
* @param {Object.<string,*>=} options Options
|
||||
* @constructor
|
||||
*/
|
||||
var Builder = function(options) {
|
||||
|
||||
/**
|
||||
* Namespace.
|
||||
* @type {ProtoBuf.Reflect.Namespace}
|
||||
* @expose
|
||||
*/
|
||||
this.ns = new Reflect.Namespace(this, null, ""); // Global namespace
|
||||
|
||||
/**
|
||||
* Namespace pointer.
|
||||
* @type {ProtoBuf.Reflect.T}
|
||||
* @expose
|
||||
*/
|
||||
this.ptr = this.ns;
|
||||
|
||||
/**
|
||||
* Resolved flag.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
this.resolved = false;
|
||||
|
||||
/**
|
||||
* The current building result.
|
||||
* @type {Object.<string,ProtoBuf.Builder.Message|Object>|null}
|
||||
* @expose
|
||||
*/
|
||||
this.result = null;
|
||||
|
||||
/**
|
||||
* Imported files.
|
||||
* @type {Array.<string>}
|
||||
* @expose
|
||||
*/
|
||||
this.files = {};
|
||||
|
||||
/**
|
||||
* Import root override.
|
||||
* @type {?string}
|
||||
* @expose
|
||||
*/
|
||||
this.importRoot = null;
|
||||
|
||||
/**
|
||||
* Options.
|
||||
* @type {!Object.<string, *>}
|
||||
* @expose
|
||||
*/
|
||||
this.options = options || {};
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.prototype
|
||||
* @inner
|
||||
*/
|
||||
var BuilderPrototype = Builder.prototype;
|
||||
|
||||
// ----- Definition tests -----
|
||||
|
||||
/**
|
||||
* Tests if a definition most likely describes a message.
|
||||
* @param {!Object} def
|
||||
* @returns {boolean}
|
||||
* @expose
|
||||
*/
|
||||
Builder.isMessage = function(def) {
|
||||
// Messages require a string name
|
||||
if (typeof def["name"] !== 'string')
|
||||
return false;
|
||||
// Messages do not contain values (enum) or rpc methods (service)
|
||||
if (typeof def["values"] !== 'undefined' || typeof def["rpc"] !== 'undefined')
|
||||
return false;
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Tests if a definition most likely describes a message field.
|
||||
* @param {!Object} def
|
||||
* @returns {boolean}
|
||||
* @expose
|
||||
*/
|
||||
Builder.isMessageField = function(def) {
|
||||
// Message fields require a string rule, name and type and an id
|
||||
if (typeof def["rule"] !== 'string' || typeof def["name"] !== 'string' || typeof def["type"] !== 'string' || typeof def["id"] === 'undefined')
|
||||
return false;
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Tests if a definition most likely describes an enum.
|
||||
* @param {!Object} def
|
||||
* @returns {boolean}
|
||||
* @expose
|
||||
*/
|
||||
Builder.isEnum = function(def) {
|
||||
// Enums require a string name
|
||||
if (typeof def["name"] !== 'string')
|
||||
return false;
|
||||
// Enums require at least one value
|
||||
if (typeof def["values"] === 'undefined' || !Array.isArray(def["values"]) || def["values"].length === 0)
|
||||
return false;
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Tests if a definition most likely describes a service.
|
||||
* @param {!Object} def
|
||||
* @returns {boolean}
|
||||
* @expose
|
||||
*/
|
||||
Builder.isService = function(def) {
|
||||
// Services require a string name and an rpc object
|
||||
if (typeof def["name"] !== 'string' || typeof def["rpc"] !== 'object' || !def["rpc"])
|
||||
return false;
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Tests if a definition most likely describes an extended message
|
||||
* @param {!Object} def
|
||||
* @returns {boolean}
|
||||
* @expose
|
||||
*/
|
||||
Builder.isExtend = function(def) {
|
||||
// Extends rquire a string ref
|
||||
if (typeof def["ref"] !== 'string')
|
||||
return false;
|
||||
return true;
|
||||
};
|
||||
|
||||
// ----- Building -----
|
||||
|
||||
/**
|
||||
* Resets the pointer to the root namespace.
|
||||
* @returns {!ProtoBuf.Builder} this
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype.reset = function() {
|
||||
this.ptr = this.ns;
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Defines a namespace on top of the current pointer position and places the pointer on it.
|
||||
* @param {string} namespace
|
||||
* @return {!ProtoBuf.Builder} this
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype.define = function(namespace) {
|
||||
if (typeof namespace !== 'string' || !Lang.TYPEREF.test(namespace))
|
||||
throw Error("illegal namespace: "+namespace);
|
||||
namespace.split(".").forEach(function(part) {
|
||||
var ns = this.ptr.getChild(part);
|
||||
if (ns === null) // Keep existing
|
||||
this.ptr.addChild(ns = new Reflect.Namespace(this, this.ptr, part));
|
||||
this.ptr = ns;
|
||||
}, this);
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates the specified definitions at the current pointer position.
|
||||
* @param {!Array.<!Object>} defs Messages, enums or services to create
|
||||
* @returns {!ProtoBuf.Builder} this
|
||||
* @throws {Error} If a message definition is invalid
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype.create = function(defs) {
|
||||
if (!defs)
|
||||
return this; // Nothing to create
|
||||
if (!Array.isArray(defs))
|
||||
defs = [defs];
|
||||
else {
|
||||
if (defs.length === 0)
|
||||
return this;
|
||||
defs = defs.slice();
|
||||
}
|
||||
|
||||
// It's quite hard to keep track of scopes and memory here, so let's do this iteratively.
|
||||
var stack = [defs];
|
||||
while (stack.length > 0) {
|
||||
defs = stack.pop();
|
||||
|
||||
if (!Array.isArray(defs)) // Stack always contains entire namespaces
|
||||
throw Error("not a valid namespace: "+JSON.stringify(defs));
|
||||
|
||||
while (defs.length > 0) {
|
||||
var def = defs.shift(); // Namespaces always contain an array of messages, enums and services
|
||||
|
||||
if (Builder.isMessage(def)) {
|
||||
var obj = new Reflect.Message(this, this.ptr, def["name"], def["options"], def["isGroup"], def["syntax"]);
|
||||
|
||||
// Create OneOfs
|
||||
var oneofs = {};
|
||||
if (def["oneofs"])
|
||||
Object.keys(def["oneofs"]).forEach(function(name) {
|
||||
obj.addChild(oneofs[name] = new Reflect.Message.OneOf(this, obj, name));
|
||||
}, this);
|
||||
|
||||
// Create fields
|
||||
if (def["fields"])
|
||||
def["fields"].forEach(function(fld) {
|
||||
if (obj.getChild(fld["id"]|0) !== null)
|
||||
throw Error("duplicate or invalid field id in "+obj.name+": "+fld['id']);
|
||||
if (fld["options"] && typeof fld["options"] !== 'object')
|
||||
throw Error("illegal field options in "+obj.name+"#"+fld["name"]);
|
||||
var oneof = null;
|
||||
if (typeof fld["oneof"] === 'string' && !(oneof = oneofs[fld["oneof"]]))
|
||||
throw Error("illegal oneof in "+obj.name+"#"+fld["name"]+": "+fld["oneof"]);
|
||||
fld = new Reflect.Message.Field(this, obj, fld["rule"], fld["keytype"], fld["type"], fld["name"], fld["id"], fld["options"], oneof, def["syntax"]);
|
||||
if (oneof)
|
||||
oneof.fields.push(fld);
|
||||
obj.addChild(fld);
|
||||
}, this);
|
||||
|
||||
// Push children to stack
|
||||
var subObj = [];
|
||||
if (def["enums"])
|
||||
def["enums"].forEach(function(enm) {
|
||||
subObj.push(enm);
|
||||
});
|
||||
if (def["messages"])
|
||||
def["messages"].forEach(function(msg) {
|
||||
subObj.push(msg);
|
||||
});
|
||||
if (def["services"])
|
||||
def["services"].forEach(function(svc) {
|
||||
subObj.push(svc);
|
||||
});
|
||||
|
||||
// Set extension ranges
|
||||
if (def["extensions"]) {
|
||||
if (typeof def["extensions"][0] === 'number') // pre 5.0.1
|
||||
obj.extensions = [ def["extensions"] ];
|
||||
else
|
||||
obj.extensions = def["extensions"];
|
||||
}
|
||||
|
||||
// Create on top of current namespace
|
||||
this.ptr.addChild(obj);
|
||||
if (subObj.length > 0) {
|
||||
stack.push(defs); // Push the current level back
|
||||
defs = subObj; // Continue processing sub level
|
||||
subObj = null;
|
||||
this.ptr = obj; // And move the pointer to this namespace
|
||||
obj = null;
|
||||
continue;
|
||||
}
|
||||
subObj = null;
|
||||
|
||||
} else if (Builder.isEnum(def)) {
|
||||
|
||||
obj = new Reflect.Enum(this, this.ptr, def["name"], def["options"], def["syntax"]);
|
||||
def["values"].forEach(function(val) {
|
||||
obj.addChild(new Reflect.Enum.Value(this, obj, val["name"], val["id"]));
|
||||
}, this);
|
||||
this.ptr.addChild(obj);
|
||||
|
||||
} else if (Builder.isService(def)) {
|
||||
|
||||
obj = new Reflect.Service(this, this.ptr, def["name"], def["options"]);
|
||||
Object.keys(def["rpc"]).forEach(function(name) {
|
||||
var mtd = def["rpc"][name];
|
||||
obj.addChild(new Reflect.Service.RPCMethod(this, obj, name, mtd["request"], mtd["response"], !!mtd["request_stream"], !!mtd["response_stream"], mtd["options"]));
|
||||
}, this);
|
||||
this.ptr.addChild(obj);
|
||||
|
||||
} else if (Builder.isExtend(def)) {
|
||||
|
||||
obj = this.ptr.resolve(def["ref"], true);
|
||||
if (obj) {
|
||||
def["fields"].forEach(function(fld) {
|
||||
if (obj.getChild(fld['id']|0) !== null)
|
||||
throw Error("duplicate extended field id in "+obj.name+": "+fld['id']);
|
||||
// Check if field id is allowed to be extended
|
||||
if (obj.extensions) {
|
||||
var valid = false;
|
||||
obj.extensions.forEach(function(range) {
|
||||
if (fld["id"] >= range[0] && fld["id"] <= range[1])
|
||||
valid = true;
|
||||
});
|
||||
if (!valid)
|
||||
throw Error("illegal extended field id in "+obj.name+": "+fld['id']+" (not within valid ranges)");
|
||||
}
|
||||
// Convert extension field names to camel case notation if the override is set
|
||||
var name = fld["name"];
|
||||
if (this.options['convertFieldsToCamelCase'])
|
||||
name = ProtoBuf.Util.toCamelCase(name);
|
||||
// see #161: Extensions use their fully qualified name as their runtime key and...
|
||||
var field = new Reflect.Message.ExtensionField(this, obj, fld["rule"], fld["type"], this.ptr.fqn()+'.'+name, fld["id"], fld["options"]);
|
||||
// ...are added on top of the current namespace as an extension which is used for
|
||||
// resolving their type later on (the extension always keeps the original name to
|
||||
// prevent naming collisions)
|
||||
var ext = new Reflect.Extension(this, this.ptr, fld["name"], field);
|
||||
field.extension = ext;
|
||||
this.ptr.addChild(ext);
|
||||
obj.addChild(field);
|
||||
}, this);
|
||||
|
||||
} else if (!/\.?google\.protobuf\./.test(def["ref"])) // Silently skip internal extensions
|
||||
throw Error("extended message "+def["ref"]+" is not defined");
|
||||
|
||||
} else
|
||||
throw Error("not a valid definition: "+JSON.stringify(def));
|
||||
|
||||
def = null;
|
||||
obj = null;
|
||||
}
|
||||
// Break goes here
|
||||
defs = null;
|
||||
this.ptr = this.ptr.parent; // Namespace done, continue at parent
|
||||
}
|
||||
this.resolved = false; // Require re-resolve
|
||||
this.result = null; // Require re-build
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Propagates syntax to all children.
|
||||
* @param {!Object} parent
|
||||
* @inner
|
||||
*/
|
||||
function propagateSyntax(parent) {
|
||||
if (parent['messages']) {
|
||||
parent['messages'].forEach(function(child) {
|
||||
child["syntax"] = parent["syntax"];
|
||||
propagateSyntax(child);
|
||||
});
|
||||
}
|
||||
if (parent['enums']) {
|
||||
parent['enums'].forEach(function(child) {
|
||||
child["syntax"] = parent["syntax"];
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Imports another definition into this builder.
|
||||
* @param {Object.<string,*>} json Parsed import
|
||||
* @param {(string|{root: string, file: string})=} filename Imported file name
|
||||
* @returns {!ProtoBuf.Builder} this
|
||||
* @throws {Error} If the definition or file cannot be imported
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype["import"] = function(json, filename) {
|
||||
var delim = '/';
|
||||
|
||||
// Make sure to skip duplicate imports
|
||||
|
||||
if (typeof filename === 'string') {
|
||||
|
||||
if (ProtoBuf.Util.IS_NODE)
|
||||
filename = require("path")['resolve'](filename);
|
||||
if (this.files[filename] === true)
|
||||
return this.reset();
|
||||
this.files[filename] = true;
|
||||
|
||||
} else if (typeof filename === 'object') { // Object with root, file.
|
||||
|
||||
var root = filename.root;
|
||||
if (ProtoBuf.Util.IS_NODE)
|
||||
root = require("path")['resolve'](root);
|
||||
if (root.indexOf("\\") >= 0 || filename.file.indexOf("\\") >= 0)
|
||||
delim = '\\';
|
||||
var fname;
|
||||
if (ProtoBuf.Util.IS_NODE)
|
||||
fname = require("path")['join'](root, filename.file);
|
||||
else
|
||||
fname = root + delim + filename.file;
|
||||
if (this.files[fname] === true)
|
||||
return this.reset();
|
||||
this.files[fname] = true;
|
||||
}
|
||||
|
||||
// Import imports
|
||||
|
||||
if (json['imports'] && json['imports'].length > 0) {
|
||||
var importRoot,
|
||||
resetRoot = false;
|
||||
|
||||
if (typeof filename === 'object') { // If an import root is specified, override
|
||||
|
||||
this.importRoot = filename["root"]; resetRoot = true; // ... and reset afterwards
|
||||
importRoot = this.importRoot;
|
||||
filename = filename["file"];
|
||||
if (importRoot.indexOf("\\") >= 0 || filename.indexOf("\\") >= 0)
|
||||
delim = '\\';
|
||||
|
||||
} else if (typeof filename === 'string') {
|
||||
|
||||
if (this.importRoot) // If import root is overridden, use it
|
||||
importRoot = this.importRoot;
|
||||
else { // Otherwise compute from filename
|
||||
if (filename.indexOf("/") >= 0) { // Unix
|
||||
importRoot = filename.replace(/\/[^\/]*$/, "");
|
||||
if (/* /file.proto */ importRoot === "")
|
||||
importRoot = "/";
|
||||
} else if (filename.indexOf("\\") >= 0) { // Windows
|
||||
importRoot = filename.replace(/\\[^\\]*$/, "");
|
||||
delim = '\\';
|
||||
} else
|
||||
importRoot = ".";
|
||||
}
|
||||
|
||||
} else
|
||||
importRoot = null;
|
||||
|
||||
for (var i=0; i<json['imports'].length; i++) {
|
||||
if (typeof json['imports'][i] === 'string') { // Import file
|
||||
if (!importRoot)
|
||||
throw Error("cannot determine import root");
|
||||
var importFilename = json['imports'][i];
|
||||
if (importFilename === "google/protobuf/descriptor.proto")
|
||||
continue; // Not needed and therefore not used
|
||||
if (ProtoBuf.Util.IS_NODE)
|
||||
importFilename = require("path")['join'](importRoot, importFilename);
|
||||
else
|
||||
importFilename = importRoot + delim + importFilename;
|
||||
if (this.files[importFilename] === true)
|
||||
continue; // Already imported
|
||||
if (/\.proto$/i.test(importFilename) && !ProtoBuf.DotProto) // If this is a light build
|
||||
importFilename = importFilename.replace(/\.proto$/, ".json"); // always load the JSON file
|
||||
var contents = ProtoBuf.Util.fetch(importFilename);
|
||||
if (contents === null)
|
||||
throw Error("failed to import '"+importFilename+"' in '"+filename+"': file not found");
|
||||
if (/\.json$/i.test(importFilename)) // Always possible
|
||||
this["import"](JSON.parse(contents+""), importFilename); // May throw
|
||||
else
|
||||
this["import"](ProtoBuf.DotProto.Parser.parse(contents), importFilename); // May throw
|
||||
} else // Import structure
|
||||
if (!filename)
|
||||
this["import"](json['imports'][i]);
|
||||
else if (/\.(\w+)$/.test(filename)) // With extension: Append _importN to the name portion to make it unique
|
||||
this["import"](json['imports'][i], filename.replace(/^(.+)\.(\w+)$/, function($0, $1, $2) { return $1+"_import"+i+"."+$2; }));
|
||||
else // Without extension: Append _importN to make it unique
|
||||
this["import"](json['imports'][i], filename+"_import"+i);
|
||||
}
|
||||
if (resetRoot) // Reset import root override when all imports are done
|
||||
this.importRoot = null;
|
||||
}
|
||||
|
||||
// Import structures
|
||||
|
||||
if (json['package'])
|
||||
this.define(json['package']);
|
||||
if (json['syntax'])
|
||||
propagateSyntax(json);
|
||||
var base = this.ptr;
|
||||
if (json['options'])
|
||||
Object.keys(json['options']).forEach(function(key) {
|
||||
base.options[key] = json['options'][key];
|
||||
});
|
||||
if (json['messages'])
|
||||
this.create(json['messages']),
|
||||
this.ptr = base;
|
||||
if (json['enums'])
|
||||
this.create(json['enums']),
|
||||
this.ptr = base;
|
||||
if (json['services'])
|
||||
this.create(json['services']),
|
||||
this.ptr = base;
|
||||
if (json['extends'])
|
||||
this.create(json['extends']);
|
||||
|
||||
return this.reset();
|
||||
};
|
||||
|
||||
/**
|
||||
* Resolves all namespace objects.
|
||||
* @throws {Error} If a type cannot be resolved
|
||||
* @returns {!ProtoBuf.Builder} this
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype.resolveAll = function() {
|
||||
// Resolve all reflected objects
|
||||
var res;
|
||||
if (this.ptr == null || typeof this.ptr.type === 'object')
|
||||
return this; // Done (already resolved)
|
||||
|
||||
if (this.ptr instanceof Reflect.Namespace) { // Resolve children
|
||||
|
||||
this.ptr.children.forEach(function(child) {
|
||||
this.ptr = child;
|
||||
this.resolveAll();
|
||||
}, this);
|
||||
|
||||
} else if (this.ptr instanceof Reflect.Message.Field) { // Resolve type
|
||||
|
||||
if (!Lang.TYPE.test(this.ptr.type)) {
|
||||
if (!Lang.TYPEREF.test(this.ptr.type))
|
||||
throw Error("illegal type reference in "+this.ptr.toString(true)+": "+this.ptr.type);
|
||||
res = (this.ptr instanceof Reflect.Message.ExtensionField ? this.ptr.extension.parent : this.ptr.parent).resolve(this.ptr.type, true);
|
||||
if (!res)
|
||||
throw Error("unresolvable type reference in "+this.ptr.toString(true)+": "+this.ptr.type);
|
||||
this.ptr.resolvedType = res;
|
||||
if (res instanceof Reflect.Enum) {
|
||||
this.ptr.type = ProtoBuf.TYPES["enum"];
|
||||
if (this.ptr.syntax === 'proto3' && res.syntax !== 'proto3')
|
||||
throw Error("proto3 message cannot reference proto2 enum");
|
||||
}
|
||||
else if (res instanceof Reflect.Message)
|
||||
this.ptr.type = res.isGroup ? ProtoBuf.TYPES["group"] : ProtoBuf.TYPES["message"];
|
||||
else
|
||||
throw Error("illegal type reference in "+this.ptr.toString(true)+": "+this.ptr.type);
|
||||
} else
|
||||
this.ptr.type = ProtoBuf.TYPES[this.ptr.type];
|
||||
|
||||
// If it's a map field, also resolve the key type. The key type can be only a numeric, string, or bool type
|
||||
// (i.e., no enums or messages), so we don't need to resolve against the current namespace.
|
||||
if (this.ptr.map) {
|
||||
if (!Lang.TYPE.test(this.ptr.keyType))
|
||||
throw Error("illegal key type for map field in "+this.ptr.toString(true)+": "+this.ptr.keyType);
|
||||
this.ptr.keyType = ProtoBuf.TYPES[this.ptr.keyType];
|
||||
}
|
||||
|
||||
// If it's a repeated and packable field then proto3 mandates it should be packed by
|
||||
// default
|
||||
if (
|
||||
this.ptr.syntax === 'proto3' &&
|
||||
this.ptr.repeated && this.ptr.options.packed === undefined &&
|
||||
ProtoBuf.PACKABLE_WIRE_TYPES.indexOf(this.ptr.type.wireType) !== -1
|
||||
) {
|
||||
this.ptr.options.packed = true;
|
||||
}
|
||||
|
||||
} else if (this.ptr instanceof ProtoBuf.Reflect.Service.Method) {
|
||||
|
||||
if (this.ptr instanceof ProtoBuf.Reflect.Service.RPCMethod) {
|
||||
res = this.ptr.parent.resolve(this.ptr.requestName, true);
|
||||
if (!res || !(res instanceof ProtoBuf.Reflect.Message))
|
||||
throw Error("Illegal type reference in "+this.ptr.toString(true)+": "+this.ptr.requestName);
|
||||
this.ptr.resolvedRequestType = res;
|
||||
res = this.ptr.parent.resolve(this.ptr.responseName, true);
|
||||
if (!res || !(res instanceof ProtoBuf.Reflect.Message))
|
||||
throw Error("Illegal type reference in "+this.ptr.toString(true)+": "+this.ptr.responseName);
|
||||
this.ptr.resolvedResponseType = res;
|
||||
} else // Should not happen as nothing else is implemented
|
||||
throw Error("illegal service type in "+this.ptr.toString(true));
|
||||
|
||||
} else if (
|
||||
!(this.ptr instanceof ProtoBuf.Reflect.Message.OneOf) && // Not built
|
||||
!(this.ptr instanceof ProtoBuf.Reflect.Extension) && // Not built
|
||||
!(this.ptr instanceof ProtoBuf.Reflect.Enum.Value) // Built in enum
|
||||
)
|
||||
throw Error("illegal object in namespace: "+typeof(this.ptr)+": "+this.ptr);
|
||||
|
||||
return this.reset();
|
||||
};
|
||||
|
||||
/**
|
||||
* Builds the protocol. This will first try to resolve all definitions and, if this has been successful,
|
||||
* return the built package.
|
||||
* @param {(string|Array.<string>)=} path Specifies what to return. If omitted, the entire namespace will be returned.
|
||||
* @returns {!ProtoBuf.Builder.Message|!Object.<string,*>}
|
||||
* @throws {Error} If a type could not be resolved
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype.build = function(path) {
|
||||
this.reset();
|
||||
if (!this.resolved)
|
||||
this.resolveAll(),
|
||||
this.resolved = true,
|
||||
this.result = null; // Require re-build
|
||||
if (this.result === null) // (Re-)Build
|
||||
this.result = this.ns.build();
|
||||
if (!path)
|
||||
return this.result;
|
||||
var part = typeof path === 'string' ? path.split(".") : path,
|
||||
ptr = this.result; // Build namespace pointer (no hasChild etc.)
|
||||
for (var i=0; i<part.length; i++)
|
||||
if (ptr[part[i]])
|
||||
ptr = ptr[part[i]];
|
||||
else {
|
||||
ptr = null;
|
||||
break;
|
||||
}
|
||||
return ptr;
|
||||
};
|
||||
|
||||
/**
|
||||
* Similar to {@link ProtoBuf.Builder#build}, but looks up the internal reflection descriptor.
|
||||
* @param {string=} path Specifies what to return. If omitted, the entire namespace wiil be returned.
|
||||
* @param {boolean=} excludeNonNamespace Excludes non-namespace types like fields, defaults to `false`
|
||||
* @returns {?ProtoBuf.Reflect.T} Reflection descriptor or `null` if not found
|
||||
*/
|
||||
BuilderPrototype.lookup = function(path, excludeNonNamespace) {
|
||||
return path ? this.ns.resolve(path, excludeNonNamespace) : this.ns;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a string representation of this object.
|
||||
* @return {string} String representation as of "Builder"
|
||||
* @expose
|
||||
*/
|
||||
BuilderPrototype.toString = function() {
|
||||
return "Builder";
|
||||
};
|
||||
|
||||
// ----- Base classes -----
|
||||
// Exist for the sole purpose of being able to "... instanceof ProtoBuf.Builder.Message" etc.
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.Message
|
||||
*/
|
||||
Builder.Message = function() {};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.Enum
|
||||
*/
|
||||
Builder.Enum = function() {};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.Message
|
||||
*/
|
||||
Builder.Service = function() {};
|
||||
|
||||
return Builder;
|
||||
|
||||
})(ProtoBuf, ProtoBuf.Lang, ProtoBuf.Reflect);
|
||||
22
node_modules/protobufjs/src/ProtoBuf/Builder/Enum.js
generated
vendored
Normal file
22
node_modules/protobufjs/src/ProtoBuf/Builder/Enum.js
generated
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
// This file is not included currently and exists for documentation purposes only.
|
||||
|
||||
/*?
|
||||
// --- Scope ------------------
|
||||
// T : Reflect.Enum instance
|
||||
*/
|
||||
|
||||
/**
|
||||
* Constructs a new runtime Enum.
|
||||
* @name ProtoBuf.Builder.Enum
|
||||
* @class Barebone of all runtime enums.
|
||||
* @constructor
|
||||
*/
|
||||
var Enum = function() {
|
||||
ProtoBuf.Builder.Enum.call(this);
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.Enum.prototype
|
||||
* @inner
|
||||
*/
|
||||
var EnumPrototype = Enum.prototype = Object.create(ProtoBuf.Builder.Enum.prototype);
|
||||
721
node_modules/protobufjs/src/ProtoBuf/Builder/Message.js
generated
vendored
Normal file
721
node_modules/protobufjs/src/ProtoBuf/Builder/Message.js
generated
vendored
Normal file
@ -0,0 +1,721 @@
|
||||
/*?
|
||||
// --- Scope ------------------
|
||||
// T : Reflect.Message instance
|
||||
*/
|
||||
var fields = T.getChildren(ProtoBuf.Reflect.Message.Field),
|
||||
oneofs = T.getChildren(ProtoBuf.Reflect.Message.OneOf);
|
||||
|
||||
/**
|
||||
* Constructs a new runtime Message.
|
||||
* @name ProtoBuf.Builder.Message
|
||||
* @class Barebone of all runtime messages.
|
||||
* @param {!Object.<string,*>|string} values Preset values
|
||||
* @param {...string} var_args
|
||||
* @constructor
|
||||
* @throws {Error} If the message cannot be created
|
||||
*/
|
||||
var Message = function(values, var_args) {
|
||||
ProtoBuf.Builder.Message.call(this);
|
||||
|
||||
// Create virtual oneof properties
|
||||
for (var i=0, k=oneofs.length; i<k; ++i)
|
||||
this[oneofs[i].name] = null;
|
||||
// Create fields and set default values
|
||||
for (i=0, k=fields.length; i<k; ++i) {
|
||||
var field = fields[i];
|
||||
this[field.name] =
|
||||
field.repeated ? [] :
|
||||
(field.map ? new ProtoBuf.Map(field) : null);
|
||||
if ((field.required || T.syntax === 'proto3') &&
|
||||
field.defaultValue !== null)
|
||||
this[field.name] = field.defaultValue;
|
||||
}
|
||||
|
||||
if (arguments.length > 0) {
|
||||
var value;
|
||||
// Set field values from a values object
|
||||
if (arguments.length === 1 && values !== null && typeof values === 'object' &&
|
||||
/* not _another_ Message */ (typeof values.encode !== 'function' || values instanceof Message) &&
|
||||
/* not a repeated field */ !Array.isArray(values) &&
|
||||
/* not a Map */ !(values instanceof ProtoBuf.Map) &&
|
||||
/* not a ByteBuffer */ !ByteBuffer.isByteBuffer(values) &&
|
||||
/* not an ArrayBuffer */ !(values instanceof ArrayBuffer) &&
|
||||
/* not a Long */ !(ProtoBuf.Long && values instanceof ProtoBuf.Long)) {
|
||||
this.$set(values);
|
||||
} else // Set field values from arguments, in declaration order
|
||||
for (i=0, k=arguments.length; i<k; ++i)
|
||||
if (typeof (value = arguments[i]) !== 'undefined')
|
||||
this.$set(fields[i].name, value); // May throw
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.Message.prototype
|
||||
* @inner
|
||||
*/
|
||||
var MessagePrototype = Message.prototype = Object.create(ProtoBuf.Builder.Message.prototype);
|
||||
|
||||
/**
|
||||
* Adds a value to a repeated field.
|
||||
* @name ProtoBuf.Builder.Message#add
|
||||
* @function
|
||||
* @param {string} key Field name
|
||||
* @param {*} value Value to add
|
||||
* @param {boolean=} noAssert Whether to assert the value or not (asserts by default)
|
||||
* @returns {!ProtoBuf.Builder.Message} this
|
||||
* @throws {Error} If the value cannot be added
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.add = function(key, value, noAssert) {
|
||||
var field = T._fieldsByName[key];
|
||||
if (!noAssert) {
|
||||
if (!field)
|
||||
throw Error(this+"#"+key+" is undefined");
|
||||
if (!(field instanceof ProtoBuf.Reflect.Message.Field))
|
||||
throw Error(this+"#"+key+" is not a field: "+field.toString(true)); // May throw if it's an enum or embedded message
|
||||
if (!field.repeated)
|
||||
throw Error(this+"#"+key+" is not a repeated field");
|
||||
value = field.verifyValue(value, true);
|
||||
}
|
||||
if (this[key] === null)
|
||||
this[key] = [];
|
||||
this[key].push(value);
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Adds a value to a repeated field. This is an alias for {@link ProtoBuf.Builder.Message#add}.
|
||||
* @name ProtoBuf.Builder.Message#$add
|
||||
* @function
|
||||
* @param {string} key Field name
|
||||
* @param {*} value Value to add
|
||||
* @param {boolean=} noAssert Whether to assert the value or not (asserts by default)
|
||||
* @returns {!ProtoBuf.Builder.Message} this
|
||||
* @throws {Error} If the value cannot be added
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.$add = MessagePrototype.add;
|
||||
|
||||
/**
|
||||
* Sets a field's value.
|
||||
* @name ProtoBuf.Builder.Message#set
|
||||
* @function
|
||||
* @param {string|!Object.<string,*>} keyOrObj String key or plain object holding multiple values
|
||||
* @param {(*|boolean)=} value Value to set if key is a string, otherwise omitted
|
||||
* @param {boolean=} noAssert Whether to not assert for an actual field / proper value type, defaults to `false`
|
||||
* @returns {!ProtoBuf.Builder.Message} this
|
||||
* @throws {Error} If the value cannot be set
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.set = function(keyOrObj, value, noAssert) {
|
||||
if (keyOrObj && typeof keyOrObj === 'object') {
|
||||
noAssert = value;
|
||||
for (var ikey in keyOrObj) {
|
||||
// Check if virtual oneof field - don't set these
|
||||
if (keyOrObj.hasOwnProperty(ikey) && typeof (value = keyOrObj[ikey]) !== 'undefined' && T._oneofsByName[ikey] === undefined)
|
||||
this.$set(ikey, value, noAssert);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
var field = T._fieldsByName[keyOrObj];
|
||||
if (!noAssert) {
|
||||
if (!field)
|
||||
throw Error(this+"#"+keyOrObj+" is not a field: undefined");
|
||||
if (!(field instanceof ProtoBuf.Reflect.Message.Field))
|
||||
throw Error(this+"#"+keyOrObj+" is not a field: "+field.toString(true));
|
||||
this[field.name] = (value = field.verifyValue(value)); // May throw
|
||||
} else
|
||||
this[keyOrObj] = value;
|
||||
if (field && field.oneof) { // Field is part of an OneOf (not a virtual OneOf field)
|
||||
var currentField = this[field.oneof.name]; // Virtual field references currently set field
|
||||
if (value !== null) {
|
||||
if (currentField !== null && currentField !== field.name)
|
||||
this[currentField] = null; // Clear currently set field
|
||||
this[field.oneof.name] = field.name; // Point virtual field at this field
|
||||
} else if (/* value === null && */currentField === keyOrObj)
|
||||
this[field.oneof.name] = null; // Clear virtual field (current field explicitly cleared)
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Sets a field's value. This is an alias for [@link ProtoBuf.Builder.Message#set}.
|
||||
* @name ProtoBuf.Builder.Message#$set
|
||||
* @function
|
||||
* @param {string|!Object.<string,*>} keyOrObj String key or plain object holding multiple values
|
||||
* @param {(*|boolean)=} value Value to set if key is a string, otherwise omitted
|
||||
* @param {boolean=} noAssert Whether to not assert the value, defaults to `false`
|
||||
* @throws {Error} If the value cannot be set
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.$set = MessagePrototype.set;
|
||||
|
||||
/**
|
||||
* Gets a field's value.
|
||||
* @name ProtoBuf.Builder.Message#get
|
||||
* @function
|
||||
* @param {string} key Key
|
||||
* @param {boolean=} noAssert Whether to not assert for an actual field, defaults to `false`
|
||||
* @return {*} Value
|
||||
* @throws {Error} If there is no such field
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.get = function(key, noAssert) {
|
||||
if (noAssert)
|
||||
return this[key];
|
||||
var field = T._fieldsByName[key];
|
||||
if (!field || !(field instanceof ProtoBuf.Reflect.Message.Field))
|
||||
throw Error(this+"#"+key+" is not a field: undefined");
|
||||
if (!(field instanceof ProtoBuf.Reflect.Message.Field))
|
||||
throw Error(this+"#"+key+" is not a field: "+field.toString(true));
|
||||
return this[field.name];
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets a field's value. This is an alias for {@link ProtoBuf.Builder.Message#$get}.
|
||||
* @name ProtoBuf.Builder.Message#$get
|
||||
* @function
|
||||
* @param {string} key Key
|
||||
* @return {*} Value
|
||||
* @throws {Error} If there is no such field
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.$get = MessagePrototype.get;
|
||||
|
||||
// Getters and setters
|
||||
|
||||
for (var i=0; i<fields.length; i++) {
|
||||
var field = fields[i];
|
||||
// no setters for extension fields as these are named by their fqn
|
||||
if (field instanceof ProtoBuf.Reflect.Message.ExtensionField)
|
||||
continue;
|
||||
|
||||
if (T.builder.options['populateAccessors'])
|
||||
(function(field) {
|
||||
// set/get[SomeValue]
|
||||
var Name = field.originalName.replace(/(_[a-zA-Z])/g, function(match) {
|
||||
return match.toUpperCase().replace('_','');
|
||||
});
|
||||
Name = Name.substring(0,1).toUpperCase() + Name.substring(1);
|
||||
|
||||
// set/get_[some_value] FIXME: Do we really need these?
|
||||
var name = field.originalName.replace(/([A-Z])/g, function(match) {
|
||||
return "_"+match;
|
||||
});
|
||||
|
||||
/**
|
||||
* The current field's unbound setter function.
|
||||
* @function
|
||||
* @param {*} value
|
||||
* @param {boolean=} noAssert
|
||||
* @returns {!ProtoBuf.Builder.Message}
|
||||
* @inner
|
||||
*/
|
||||
var setter = function(value, noAssert) {
|
||||
this[field.name] = noAssert ? value : field.verifyValue(value);
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* The current field's unbound getter function.
|
||||
* @function
|
||||
* @returns {*}
|
||||
* @inner
|
||||
*/
|
||||
var getter = function() {
|
||||
return this[field.name];
|
||||
};
|
||||
|
||||
if (T.getChild("set"+Name) === null)
|
||||
/**
|
||||
* Sets a value. This method is present for each field, but only if there is no name conflict with
|
||||
* another field.
|
||||
* @name ProtoBuf.Builder.Message#set[SomeField]
|
||||
* @function
|
||||
* @param {*} value Value to set
|
||||
* @param {boolean=} noAssert Whether to not assert the value, defaults to `false`
|
||||
* @returns {!ProtoBuf.Builder.Message} this
|
||||
* @abstract
|
||||
* @throws {Error} If the value cannot be set
|
||||
*/
|
||||
MessagePrototype["set"+Name] = setter;
|
||||
|
||||
if (T.getChild("set_"+name) === null)
|
||||
/**
|
||||
* Sets a value. This method is present for each field, but only if there is no name conflict with
|
||||
* another field.
|
||||
* @name ProtoBuf.Builder.Message#set_[some_field]
|
||||
* @function
|
||||
* @param {*} value Value to set
|
||||
* @param {boolean=} noAssert Whether to not assert the value, defaults to `false`
|
||||
* @returns {!ProtoBuf.Builder.Message} this
|
||||
* @abstract
|
||||
* @throws {Error} If the value cannot be set
|
||||
*/
|
||||
MessagePrototype["set_"+name] = setter;
|
||||
|
||||
if (T.getChild("get"+Name) === null)
|
||||
/**
|
||||
* Gets a value. This method is present for each field, but only if there is no name conflict with
|
||||
* another field.
|
||||
* @name ProtoBuf.Builder.Message#get[SomeField]
|
||||
* @function
|
||||
* @abstract
|
||||
* @return {*} The value
|
||||
*/
|
||||
MessagePrototype["get"+Name] = getter;
|
||||
|
||||
if (T.getChild("get_"+name) === null)
|
||||
/**
|
||||
* Gets a value. This method is present for each field, but only if there is no name conflict with
|
||||
* another field.
|
||||
* @name ProtoBuf.Builder.Message#get_[some_field]
|
||||
* @function
|
||||
* @return {*} The value
|
||||
* @abstract
|
||||
*/
|
||||
MessagePrototype["get_"+name] = getter;
|
||||
|
||||
})(field);
|
||||
}
|
||||
|
||||
// En-/decoding
|
||||
|
||||
/**
|
||||
* Encodes the message.
|
||||
* @name ProtoBuf.Builder.Message#$encode
|
||||
* @function
|
||||
* @param {(!ByteBuffer|boolean)=} buffer ByteBuffer to encode to. Will create a new one and flip it if omitted.
|
||||
* @param {boolean=} noVerify Whether to not verify field values, defaults to `false`
|
||||
* @return {!ByteBuffer} Encoded message as a ByteBuffer
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded ByteBuffer in the `encoded` property on the error.
|
||||
* @expose
|
||||
* @see ProtoBuf.Builder.Message#encode64
|
||||
* @see ProtoBuf.Builder.Message#encodeHex
|
||||
* @see ProtoBuf.Builder.Message#encodeAB
|
||||
*/
|
||||
MessagePrototype.encode = function(buffer, noVerify) {
|
||||
if (typeof buffer === 'boolean')
|
||||
noVerify = buffer,
|
||||
buffer = undefined;
|
||||
var isNew = false;
|
||||
if (!buffer)
|
||||
buffer = new ByteBuffer(),
|
||||
isNew = true;
|
||||
var le = buffer.littleEndian;
|
||||
try {
|
||||
T.encode(this, buffer.LE(), noVerify);
|
||||
return (isNew ? buffer.flip() : buffer).LE(le);
|
||||
} catch (e) {
|
||||
buffer.LE(le);
|
||||
throw(e);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Encodes a message using the specified data payload.
|
||||
* @param {!Object.<string,*>} data Data payload
|
||||
* @param {(!ByteBuffer|boolean)=} buffer ByteBuffer to encode to. Will create a new one and flip it if omitted.
|
||||
* @param {boolean=} noVerify Whether to not verify field values, defaults to `false`
|
||||
* @return {!ByteBuffer} Encoded message as a ByteBuffer
|
||||
* @expose
|
||||
*/
|
||||
Message.encode = function(data, buffer, noVerify) {
|
||||
return new Message(data).encode(buffer, noVerify);
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculates the byte length of the message.
|
||||
* @name ProtoBuf.Builder.Message#calculate
|
||||
* @function
|
||||
* @returns {number} Byte length
|
||||
* @throws {Error} If the message cannot be calculated or if required fields are missing.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.calculate = function() {
|
||||
return T.calculate(this);
|
||||
};
|
||||
|
||||
/**
|
||||
* Encodes the varint32 length-delimited message.
|
||||
* @name ProtoBuf.Builder.Message#encodeDelimited
|
||||
* @function
|
||||
* @param {(!ByteBuffer|boolean)=} buffer ByteBuffer to encode to. Will create a new one and flip it if omitted.
|
||||
* @param {boolean=} noVerify Whether to not verify field values, defaults to `false`
|
||||
* @return {!ByteBuffer} Encoded message as a ByteBuffer
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded ByteBuffer in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encodeDelimited = function(buffer, noVerify) {
|
||||
var isNew = false;
|
||||
if (!buffer)
|
||||
buffer = new ByteBuffer(),
|
||||
isNew = true;
|
||||
var enc = new ByteBuffer().LE();
|
||||
T.encode(this, enc, noVerify).flip();
|
||||
buffer.writeVarint32(enc.remaining());
|
||||
buffer.append(enc);
|
||||
return isNew ? buffer.flip() : buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Directly encodes the message to an ArrayBuffer.
|
||||
* @name ProtoBuf.Builder.Message#encodeAB
|
||||
* @function
|
||||
* @return {ArrayBuffer} Encoded message as ArrayBuffer
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded ArrayBuffer in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encodeAB = function() {
|
||||
try {
|
||||
return this.encode().toArrayBuffer();
|
||||
} catch (e) {
|
||||
if (e["encoded"]) e["encoded"] = e["encoded"].toArrayBuffer();
|
||||
throw(e);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the message as an ArrayBuffer. This is an alias for {@link ProtoBuf.Builder.Message#encodeAB}.
|
||||
* @name ProtoBuf.Builder.Message#toArrayBuffer
|
||||
* @function
|
||||
* @return {ArrayBuffer} Encoded message as ArrayBuffer
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded ArrayBuffer in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.toArrayBuffer = MessagePrototype.encodeAB;
|
||||
|
||||
/**
|
||||
* Directly encodes the message to a node Buffer.
|
||||
* @name ProtoBuf.Builder.Message#encodeNB
|
||||
* @function
|
||||
* @return {!Buffer}
|
||||
* @throws {Error} If the message cannot be encoded, not running under node.js or if required fields are
|
||||
* missing. The later still returns the encoded node Buffer in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encodeNB = function() {
|
||||
try {
|
||||
return this.encode().toBuffer();
|
||||
} catch (e) {
|
||||
if (e["encoded"]) e["encoded"] = e["encoded"].toBuffer();
|
||||
throw(e);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the message as a node Buffer. This is an alias for {@link ProtoBuf.Builder.Message#encodeNB}.
|
||||
* @name ProtoBuf.Builder.Message#toBuffer
|
||||
* @function
|
||||
* @return {!Buffer}
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded node Buffer in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.toBuffer = MessagePrototype.encodeNB;
|
||||
|
||||
/**
|
||||
* Directly encodes the message to a base64 encoded string.
|
||||
* @name ProtoBuf.Builder.Message#encode64
|
||||
* @function
|
||||
* @return {string} Base64 encoded string
|
||||
* @throws {Error} If the underlying buffer cannot be encoded or if required fields are missing. The later
|
||||
* still returns the encoded base64 string in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encode64 = function() {
|
||||
try {
|
||||
return this.encode().toBase64();
|
||||
} catch (e) {
|
||||
if (e["encoded"]) e["encoded"] = e["encoded"].toBase64();
|
||||
throw(e);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the message as a base64 encoded string. This is an alias for {@link ProtoBuf.Builder.Message#encode64}.
|
||||
* @name ProtoBuf.Builder.Message#toBase64
|
||||
* @function
|
||||
* @return {string} Base64 encoded string
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded base64 string in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.toBase64 = MessagePrototype.encode64;
|
||||
|
||||
/**
|
||||
* Directly encodes the message to a hex encoded string.
|
||||
* @name ProtoBuf.Builder.Message#encodeHex
|
||||
* @function
|
||||
* @return {string} Hex encoded string
|
||||
* @throws {Error} If the underlying buffer cannot be encoded or if required fields are missing. The later
|
||||
* still returns the encoded hex string in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encodeHex = function() {
|
||||
try {
|
||||
return this.encode().toHex();
|
||||
} catch (e) {
|
||||
if (e["encoded"]) e["encoded"] = e["encoded"].toHex();
|
||||
throw(e);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the message as a hex encoded string. This is an alias for {@link ProtoBuf.Builder.Message#encodeHex}.
|
||||
* @name ProtoBuf.Builder.Message#toHex
|
||||
* @function
|
||||
* @return {string} Hex encoded string
|
||||
* @throws {Error} If the message cannot be encoded or if required fields are missing. The later still
|
||||
* returns the encoded hex string in the `encoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.toHex = MessagePrototype.encodeHex;
|
||||
|
||||
/**
|
||||
* Clones a message object or field value to a raw object.
|
||||
* @param {*} obj Object to clone
|
||||
* @param {boolean} binaryAsBase64 Whether to include binary data as base64 strings or as a buffer otherwise
|
||||
* @param {boolean} longsAsStrings Whether to encode longs as strings
|
||||
* @param {!ProtoBuf.Reflect.T=} resolvedType The resolved field type if a field
|
||||
* @returns {*} Cloned object
|
||||
* @inner
|
||||
*/
|
||||
function cloneRaw(obj, binaryAsBase64, longsAsStrings, resolvedType) {
|
||||
if (obj === null || typeof obj !== 'object') {
|
||||
// Convert enum values to their respective names
|
||||
if (resolvedType && resolvedType instanceof ProtoBuf.Reflect.Enum) {
|
||||
var name = ProtoBuf.Reflect.Enum.getName(resolvedType.object, obj);
|
||||
if (name !== null)
|
||||
return name;
|
||||
}
|
||||
// Pass-through string, number, boolean, null...
|
||||
return obj;
|
||||
}
|
||||
// Convert ByteBuffers to raw buffer or strings
|
||||
if (ByteBuffer.isByteBuffer(obj))
|
||||
return binaryAsBase64 ? obj.toBase64() : obj.toBuffer();
|
||||
// Convert Longs to proper objects or strings
|
||||
if (ProtoBuf.Long.isLong(obj))
|
||||
return longsAsStrings ? obj.toString() : ProtoBuf.Long.fromValue(obj);
|
||||
var clone;
|
||||
// Clone arrays
|
||||
if (Array.isArray(obj)) {
|
||||
clone = [];
|
||||
obj.forEach(function(v, k) {
|
||||
clone[k] = cloneRaw(v, binaryAsBase64, longsAsStrings, resolvedType);
|
||||
});
|
||||
return clone;
|
||||
}
|
||||
clone = {};
|
||||
// Convert maps to objects
|
||||
if (obj instanceof ProtoBuf.Map) {
|
||||
var it = obj.entries();
|
||||
for (var e = it.next(); !e.done; e = it.next())
|
||||
clone[obj.keyElem.valueToString(e.value[0])] = cloneRaw(e.value[1], binaryAsBase64, longsAsStrings, obj.valueElem.resolvedType);
|
||||
return clone;
|
||||
}
|
||||
// Everything else is a non-null object
|
||||
var type = obj.$type,
|
||||
field = undefined;
|
||||
for (var i in obj)
|
||||
if (obj.hasOwnProperty(i)) {
|
||||
if (type && (field = type.getChild(i)))
|
||||
clone[i] = cloneRaw(obj[i], binaryAsBase64, longsAsStrings, field.resolvedType);
|
||||
else
|
||||
clone[i] = cloneRaw(obj[i], binaryAsBase64, longsAsStrings);
|
||||
}
|
||||
return clone;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the message's raw payload.
|
||||
* @param {boolean=} binaryAsBase64 Whether to include binary data as base64 strings instead of Buffers, defaults to `false`
|
||||
* @param {boolean} longsAsStrings Whether to encode longs as strings
|
||||
* @returns {Object.<string,*>} Raw payload
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.toRaw = function(binaryAsBase64, longsAsStrings) {
|
||||
return cloneRaw(this, !!binaryAsBase64, !!longsAsStrings, this.$type);
|
||||
};
|
||||
|
||||
/**
|
||||
* Encodes a message to JSON.
|
||||
* @returns {string} JSON string
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encodeJSON = function() {
|
||||
return JSON.stringify(
|
||||
cloneRaw(this,
|
||||
/* binary-as-base64 */ true,
|
||||
/* longs-as-strings */ true,
|
||||
this.$type
|
||||
)
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Decodes a message from the specified buffer or string.
|
||||
* @name ProtoBuf.Builder.Message.decode
|
||||
* @function
|
||||
* @param {!ByteBuffer|!ArrayBuffer|!Buffer|string} buffer Buffer to decode from
|
||||
* @param {(number|string)=} length Message length. Defaults to decode all the remainig data.
|
||||
* @param {string=} enc Encoding if buffer is a string: hex, utf8 (not recommended), defaults to base64
|
||||
* @return {!ProtoBuf.Builder.Message} Decoded message
|
||||
* @throws {Error} If the message cannot be decoded or if required fields are missing. The later still
|
||||
* returns the decoded message with missing fields in the `decoded` property on the error.
|
||||
* @expose
|
||||
* @see ProtoBuf.Builder.Message.decode64
|
||||
* @see ProtoBuf.Builder.Message.decodeHex
|
||||
*/
|
||||
Message.decode = function(buffer, length, enc) {
|
||||
if (typeof length === 'string')
|
||||
enc = length,
|
||||
length = -1;
|
||||
if (typeof buffer === 'string')
|
||||
buffer = ByteBuffer.wrap(buffer, enc ? enc : "base64");
|
||||
else if (!ByteBuffer.isByteBuffer(buffer))
|
||||
buffer = ByteBuffer.wrap(buffer); // May throw
|
||||
var le = buffer.littleEndian;
|
||||
try {
|
||||
var msg = T.decode(buffer.LE(), length);
|
||||
buffer.LE(le);
|
||||
return msg;
|
||||
} catch (e) {
|
||||
buffer.LE(le);
|
||||
throw(e);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Decodes a varint32 length-delimited message from the specified buffer or string.
|
||||
* @name ProtoBuf.Builder.Message.decodeDelimited
|
||||
* @function
|
||||
* @param {!ByteBuffer|!ArrayBuffer|!Buffer|string} buffer Buffer to decode from
|
||||
* @param {string=} enc Encoding if buffer is a string: hex, utf8 (not recommended), defaults to base64
|
||||
* @return {ProtoBuf.Builder.Message} Decoded message or `null` if not enough bytes are available yet
|
||||
* @throws {Error} If the message cannot be decoded or if required fields are missing. The later still
|
||||
* returns the decoded message with missing fields in the `decoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
Message.decodeDelimited = function(buffer, enc) {
|
||||
if (typeof buffer === 'string')
|
||||
buffer = ByteBuffer.wrap(buffer, enc ? enc : "base64");
|
||||
else if (!ByteBuffer.isByteBuffer(buffer))
|
||||
buffer = ByteBuffer.wrap(buffer); // May throw
|
||||
if (buffer.remaining() < 1)
|
||||
return null;
|
||||
var off = buffer.offset,
|
||||
len = buffer.readVarint32();
|
||||
if (buffer.remaining() < len) {
|
||||
buffer.offset = off;
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
var msg = T.decode(buffer.slice(buffer.offset, buffer.offset + len).LE());
|
||||
buffer.offset += len;
|
||||
return msg;
|
||||
} catch (err) {
|
||||
buffer.offset += len;
|
||||
throw err;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Decodes the message from the specified base64 encoded string.
|
||||
* @name ProtoBuf.Builder.Message.decode64
|
||||
* @function
|
||||
* @param {string} str String to decode from
|
||||
* @return {!ProtoBuf.Builder.Message} Decoded message
|
||||
* @throws {Error} If the message cannot be decoded or if required fields are missing. The later still
|
||||
* returns the decoded message with missing fields in the `decoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
Message.decode64 = function(str) {
|
||||
return Message.decode(str, "base64");
|
||||
};
|
||||
|
||||
/**
|
||||
* Decodes the message from the specified hex encoded string.
|
||||
* @name ProtoBuf.Builder.Message.decodeHex
|
||||
* @function
|
||||
* @param {string} str String to decode from
|
||||
* @return {!ProtoBuf.Builder.Message} Decoded message
|
||||
* @throws {Error} If the message cannot be decoded or if required fields are missing. The later still
|
||||
* returns the decoded message with missing fields in the `decoded` property on the error.
|
||||
* @expose
|
||||
*/
|
||||
Message.decodeHex = function(str) {
|
||||
return Message.decode(str, "hex");
|
||||
};
|
||||
|
||||
/**
|
||||
* Decodes the message from a JSON string.
|
||||
* @name ProtoBuf.Builder.Message.decodeJSON
|
||||
* @function
|
||||
* @param {string} str String to decode from
|
||||
* @return {!ProtoBuf.Builder.Message} Decoded message
|
||||
* @throws {Error} If the message cannot be decoded or if required fields are
|
||||
* missing.
|
||||
* @expose
|
||||
*/
|
||||
Message.decodeJSON = function(str) {
|
||||
return new Message(JSON.parse(str));
|
||||
};
|
||||
|
||||
// Utility
|
||||
|
||||
/**
|
||||
* Returns a string representation of this Message.
|
||||
* @name ProtoBuf.Builder.Message#toString
|
||||
* @function
|
||||
* @return {string} String representation as of ".Fully.Qualified.MessageName"
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.toString = function() {
|
||||
return T.toString();
|
||||
};
|
||||
|
||||
// Properties
|
||||
|
||||
/**
|
||||
* Message options.
|
||||
* @name ProtoBuf.Builder.Message.$options
|
||||
* @type {Object.<string,*>}
|
||||
* @expose
|
||||
*/
|
||||
var $optionsS; // cc needs this
|
||||
|
||||
/**
|
||||
* Message options.
|
||||
* @name ProtoBuf.Builder.Message#$options
|
||||
* @type {Object.<string,*>}
|
||||
* @expose
|
||||
*/
|
||||
var $options;
|
||||
|
||||
/**
|
||||
* Reflection type.
|
||||
* @name ProtoBuf.Builder.Message.$type
|
||||
* @type {!ProtoBuf.Reflect.Message}
|
||||
* @expose
|
||||
*/
|
||||
var $typeS;
|
||||
|
||||
/**
|
||||
* Reflection type.
|
||||
* @name ProtoBuf.Builder.Message#$type
|
||||
* @type {!ProtoBuf.Reflect.Message}
|
||||
* @expose
|
||||
*/
|
||||
var $type;
|
||||
|
||||
if (Object.defineProperty)
|
||||
Object.defineProperty(Message, '$options', { "value": T.buildOpt() }),
|
||||
Object.defineProperty(MessagePrototype, "$options", { "value": Message["$options"] }),
|
||||
Object.defineProperty(Message, "$type", { "value": T }),
|
||||
Object.defineProperty(MessagePrototype, "$type", { "value": T });
|
||||
144
node_modules/protobufjs/src/ProtoBuf/Builder/Service.js
generated
vendored
Normal file
144
node_modules/protobufjs/src/ProtoBuf/Builder/Service.js
generated
vendored
Normal file
@ -0,0 +1,144 @@
|
||||
/*?
|
||||
// --- Scope ------------------
|
||||
// T : Reflect.Service instance
|
||||
*/
|
||||
/**
|
||||
* Constructs a new runtime Service.
|
||||
* @name ProtoBuf.Builder.Service
|
||||
* @param {function(string, ProtoBuf.Builder.Message, function(Error, ProtoBuf.Builder.Message=))=} rpcImpl RPC implementation receiving the method name and the message
|
||||
* @class Barebone of all runtime services.
|
||||
* @constructor
|
||||
* @throws {Error} If the service cannot be created
|
||||
*/
|
||||
var Service = function(rpcImpl) {
|
||||
ProtoBuf.Builder.Service.call(this);
|
||||
|
||||
/**
|
||||
* Service implementation.
|
||||
* @name ProtoBuf.Builder.Service#rpcImpl
|
||||
* @type {!function(string, ProtoBuf.Builder.Message, function(Error, ProtoBuf.Builder.Message=))}
|
||||
* @expose
|
||||
*/
|
||||
this.rpcImpl = rpcImpl || function(name, msg, callback) {
|
||||
// This is what a user has to implement: A function receiving the method name, the actual message to
|
||||
// send (type checked) and the callback that's either provided with the error as its first
|
||||
// argument or null and the actual response message.
|
||||
setTimeout(callback.bind(this, Error("Not implemented, see: https://github.com/dcodeIO/ProtoBuf.js/wiki/Services")), 0); // Must be async!
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Builder.Service.prototype
|
||||
* @inner
|
||||
*/
|
||||
var ServicePrototype = Service.prototype = Object.create(ProtoBuf.Builder.Service.prototype);
|
||||
|
||||
/**
|
||||
* Asynchronously performs an RPC call using the given RPC implementation.
|
||||
* @name ProtoBuf.Builder.Service.[Method]
|
||||
* @function
|
||||
* @param {!function(string, ProtoBuf.Builder.Message, function(Error, ProtoBuf.Builder.Message=))} rpcImpl RPC implementation
|
||||
* @param {ProtoBuf.Builder.Message} req Request
|
||||
* @param {function(Error, (ProtoBuf.Builder.Message|ByteBuffer|Buffer|string)=)} callback Callback receiving
|
||||
* the error if any and the response either as a pre-parsed message or as its raw bytes
|
||||
* @abstract
|
||||
*/
|
||||
|
||||
/**
|
||||
* Asynchronously performs an RPC call using the instance's RPC implementation.
|
||||
* @name ProtoBuf.Builder.Service#[Method]
|
||||
* @function
|
||||
* @param {ProtoBuf.Builder.Message} req Request
|
||||
* @param {function(Error, (ProtoBuf.Builder.Message|ByteBuffer|Buffer|string)=)} callback Callback receiving
|
||||
* the error if any and the response either as a pre-parsed message or as its raw bytes
|
||||
* @abstract
|
||||
*/
|
||||
|
||||
var rpc = T.getChildren(ProtoBuf.Reflect.Service.RPCMethod);
|
||||
for (var i=0; i<rpc.length; i++) {
|
||||
(function(method) {
|
||||
|
||||
// service#Method(message, callback)
|
||||
ServicePrototype[method.name] = function(req, callback) {
|
||||
try {
|
||||
try {
|
||||
// If given as a buffer, decode the request. Will throw a TypeError if not a valid buffer.
|
||||
req = method.resolvedRequestType.clazz.decode(ByteBuffer.wrap(req));
|
||||
} catch (err) {
|
||||
if (!(err instanceof TypeError))
|
||||
throw err;
|
||||
}
|
||||
if (req === null || typeof req !== 'object')
|
||||
throw Error("Illegal arguments");
|
||||
if (!(req instanceof method.resolvedRequestType.clazz))
|
||||
req = new method.resolvedRequestType.clazz(req);
|
||||
this.rpcImpl(method.fqn(), req, function(err, res) { // Assumes that this is properly async
|
||||
if (err) {
|
||||
callback(err);
|
||||
return;
|
||||
}
|
||||
// Coalesce to empty string when service response has empty content
|
||||
if (res === null)
|
||||
res = ''
|
||||
try { res = method.resolvedResponseType.clazz.decode(res); } catch (notABuffer) {}
|
||||
if (!res || !(res instanceof method.resolvedResponseType.clazz)) {
|
||||
callback(Error("Illegal response type received in service method "+ T.name+"#"+method.name));
|
||||
return;
|
||||
}
|
||||
callback(null, res);
|
||||
});
|
||||
} catch (err) {
|
||||
setTimeout(callback.bind(this, err), 0);
|
||||
}
|
||||
};
|
||||
|
||||
// Service.Method(rpcImpl, message, callback)
|
||||
Service[method.name] = function(rpcImpl, req, callback) {
|
||||
new Service(rpcImpl)[method.name](req, callback);
|
||||
};
|
||||
|
||||
if (Object.defineProperty)
|
||||
Object.defineProperty(Service[method.name], "$options", { "value": method.buildOpt() }),
|
||||
Object.defineProperty(ServicePrototype[method.name], "$options", { "value": Service[method.name]["$options"] });
|
||||
})(rpc[i]);
|
||||
}
|
||||
|
||||
// Properties
|
||||
|
||||
/**
|
||||
* Service options.
|
||||
* @name ProtoBuf.Builder.Service.$options
|
||||
* @type {Object.<string,*>}
|
||||
* @expose
|
||||
*/
|
||||
var $optionsS; // cc needs this
|
||||
|
||||
/**
|
||||
* Service options.
|
||||
* @name ProtoBuf.Builder.Service#$options
|
||||
* @type {Object.<string,*>}
|
||||
* @expose
|
||||
*/
|
||||
var $options;
|
||||
|
||||
/**
|
||||
* Reflection type.
|
||||
* @name ProtoBuf.Builder.Service.$type
|
||||
* @type {!ProtoBuf.Reflect.Service}
|
||||
* @expose
|
||||
*/
|
||||
var $typeS;
|
||||
|
||||
/**
|
||||
* Reflection type.
|
||||
* @name ProtoBuf.Builder.Service#$type
|
||||
* @type {!ProtoBuf.Reflect.Service}
|
||||
* @expose
|
||||
*/
|
||||
var $type;
|
||||
|
||||
if (Object.defineProperty)
|
||||
Object.defineProperty(Service, "$options", { "value": T.buildOpt() }),
|
||||
Object.defineProperty(ServicePrototype, "$options", { "value": Service["$options"] }),
|
||||
Object.defineProperty(Service, "$type", { "value": T }),
|
||||
Object.defineProperty(ServicePrototype, "$type", { "value": T });
|
||||
33
node_modules/protobufjs/src/ProtoBuf/DotProto.js
generated
vendored
Normal file
33
node_modules/protobufjs/src/ProtoBuf/DotProto.js
generated
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
/**
|
||||
* @alias ProtoBuf.DotProto
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.DotProto = (function(ProtoBuf, Lang) {
|
||||
"use strict";
|
||||
|
||||
/**
|
||||
* Utilities to parse .proto files.
|
||||
* @exports ProtoBuf.DotProto
|
||||
* @namespace
|
||||
*/
|
||||
var DotProto = {};
|
||||
|
||||
//? include("DotProto/Tokenizer.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.DotProto.Tokenizer
|
||||
* @expose
|
||||
*/
|
||||
DotProto.Tokenizer = Tokenizer;
|
||||
|
||||
//? include("DotProto/Parser.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.DotProto.Parser
|
||||
* @expose
|
||||
*/
|
||||
DotProto.Parser = Parser;
|
||||
|
||||
return DotProto;
|
||||
|
||||
})(ProtoBuf, ProtoBuf.Lang);
|
||||
700
node_modules/protobufjs/src/ProtoBuf/DotProto/Parser.js
generated
vendored
Normal file
700
node_modules/protobufjs/src/ProtoBuf/DotProto/Parser.js
generated
vendored
Normal file
@ -0,0 +1,700 @@
|
||||
/*?
|
||||
// --- Scope ----------------------
|
||||
// Lang : Language expressions
|
||||
// Tokenizer : DotProto Tokenizer
|
||||
*/
|
||||
/**
|
||||
* Constructs a new Parser.
|
||||
* @exports ProtoBuf.DotProto.Parser
|
||||
* @class prototype parser
|
||||
* @param {string} source Source
|
||||
* @constructor
|
||||
*/
|
||||
var Parser = function(source) {
|
||||
|
||||
/**
|
||||
* Tokenizer.
|
||||
* @type {!ProtoBuf.DotProto.Tokenizer}
|
||||
* @expose
|
||||
*/
|
||||
this.tn = new Tokenizer(source);
|
||||
|
||||
/**
|
||||
* Whether parsing proto3 or not.
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.proto3 = false;
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.DotProto.Parser.prototype
|
||||
* @inner
|
||||
*/
|
||||
var ParserPrototype = Parser.prototype;
|
||||
|
||||
/**
|
||||
* Parses the source.
|
||||
* @returns {!Object}
|
||||
* @throws {Error} If the source cannot be parsed
|
||||
* @expose
|
||||
*/
|
||||
ParserPrototype.parse = function() {
|
||||
var topLevel = {
|
||||
"name": "[ROOT]", // temporary
|
||||
"package": null,
|
||||
"messages": [],
|
||||
"enums": [],
|
||||
"imports": [],
|
||||
"options": {},
|
||||
"services": []
|
||||
// "syntax": undefined
|
||||
};
|
||||
var token,
|
||||
head = true,
|
||||
weak;
|
||||
try {
|
||||
while (token = this.tn.next()) {
|
||||
switch (token) {
|
||||
case 'package':
|
||||
if (!head || topLevel["package"] !== null)
|
||||
throw Error("unexpected 'package'");
|
||||
token = this.tn.next();
|
||||
if (!Lang.TYPEREF.test(token))
|
||||
throw Error("illegal package name: " + token);
|
||||
this.tn.skip(";");
|
||||
topLevel["package"] = token;
|
||||
break;
|
||||
case 'import':
|
||||
if (!head)
|
||||
throw Error("unexpected 'import'");
|
||||
token = this.tn.peek();
|
||||
if (token === "public" || (weak = token === "weak")) // token ignored
|
||||
this.tn.next();
|
||||
token = this._readString();
|
||||
this.tn.skip(";");
|
||||
if (!weak) // import ignored
|
||||
topLevel["imports"].push(token);
|
||||
break;
|
||||
case 'syntax':
|
||||
if (!head)
|
||||
throw Error("unexpected 'syntax'");
|
||||
this.tn.skip("=");
|
||||
if ((topLevel["syntax"] = this._readString()) === "proto3")
|
||||
this.proto3 = true;
|
||||
this.tn.skip(";");
|
||||
break;
|
||||
case 'message':
|
||||
this._parseMessage(topLevel, null);
|
||||
head = false;
|
||||
break;
|
||||
case 'enum':
|
||||
this._parseEnum(topLevel);
|
||||
head = false;
|
||||
break;
|
||||
case 'option':
|
||||
this._parseOption(topLevel);
|
||||
break;
|
||||
case 'service':
|
||||
this._parseService(topLevel);
|
||||
break;
|
||||
case 'extend':
|
||||
this._parseExtend(topLevel);
|
||||
break;
|
||||
default:
|
||||
throw Error("unexpected '" + token + "'");
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
e.message = "Parse error at line "+this.tn.line+": " + e.message;
|
||||
throw e;
|
||||
}
|
||||
delete topLevel["name"];
|
||||
return topLevel;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses the specified source.
|
||||
* @returns {!Object}
|
||||
* @throws {Error} If the source cannot be parsed
|
||||
* @expose
|
||||
*/
|
||||
Parser.parse = function(source) {
|
||||
return new Parser(source).parse();
|
||||
};
|
||||
|
||||
// ----- Conversion ------
|
||||
|
||||
/**
|
||||
* Converts a numerical string to an id.
|
||||
* @param {string} value
|
||||
* @param {boolean=} mayBeNegative
|
||||
* @returns {number}
|
||||
* @inner
|
||||
*/
|
||||
function mkId(value, mayBeNegative) {
|
||||
var id = -1,
|
||||
sign = 1;
|
||||
if (value.charAt(0) == '-') {
|
||||
sign = -1;
|
||||
value = value.substring(1);
|
||||
}
|
||||
if (Lang.NUMBER_DEC.test(value))
|
||||
id = parseInt(value);
|
||||
else if (Lang.NUMBER_HEX.test(value))
|
||||
id = parseInt(value.substring(2), 16);
|
||||
else if (Lang.NUMBER_OCT.test(value))
|
||||
id = parseInt(value.substring(1), 8);
|
||||
else
|
||||
throw Error("illegal id value: " + (sign < 0 ? '-' : '') + value);
|
||||
id = (sign*id)|0; // Force to 32bit
|
||||
if (!mayBeNegative && id < 0)
|
||||
throw Error("illegal id value: " + (sign < 0 ? '-' : '') + value);
|
||||
return id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts a numerical string to a number.
|
||||
* @param {string} val
|
||||
* @returns {number}
|
||||
* @inner
|
||||
*/
|
||||
function mkNumber(val) {
|
||||
var sign = 1;
|
||||
if (val.charAt(0) == '-') {
|
||||
sign = -1;
|
||||
val = val.substring(1);
|
||||
}
|
||||
if (Lang.NUMBER_DEC.test(val))
|
||||
return sign * parseInt(val, 10);
|
||||
else if (Lang.NUMBER_HEX.test(val))
|
||||
return sign * parseInt(val.substring(2), 16);
|
||||
else if (Lang.NUMBER_OCT.test(val))
|
||||
return sign * parseInt(val.substring(1), 8);
|
||||
else if (val === 'inf')
|
||||
return sign * Infinity;
|
||||
else if (val === 'nan')
|
||||
return NaN;
|
||||
else if (Lang.NUMBER_FLT.test(val))
|
||||
return sign * parseFloat(val);
|
||||
throw Error("illegal number value: " + (sign < 0 ? '-' : '') + val);
|
||||
}
|
||||
|
||||
// ----- Reading ------
|
||||
|
||||
/**
|
||||
* Reads a string.
|
||||
* @returns {string}
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._readString = function() {
|
||||
var value = "",
|
||||
token,
|
||||
delim;
|
||||
do {
|
||||
delim = this.tn.next();
|
||||
if (delim !== "'" && delim !== '"')
|
||||
throw Error("illegal string delimiter: "+delim);
|
||||
value += this.tn.next();
|
||||
this.tn.skip(delim);
|
||||
token = this.tn.peek();
|
||||
} while (token === '"' || token === '"'); // multi line?
|
||||
return value;
|
||||
};
|
||||
|
||||
/**
|
||||
* Reads a value.
|
||||
* @param {boolean=} mayBeTypeRef
|
||||
* @returns {number|boolean|string}
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._readValue = function(mayBeTypeRef) {
|
||||
var token = this.tn.peek(),
|
||||
value;
|
||||
if (token === '"' || token === "'")
|
||||
return this._readString();
|
||||
this.tn.next();
|
||||
if (Lang.NUMBER.test(token))
|
||||
return mkNumber(token);
|
||||
if (Lang.BOOL.test(token))
|
||||
return (token.toLowerCase() === 'true');
|
||||
if (mayBeTypeRef && Lang.TYPEREF.test(token))
|
||||
return token;
|
||||
throw Error("illegal value: "+token);
|
||||
|
||||
};
|
||||
|
||||
// ----- Parsing constructs -----
|
||||
|
||||
/**
|
||||
* Parses a namespace option.
|
||||
* @param {!Object} parent Parent definition
|
||||
* @param {boolean=} isList
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseOption = function(parent, isList) {
|
||||
var token = this.tn.next(),
|
||||
custom = false;
|
||||
if (token === '(') {
|
||||
custom = true;
|
||||
token = this.tn.next();
|
||||
}
|
||||
if (!Lang.TYPEREF.test(token))
|
||||
// we can allow options of the form google.protobuf.* since they will just get ignored anyways
|
||||
// if (!/google\.protobuf\./.test(token)) // FIXME: Why should that not be a valid typeref?
|
||||
throw Error("illegal option name: "+token);
|
||||
var name = token;
|
||||
if (custom) { // (my_method_option).foo, (my_method_option), some_method_option, (foo.my_option).bar
|
||||
this.tn.skip(')');
|
||||
name = '('+name+')';
|
||||
token = this.tn.peek();
|
||||
if (Lang.FQTYPEREF.test(token)) {
|
||||
name += token;
|
||||
this.tn.next();
|
||||
}
|
||||
}
|
||||
this.tn.skip('=');
|
||||
this._parseOptionValue(parent, name);
|
||||
if (!isList)
|
||||
this.tn.skip(";");
|
||||
};
|
||||
|
||||
/**
|
||||
* Sets an option on the specified options object.
|
||||
* @param {!Object.<string,*>} options
|
||||
* @param {string} name
|
||||
* @param {string|number|boolean} value
|
||||
* @inner
|
||||
*/
|
||||
function setOption(options, name, value) {
|
||||
if (typeof options[name] === 'undefined')
|
||||
options[name] = value;
|
||||
else {
|
||||
if (!Array.isArray(options[name]))
|
||||
options[name] = [ options[name] ];
|
||||
options[name].push(value);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses an option value.
|
||||
* @param {!Object} parent
|
||||
* @param {string} name
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseOptionValue = function(parent, name) {
|
||||
var token = this.tn.peek();
|
||||
if (token !== '{') { // Plain value
|
||||
setOption(parent["options"], name, this._readValue(true));
|
||||
} else { // Aggregate options
|
||||
this.tn.skip("{");
|
||||
while ((token = this.tn.next()) !== '}') {
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal option name: " + name + "." + token);
|
||||
if (this.tn.omit(":"))
|
||||
setOption(parent["options"], name + "." + token, this._readValue(true));
|
||||
else
|
||||
this._parseOptionValue(parent, name + "." + token);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses a service definition.
|
||||
* @param {!Object} parent Parent definition
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseService = function(parent) {
|
||||
var token = this.tn.next();
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal service name at line "+this.tn.line+": "+token);
|
||||
var name = token;
|
||||
var svc = {
|
||||
"name": name,
|
||||
"rpc": {},
|
||||
"options": {}
|
||||
};
|
||||
this.tn.skip("{");
|
||||
while ((token = this.tn.next()) !== '}') {
|
||||
if (token === "option")
|
||||
this._parseOption(svc);
|
||||
else if (token === 'rpc')
|
||||
this._parseServiceRPC(svc);
|
||||
else
|
||||
throw Error("illegal service token: "+token);
|
||||
}
|
||||
this.tn.omit(";");
|
||||
parent["services"].push(svc);
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses a RPC service definition of the form ['rpc', name, (request), 'returns', (response)].
|
||||
* @param {!Object} svc Service definition
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseServiceRPC = function(svc) {
|
||||
var type = "rpc",
|
||||
token = this.tn.next();
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal rpc service method name: "+token);
|
||||
var name = token;
|
||||
var method = {
|
||||
"request": null,
|
||||
"response": null,
|
||||
"request_stream": false,
|
||||
"response_stream": false,
|
||||
"options": {}
|
||||
};
|
||||
this.tn.skip("(");
|
||||
token = this.tn.next();
|
||||
if (token.toLowerCase() === "stream") {
|
||||
method["request_stream"] = true;
|
||||
token = this.tn.next();
|
||||
}
|
||||
if (!Lang.TYPEREF.test(token))
|
||||
throw Error("illegal rpc service request type: "+token);
|
||||
method["request"] = token;
|
||||
this.tn.skip(")");
|
||||
token = this.tn.next();
|
||||
if (token.toLowerCase() !== "returns")
|
||||
throw Error("illegal rpc service request type delimiter: "+token);
|
||||
this.tn.skip("(");
|
||||
token = this.tn.next();
|
||||
if (token.toLowerCase() === "stream") {
|
||||
method["response_stream"] = true;
|
||||
token = this.tn.next();
|
||||
}
|
||||
method["response"] = token;
|
||||
this.tn.skip(")");
|
||||
token = this.tn.peek();
|
||||
if (token === '{') {
|
||||
this.tn.next();
|
||||
while ((token = this.tn.next()) !== '}') {
|
||||
if (token === 'option')
|
||||
this._parseOption(method);
|
||||
else
|
||||
throw Error("illegal rpc service token: " + token);
|
||||
}
|
||||
this.tn.omit(";");
|
||||
} else
|
||||
this.tn.skip(";");
|
||||
if (typeof svc[type] === 'undefined')
|
||||
svc[type] = {};
|
||||
svc[type][name] = method;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses a message definition.
|
||||
* @param {!Object} parent Parent definition
|
||||
* @param {!Object=} fld Field definition if this is a group
|
||||
* @returns {!Object}
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseMessage = function(parent, fld) {
|
||||
var isGroup = !!fld,
|
||||
token = this.tn.next();
|
||||
var msg = {
|
||||
"name": "",
|
||||
"fields": [],
|
||||
"enums": [],
|
||||
"messages": [],
|
||||
"options": {},
|
||||
"services": [],
|
||||
"oneofs": {}
|
||||
// "extensions": undefined
|
||||
};
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal "+(isGroup ? "group" : "message")+" name: "+token);
|
||||
msg["name"] = token;
|
||||
if (isGroup) {
|
||||
this.tn.skip("=");
|
||||
fld["id"] = mkId(this.tn.next());
|
||||
msg["isGroup"] = true;
|
||||
}
|
||||
token = this.tn.peek();
|
||||
if (token === '[' && fld)
|
||||
this._parseFieldOptions(fld);
|
||||
this.tn.skip("{");
|
||||
while ((token = this.tn.next()) !== '}') {
|
||||
if (Lang.RULE.test(token))
|
||||
this._parseMessageField(msg, token);
|
||||
else if (token === "oneof")
|
||||
this._parseMessageOneOf(msg);
|
||||
else if (token === "enum")
|
||||
this._parseEnum(msg);
|
||||
else if (token === "message")
|
||||
this._parseMessage(msg);
|
||||
else if (token === "option")
|
||||
this._parseOption(msg);
|
||||
else if (token === "service")
|
||||
this._parseService(msg);
|
||||
else if (token === "extensions")
|
||||
if (msg.hasOwnProperty("extensions")) {
|
||||
msg["extensions"] = msg["extensions"].concat(this._parseExtensionRanges())
|
||||
} else {
|
||||
msg["extensions"] = this._parseExtensionRanges();
|
||||
}
|
||||
else if (token === "reserved")
|
||||
this._parseIgnored(); // TODO
|
||||
else if (token === "extend")
|
||||
this._parseExtend(msg);
|
||||
else if (Lang.TYPEREF.test(token)) {
|
||||
if (!this.proto3)
|
||||
throw Error("illegal field rule: "+token);
|
||||
this._parseMessageField(msg, "optional", token);
|
||||
} else
|
||||
throw Error("illegal message token: "+token);
|
||||
}
|
||||
this.tn.omit(";");
|
||||
parent["messages"].push(msg);
|
||||
return msg;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses an ignored statement.
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseIgnored = function() {
|
||||
while (this.tn.peek() !== ';')
|
||||
this.tn.next();
|
||||
this.tn.skip(";");
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses a message field.
|
||||
* @param {!Object} msg Message definition
|
||||
* @param {string} rule Field rule
|
||||
* @param {string=} type Field type if already known (never known for maps)
|
||||
* @returns {!Object} Field descriptor
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseMessageField = function(msg, rule, type) {
|
||||
if (!Lang.RULE.test(rule))
|
||||
throw Error("illegal message field rule: "+rule);
|
||||
var fld = {
|
||||
"rule": rule,
|
||||
"type": "",
|
||||
"name": "",
|
||||
"options": {},
|
||||
"id": 0
|
||||
};
|
||||
var token;
|
||||
if (rule === "map") {
|
||||
|
||||
if (type)
|
||||
throw Error("illegal type: " + type);
|
||||
this.tn.skip('<');
|
||||
token = this.tn.next();
|
||||
if (!Lang.TYPE.test(token) && !Lang.TYPEREF.test(token))
|
||||
throw Error("illegal message field type: " + token);
|
||||
fld["keytype"] = token;
|
||||
this.tn.skip(',');
|
||||
token = this.tn.next();
|
||||
if (!Lang.TYPE.test(token) && !Lang.TYPEREF.test(token))
|
||||
throw Error("illegal message field: " + token);
|
||||
fld["type"] = token;
|
||||
this.tn.skip('>');
|
||||
token = this.tn.next();
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal message field name: " + token);
|
||||
fld["name"] = token;
|
||||
this.tn.skip("=");
|
||||
fld["id"] = mkId(this.tn.next());
|
||||
token = this.tn.peek();
|
||||
if (token === '[')
|
||||
this._parseFieldOptions(fld);
|
||||
this.tn.skip(";");
|
||||
|
||||
} else {
|
||||
|
||||
type = typeof type !== 'undefined' ? type : this.tn.next();
|
||||
|
||||
if (type === "group") {
|
||||
|
||||
// "A [legacy] group simply combines a nested message type and a field into a single declaration. In your
|
||||
// code, you can treat this message just as if it had a Result type field called result (the latter name is
|
||||
// converted to lower-case so that it does not conflict with the former)."
|
||||
var grp = this._parseMessage(msg, fld);
|
||||
if (!/^[A-Z]/.test(grp["name"]))
|
||||
throw Error('illegal group name: '+grp["name"]);
|
||||
fld["type"] = grp["name"];
|
||||
fld["name"] = grp["name"].toLowerCase();
|
||||
this.tn.omit(";");
|
||||
|
||||
} else {
|
||||
|
||||
if (!Lang.TYPE.test(type) && !Lang.TYPEREF.test(type))
|
||||
throw Error("illegal message field type: " + type);
|
||||
fld["type"] = type;
|
||||
token = this.tn.next();
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal message field name: " + token);
|
||||
fld["name"] = token;
|
||||
this.tn.skip("=");
|
||||
fld["id"] = mkId(this.tn.next());
|
||||
token = this.tn.peek();
|
||||
if (token === "[")
|
||||
this._parseFieldOptions(fld);
|
||||
this.tn.skip(";");
|
||||
|
||||
}
|
||||
}
|
||||
msg["fields"].push(fld);
|
||||
return fld;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses a message oneof.
|
||||
* @param {!Object} msg Message definition
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseMessageOneOf = function(msg) {
|
||||
var token = this.tn.next();
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal oneof name: "+token);
|
||||
var name = token,
|
||||
fld;
|
||||
var fields = [];
|
||||
this.tn.skip("{");
|
||||
while ((token = this.tn.next()) !== "}") {
|
||||
fld = this._parseMessageField(msg, "optional", token);
|
||||
fld["oneof"] = name;
|
||||
fields.push(fld["id"]);
|
||||
}
|
||||
this.tn.omit(";");
|
||||
msg["oneofs"][name] = fields;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses a set of field option definitions.
|
||||
* @param {!Object} fld Field definition
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseFieldOptions = function(fld) {
|
||||
this.tn.skip("[");
|
||||
var token,
|
||||
first = true;
|
||||
while ((token = this.tn.peek()) !== ']') {
|
||||
if (!first)
|
||||
this.tn.skip(",");
|
||||
this._parseOption(fld, true);
|
||||
first = false;
|
||||
}
|
||||
this.tn.next();
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses an enum.
|
||||
* @param {!Object} msg Message definition
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseEnum = function(msg) {
|
||||
var enm = {
|
||||
"name": "",
|
||||
"values": [],
|
||||
"options": {}
|
||||
};
|
||||
var token = this.tn.next();
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal name: "+token);
|
||||
enm["name"] = token;
|
||||
this.tn.skip("{");
|
||||
while ((token = this.tn.next()) !== '}') {
|
||||
if (token === "option")
|
||||
this._parseOption(enm);
|
||||
else {
|
||||
if (!Lang.NAME.test(token))
|
||||
throw Error("illegal name: "+token);
|
||||
this.tn.skip("=");
|
||||
var val = {
|
||||
"name": token,
|
||||
"id": mkId(this.tn.next(), true)
|
||||
};
|
||||
token = this.tn.peek();
|
||||
if (token === "[")
|
||||
this._parseFieldOptions({ "options": {} });
|
||||
this.tn.skip(";");
|
||||
enm["values"].push(val);
|
||||
}
|
||||
}
|
||||
this.tn.omit(";");
|
||||
msg["enums"].push(enm);
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses extension / reserved ranges.
|
||||
* @returns {!Array.<!Array.<number>>}
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseExtensionRanges = function() {
|
||||
var ranges = [];
|
||||
var token,
|
||||
range,
|
||||
value;
|
||||
do {
|
||||
range = [];
|
||||
while (true) {
|
||||
token = this.tn.next();
|
||||
switch (token) {
|
||||
case "min":
|
||||
value = ProtoBuf.ID_MIN;
|
||||
break;
|
||||
case "max":
|
||||
value = ProtoBuf.ID_MAX;
|
||||
break;
|
||||
default:
|
||||
value = mkNumber(token);
|
||||
break;
|
||||
}
|
||||
range.push(value);
|
||||
if (range.length === 2)
|
||||
break;
|
||||
if (this.tn.peek() !== "to") {
|
||||
range.push(value);
|
||||
break;
|
||||
}
|
||||
this.tn.next();
|
||||
}
|
||||
ranges.push(range);
|
||||
} while (this.tn.omit(","));
|
||||
this.tn.skip(";");
|
||||
return ranges;
|
||||
};
|
||||
|
||||
/**
|
||||
* Parses an extend block.
|
||||
* @param {!Object} parent Parent object
|
||||
* @private
|
||||
*/
|
||||
ParserPrototype._parseExtend = function(parent) {
|
||||
var token = this.tn.next();
|
||||
if (!Lang.TYPEREF.test(token))
|
||||
throw Error("illegal extend reference: "+token);
|
||||
var ext = {
|
||||
"ref": token,
|
||||
"fields": []
|
||||
};
|
||||
this.tn.skip("{");
|
||||
while ((token = this.tn.next()) !== '}') {
|
||||
if (Lang.RULE.test(token))
|
||||
this._parseMessageField(ext, token);
|
||||
else if (Lang.TYPEREF.test(token)) {
|
||||
if (!this.proto3)
|
||||
throw Error("illegal field rule: "+token);
|
||||
this._parseMessageField(ext, "optional", token);
|
||||
} else
|
||||
throw Error("illegal extend token: "+token);
|
||||
}
|
||||
this.tn.omit(";");
|
||||
parent["messages"].push(ext);
|
||||
return ext;
|
||||
};
|
||||
|
||||
// ----- General -----
|
||||
|
||||
/**
|
||||
* Returns a string representation of this parser.
|
||||
* @returns {string}
|
||||
*/
|
||||
ParserPrototype.toString = function() {
|
||||
return "Parser at line "+this.tn.line;
|
||||
};
|
||||
190
node_modules/protobufjs/src/ProtoBuf/DotProto/Tokenizer.js
generated
vendored
Normal file
190
node_modules/protobufjs/src/ProtoBuf/DotProto/Tokenizer.js
generated
vendored
Normal file
@ -0,0 +1,190 @@
|
||||
/*?
|
||||
// --- Scope -----------------
|
||||
// Lang : Language expressions
|
||||
*/
|
||||
/**
|
||||
* Constructs a new Tokenizer.
|
||||
* @exports ProtoBuf.DotProto.Tokenizer
|
||||
* @class prototype tokenizer
|
||||
* @param {string} proto Proto to tokenize
|
||||
* @constructor
|
||||
*/
|
||||
var Tokenizer = function(proto) {
|
||||
|
||||
/**
|
||||
* Source to parse.
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.source = proto+"";
|
||||
|
||||
/**
|
||||
* Current index.
|
||||
* @type {number}
|
||||
* @expose
|
||||
*/
|
||||
this.index = 0;
|
||||
|
||||
/**
|
||||
* Current line.
|
||||
* @type {number}
|
||||
* @expose
|
||||
*/
|
||||
this.line = 1;
|
||||
|
||||
/**
|
||||
* Token stack.
|
||||
* @type {!Array.<string>}
|
||||
* @expose
|
||||
*/
|
||||
this.stack = [];
|
||||
|
||||
/**
|
||||
* Opening character of the current string read, if any.
|
||||
* @type {?string}
|
||||
* @private
|
||||
*/
|
||||
this._stringOpen = null;
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.DotProto.Tokenizer.prototype
|
||||
* @inner
|
||||
*/
|
||||
var TokenizerPrototype = Tokenizer.prototype;
|
||||
|
||||
/**
|
||||
* Reads a string beginning at the current index.
|
||||
* @return {string}
|
||||
* @private
|
||||
*/
|
||||
TokenizerPrototype._readString = function() {
|
||||
var re = this._stringOpen === '"'
|
||||
? Lang.STRING_DQ
|
||||
: Lang.STRING_SQ;
|
||||
re.lastIndex = this.index - 1; // Include the open quote
|
||||
var match = re.exec(this.source);
|
||||
if (!match)
|
||||
throw Error("unterminated string");
|
||||
this.index = re.lastIndex;
|
||||
this.stack.push(this._stringOpen);
|
||||
this._stringOpen = null;
|
||||
return match[1];
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets the next token and advances by one.
|
||||
* @return {?string} Token or `null` on EOF
|
||||
* @expose
|
||||
*/
|
||||
TokenizerPrototype.next = function() {
|
||||
if (this.stack.length > 0)
|
||||
return this.stack.shift();
|
||||
if (this.index >= this.source.length)
|
||||
return null;
|
||||
if (this._stringOpen !== null)
|
||||
return this._readString();
|
||||
|
||||
var repeat,
|
||||
prev,
|
||||
next;
|
||||
do {
|
||||
repeat = false;
|
||||
|
||||
// Strip white spaces
|
||||
while (Lang.WHITESPACE.test(next = this.source.charAt(this.index))) {
|
||||
if (next === '\n')
|
||||
++this.line;
|
||||
if (++this.index === this.source.length)
|
||||
return null;
|
||||
}
|
||||
|
||||
// Strip comments
|
||||
if (this.source.charAt(this.index) === '/') {
|
||||
++this.index;
|
||||
if (this.source.charAt(this.index) === '/') { // Line
|
||||
while (this.source.charAt(++this.index) !== '\n')
|
||||
if (this.index == this.source.length)
|
||||
return null;
|
||||
++this.index;
|
||||
++this.line;
|
||||
repeat = true;
|
||||
} else if ((next = this.source.charAt(this.index)) === '*') { /* Block */
|
||||
do {
|
||||
if (next === '\n')
|
||||
++this.line;
|
||||
if (++this.index === this.source.length)
|
||||
return null;
|
||||
prev = next;
|
||||
next = this.source.charAt(this.index);
|
||||
} while (prev !== '*' || next !== '/');
|
||||
++this.index;
|
||||
repeat = true;
|
||||
} else
|
||||
return '/';
|
||||
}
|
||||
} while (repeat);
|
||||
|
||||
if (this.index === this.source.length)
|
||||
return null;
|
||||
|
||||
// Read the next token
|
||||
var end = this.index;
|
||||
Lang.DELIM.lastIndex = 0;
|
||||
var delim = Lang.DELIM.test(this.source.charAt(end++));
|
||||
if (!delim)
|
||||
while(end < this.source.length && !Lang.DELIM.test(this.source.charAt(end)))
|
||||
++end;
|
||||
var token = this.source.substring(this.index, this.index = end);
|
||||
if (token === '"' || token === "'")
|
||||
this._stringOpen = token;
|
||||
return token;
|
||||
};
|
||||
|
||||
/**
|
||||
* Peeks for the next token.
|
||||
* @return {?string} Token or `null` on EOF
|
||||
* @expose
|
||||
*/
|
||||
TokenizerPrototype.peek = function() {
|
||||
if (this.stack.length === 0) {
|
||||
var token = this.next();
|
||||
if (token === null)
|
||||
return null;
|
||||
this.stack.push(token);
|
||||
}
|
||||
return this.stack[0];
|
||||
};
|
||||
|
||||
/**
|
||||
* Skips a specific token and throws if it differs.
|
||||
* @param {string} expected Expected token
|
||||
* @throws {Error} If the actual token differs
|
||||
*/
|
||||
TokenizerPrototype.skip = function(expected) {
|
||||
var actual = this.next();
|
||||
if (actual !== expected)
|
||||
throw Error("illegal '"+actual+"', '"+expected+"' expected");
|
||||
};
|
||||
|
||||
/**
|
||||
* Omits an optional token.
|
||||
* @param {string} expected Expected optional token
|
||||
* @returns {boolean} `true` if the token exists
|
||||
*/
|
||||
TokenizerPrototype.omit = function(expected) {
|
||||
if (this.peek() === expected) {
|
||||
this.next();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a string representation of this object.
|
||||
* @return {string} String representation as of "Tokenizer(index/length)"
|
||||
* @expose
|
||||
*/
|
||||
TokenizerPrototype.toString = function() {
|
||||
return "Tokenizer ("+this.index+"/"+this.source.length+" at line "+this.line+")";
|
||||
};
|
||||
64
node_modules/protobufjs/src/ProtoBuf/Lang.js
generated
vendored
Normal file
64
node_modules/protobufjs/src/ProtoBuf/Lang.js
generated
vendored
Normal file
@ -0,0 +1,64 @@
|
||||
/**
|
||||
* Language expressions.
|
||||
* @type {!Object.<string,!RegExp>}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.Lang = {
|
||||
|
||||
// Characters always ending a statement
|
||||
DELIM: /[\s\{\}=;:\[\],'"\(\)<>]/g,
|
||||
|
||||
// Field rules
|
||||
RULE: /^(?:required|optional|repeated|map)$/,
|
||||
|
||||
// Field types
|
||||
TYPE: /^(?:double|float|int32|uint32|sint32|int64|uint64|sint64|fixed32|sfixed32|fixed64|sfixed64|bool|string|bytes)$/,
|
||||
|
||||
// Names
|
||||
NAME: /^[a-zA-Z_][a-zA-Z_0-9]*$/,
|
||||
|
||||
// Type definitions
|
||||
TYPEDEF: /^[a-zA-Z][a-zA-Z_0-9]*$/,
|
||||
|
||||
// Type references
|
||||
TYPEREF: /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*$/,
|
||||
|
||||
// Fully qualified type references
|
||||
FQTYPEREF: /^(?:\.[a-zA-Z_][a-zA-Z_0-9]*)+$/,
|
||||
|
||||
// All numbers
|
||||
NUMBER: /^-?(?:[1-9][0-9]*|0|0[xX][0-9a-fA-F]+|0[0-7]+|([0-9]*(\.[0-9]*)?([Ee][+-]?[0-9]+)?)|inf|nan)$/,
|
||||
|
||||
// Decimal numbers
|
||||
NUMBER_DEC: /^(?:[1-9][0-9]*|0)$/,
|
||||
|
||||
// Hexadecimal numbers
|
||||
NUMBER_HEX: /^0[xX][0-9a-fA-F]+$/,
|
||||
|
||||
// Octal numbers
|
||||
NUMBER_OCT: /^0[0-7]+$/,
|
||||
|
||||
// Floating point numbers
|
||||
NUMBER_FLT: /^([0-9]*(\.[0-9]*)?([Ee][+-]?[0-9]+)?|inf|nan)$/,
|
||||
|
||||
// Booleans
|
||||
BOOL: /^(?:true|false)$/i,
|
||||
|
||||
// Id numbers
|
||||
ID: /^(?:[1-9][0-9]*|0|0[xX][0-9a-fA-F]+|0[0-7]+)$/,
|
||||
|
||||
// Negative id numbers (enum values)
|
||||
NEGID: /^\-?(?:[1-9][0-9]*|0|0[xX][0-9a-fA-F]+|0[0-7]+)$/,
|
||||
|
||||
// Whitespaces
|
||||
WHITESPACE: /\s/,
|
||||
|
||||
// All strings
|
||||
STRING: /(?:"([^"\\]*(?:\\.[^"\\]*)*)")|(?:'([^'\\]*(?:\\.[^'\\]*)*)')/g,
|
||||
|
||||
// Double quoted strings
|
||||
STRING_DQ: /(?:"([^"\\]*(?:\\.[^"\\]*)*)")/g,
|
||||
|
||||
// Single quoted strings
|
||||
STRING_SQ: /(?:'([^'\\]*(?:\\.[^'\\]*)*)')/g
|
||||
};
|
||||
197
node_modules/protobufjs/src/ProtoBuf/Map.js
generated
vendored
Normal file
197
node_modules/protobufjs/src/ProtoBuf/Map.js
generated
vendored
Normal file
@ -0,0 +1,197 @@
|
||||
/**
|
||||
* @alias ProtoBuf.Map
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.Map = (function(ProtoBuf, Reflect) {
|
||||
"use strict";
|
||||
|
||||
/**
|
||||
* Constructs a new Map. A Map is a container that is used to implement map
|
||||
* fields on message objects. It closely follows the ES6 Map API; however,
|
||||
* it is distinct because we do not want to depend on external polyfills or
|
||||
* on ES6 itself.
|
||||
*
|
||||
* @exports ProtoBuf.Map
|
||||
* @param {!ProtoBuf.Reflect.Field} field Map field
|
||||
* @param {Object.<string,*>=} contents Initial contents
|
||||
* @constructor
|
||||
*/
|
||||
var Map = function(field, contents) {
|
||||
if (!field.map)
|
||||
throw Error("field is not a map");
|
||||
|
||||
/**
|
||||
* The field corresponding to this map.
|
||||
* @type {!ProtoBuf.Reflect.Field}
|
||||
*/
|
||||
this.field = field;
|
||||
|
||||
/**
|
||||
* Element instance corresponding to key type.
|
||||
* @type {!ProtoBuf.Reflect.Element}
|
||||
*/
|
||||
this.keyElem = new Reflect.Element(field.keyType, null, true, field.syntax);
|
||||
|
||||
/**
|
||||
* Element instance corresponding to value type.
|
||||
* @type {!ProtoBuf.Reflect.Element}
|
||||
*/
|
||||
this.valueElem = new Reflect.Element(field.type, field.resolvedType, false, field.syntax);
|
||||
|
||||
/**
|
||||
* Internal map: stores mapping of (string form of key) -> (key, value)
|
||||
* pair.
|
||||
*
|
||||
* We provide map semantics for arbitrary key types, but we build on top
|
||||
* of an Object, which has only string keys. In order to avoid the need
|
||||
* to convert a string key back to its native type in many situations,
|
||||
* we store the native key value alongside the value. Thus, we only need
|
||||
* a one-way mapping from a key type to its string form that guarantees
|
||||
* uniqueness and equality (i.e., str(K1) === str(K2) if and only if K1
|
||||
* === K2).
|
||||
*
|
||||
* @type {!Object<string, {key: *, value: *}>}
|
||||
*/
|
||||
this.map = {};
|
||||
|
||||
/**
|
||||
* Returns the number of elements in the map.
|
||||
*/
|
||||
Object.defineProperty(this, "size", {
|
||||
get: function() { return Object.keys(this.map).length; }
|
||||
});
|
||||
|
||||
// Fill initial contents from a raw object.
|
||||
if (contents) {
|
||||
var keys = Object.keys(contents);
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var key = this.keyElem.valueFromString(keys[i]);
|
||||
var val = this.valueElem.verifyValue(contents[keys[i]]);
|
||||
this.map[this.keyElem.valueToString(key)] =
|
||||
{ key: key, value: val };
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
var MapPrototype = Map.prototype;
|
||||
|
||||
/**
|
||||
* Helper: return an iterator over an array.
|
||||
* @param {!Array<*>} arr the array
|
||||
* @returns {!Object} an iterator
|
||||
* @inner
|
||||
*/
|
||||
function arrayIterator(arr) {
|
||||
var idx = 0;
|
||||
return {
|
||||
next: function() {
|
||||
if (idx < arr.length)
|
||||
return { done: false, value: arr[idx++] };
|
||||
return { done: true };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the map.
|
||||
*/
|
||||
MapPrototype.clear = function() {
|
||||
this.map = {};
|
||||
};
|
||||
|
||||
/**
|
||||
* Deletes a particular key from the map.
|
||||
* @returns {boolean} Whether any entry with this key was deleted.
|
||||
*/
|
||||
MapPrototype["delete"] = function(key) {
|
||||
var keyValue = this.keyElem.valueToString(this.keyElem.verifyValue(key));
|
||||
var hadKey = keyValue in this.map;
|
||||
delete this.map[keyValue];
|
||||
return hadKey;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an iterator over [key, value] pairs in the map.
|
||||
* @returns {Object} The iterator
|
||||
*/
|
||||
MapPrototype.entries = function() {
|
||||
var entries = [];
|
||||
var strKeys = Object.keys(this.map);
|
||||
for (var i = 0, entry; i < strKeys.length; i++)
|
||||
entries.push([(entry=this.map[strKeys[i]]).key, entry.value]);
|
||||
return arrayIterator(entries);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an iterator over keys in the map.
|
||||
* @returns {Object} The iterator
|
||||
*/
|
||||
MapPrototype.keys = function() {
|
||||
var keys = [];
|
||||
var strKeys = Object.keys(this.map);
|
||||
for (var i = 0; i < strKeys.length; i++)
|
||||
keys.push(this.map[strKeys[i]].key);
|
||||
return arrayIterator(keys);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an iterator over values in the map.
|
||||
* @returns {!Object} The iterator
|
||||
*/
|
||||
MapPrototype.values = function() {
|
||||
var values = [];
|
||||
var strKeys = Object.keys(this.map);
|
||||
for (var i = 0; i < strKeys.length; i++)
|
||||
values.push(this.map[strKeys[i]].value);
|
||||
return arrayIterator(values);
|
||||
};
|
||||
|
||||
/**
|
||||
* Iterates over entries in the map, calling a function on each.
|
||||
* @param {function(this:*, *, *, *)} cb The callback to invoke with value, key, and map arguments.
|
||||
* @param {Object=} thisArg The `this` value for the callback
|
||||
*/
|
||||
MapPrototype.forEach = function(cb, thisArg) {
|
||||
var strKeys = Object.keys(this.map);
|
||||
for (var i = 0, entry; i < strKeys.length; i++)
|
||||
cb.call(thisArg, (entry=this.map[strKeys[i]]).value, entry.key, this);
|
||||
};
|
||||
|
||||
/**
|
||||
* Sets a key in the map to the given value.
|
||||
* @param {*} key The key
|
||||
* @param {*} value The value
|
||||
* @returns {!ProtoBuf.Map} The map instance
|
||||
*/
|
||||
MapPrototype.set = function(key, value) {
|
||||
var keyValue = this.keyElem.verifyValue(key);
|
||||
var valValue = this.valueElem.verifyValue(value);
|
||||
this.map[this.keyElem.valueToString(keyValue)] =
|
||||
{ key: keyValue, value: valValue };
|
||||
return this;
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets the value corresponding to a key in the map.
|
||||
* @param {*} key The key
|
||||
* @returns {*|undefined} The value, or `undefined` if key not present
|
||||
*/
|
||||
MapPrototype.get = function(key) {
|
||||
var keyValue = this.keyElem.valueToString(this.keyElem.verifyValue(key));
|
||||
if (!(keyValue in this.map))
|
||||
return undefined;
|
||||
return this.map[keyValue].value;
|
||||
};
|
||||
|
||||
/**
|
||||
* Determines whether the given key is present in the map.
|
||||
* @param {*} key The key
|
||||
* @returns {boolean} `true` if the key is present
|
||||
*/
|
||||
MapPrototype.has = function(key) {
|
||||
var keyValue = this.keyElem.valueToString(this.keyElem.verifyValue(key));
|
||||
return (keyValue in this.map);
|
||||
};
|
||||
|
||||
return Map;
|
||||
})(ProtoBuf, ProtoBuf.Reflect);
|
||||
121
node_modules/protobufjs/src/ProtoBuf/Reflect.js
generated
vendored
Normal file
121
node_modules/protobufjs/src/ProtoBuf/Reflect.js
generated
vendored
Normal file
@ -0,0 +1,121 @@
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.Reflect = (function(ProtoBuf) {
|
||||
"use strict";
|
||||
|
||||
/**
|
||||
* Reflection types.
|
||||
* @exports ProtoBuf.Reflect
|
||||
* @namespace
|
||||
*/
|
||||
var Reflect = {};
|
||||
|
||||
//? include("Reflect/T.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.T
|
||||
* @expose
|
||||
*/
|
||||
Reflect.T = T;
|
||||
|
||||
//? include("Reflect/Namespace.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Namespace
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Namespace = Namespace;
|
||||
|
||||
//? include("Reflect/Element.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Element
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Element = Element;
|
||||
|
||||
//? include("Reflect/Message.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Message
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Message = Message;
|
||||
|
||||
//? include("Reflect/Message/Field.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Message.Field
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Message.Field = Field;
|
||||
|
||||
//? include("Reflect/Message/ExtensionField.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Message.ExtensionField
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Message.ExtensionField = ExtensionField;
|
||||
|
||||
//? include("Reflect/Message/OneOf.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Message.OneOf
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Message.OneOf = OneOf;
|
||||
|
||||
//? include("Reflect/Enum.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Enum
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Enum = Enum;
|
||||
|
||||
//? include("Reflect/Enum/Value.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Enum.Value
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Enum.Value = Value;
|
||||
|
||||
//? include("Reflect/Extension.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Extension
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Extension = Extension;
|
||||
|
||||
//? include("Reflect/Service.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Service
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Service = Service;
|
||||
|
||||
//? include("Reflect/Service/Method.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Service.Method
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Service.Method = Method;
|
||||
|
||||
//? include("Reflect/Service/RPCMethod.js");
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Service.RPCMethod
|
||||
* @expose
|
||||
*/
|
||||
Reflect.Service.RPCMethod = RPCMethod;
|
||||
|
||||
return Reflect;
|
||||
|
||||
})(ProtoBuf);
|
||||
580
node_modules/protobufjs/src/ProtoBuf/Reflect/Element.js
generated
vendored
Normal file
580
node_modules/protobufjs/src/ProtoBuf/Reflect/Element.js
generated
vendored
Normal file
@ -0,0 +1,580 @@
|
||||
/**
|
||||
* Constructs a new Element implementation that checks and converts values for a
|
||||
* particular field type, as appropriate.
|
||||
*
|
||||
* An Element represents a single value: either the value of a singular field,
|
||||
* or a value contained in one entry of a repeated field or map field. This
|
||||
* class does not implement these higher-level concepts; it only encapsulates
|
||||
* the low-level typechecking and conversion.
|
||||
*
|
||||
* @exports ProtoBuf.Reflect.Element
|
||||
* @param {{name: string, wireType: number}} type Resolved data type
|
||||
* @param {ProtoBuf.Reflect.T|null} resolvedType Resolved type, if relevant
|
||||
* (e.g. submessage field).
|
||||
* @param {boolean} isMapKey Is this element a Map key? The value will be
|
||||
* converted to string form if so.
|
||||
* @param {string} syntax Syntax level of defining message type, e.g.,
|
||||
* proto2 or proto3.
|
||||
* @param {string} name Name of the field containing this element (for error
|
||||
* messages)
|
||||
* @constructor
|
||||
*/
|
||||
var Element = function(type, resolvedType, isMapKey, syntax, name) {
|
||||
|
||||
/**
|
||||
* Element type, as a string (e.g., int32).
|
||||
* @type {{name: string, wireType: number}}
|
||||
*/
|
||||
this.type = type;
|
||||
|
||||
/**
|
||||
* Element type reference to submessage or enum definition, if needed.
|
||||
* @type {ProtoBuf.Reflect.T|null}
|
||||
*/
|
||||
this.resolvedType = resolvedType;
|
||||
|
||||
/**
|
||||
* Element is a map key.
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.isMapKey = isMapKey;
|
||||
|
||||
/**
|
||||
* Syntax level of defining message type, e.g., proto2 or proto3.
|
||||
* @type {string}
|
||||
*/
|
||||
this.syntax = syntax;
|
||||
|
||||
/**
|
||||
* Name of the field containing this element (for error messages)
|
||||
* @type {string}
|
||||
*/
|
||||
this.name = name;
|
||||
|
||||
if (isMapKey && ProtoBuf.MAP_KEY_TYPES.indexOf(type) < 0)
|
||||
throw Error("Invalid map key type: " + type.name);
|
||||
};
|
||||
|
||||
var ElementPrototype = Element.prototype;
|
||||
|
||||
/**
|
||||
* Obtains a (new) default value for the specified type.
|
||||
* @param type {string|{name: string, wireType: number}} Field type
|
||||
* @returns {*} Default value
|
||||
* @inner
|
||||
*/
|
||||
function mkDefault(type) {
|
||||
if (typeof type === 'string')
|
||||
type = ProtoBuf.TYPES[type];
|
||||
if (typeof type.defaultValue === 'undefined')
|
||||
throw Error("default value for type "+type.name+" is not supported");
|
||||
if (type == ProtoBuf.TYPES["bytes"])
|
||||
return new ByteBuffer(0);
|
||||
return type.defaultValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the default value for this field in proto3.
|
||||
* @function
|
||||
* @param type {string|{name: string, wireType: number}} the field type
|
||||
* @returns {*} Default value
|
||||
*/
|
||||
Element.defaultFieldValue = mkDefault;
|
||||
|
||||
/**
|
||||
* Makes a Long from a value.
|
||||
* @param {{low: number, high: number, unsigned: boolean}|string|number} value Value
|
||||
* @param {boolean=} unsigned Whether unsigned or not, defaults to reuse it from Long-like objects or to signed for
|
||||
* strings and numbers
|
||||
* @returns {!Long}
|
||||
* @throws {Error} If the value cannot be converted to a Long
|
||||
* @inner
|
||||
*/
|
||||
function mkLong(value, unsigned) {
|
||||
if (value && typeof value.low === 'number' && typeof value.high === 'number' && typeof value.unsigned === 'boolean'
|
||||
&& value.low === value.low && value.high === value.high)
|
||||
return new ProtoBuf.Long(value.low, value.high, typeof unsigned === 'undefined' ? value.unsigned : unsigned);
|
||||
if (typeof value === 'string')
|
||||
return ProtoBuf.Long.fromString(value, unsigned || false, 10);
|
||||
if (typeof value === 'number')
|
||||
return ProtoBuf.Long.fromNumber(value, unsigned || false);
|
||||
throw Error("not convertible to Long");
|
||||
}
|
||||
|
||||
ElementPrototype.toString = function() {
|
||||
return (this.name || '') + (this.isMapKey ? 'map' : 'value') + ' element';
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the given value can be set for an element of this type (singular
|
||||
* field or one element of a repeated field or map).
|
||||
* @param {*} value Value to check
|
||||
* @return {*} Verified, maybe adjusted, value
|
||||
* @throws {Error} If the value cannot be verified for this element slot
|
||||
* @expose
|
||||
*/
|
||||
ElementPrototype.verifyValue = function(value) {
|
||||
var self = this;
|
||||
function fail(val, msg) {
|
||||
throw Error("Illegal value for "+self.toString(true)+" of type "+self.type.name+": "+val+" ("+msg+")");
|
||||
}
|
||||
switch (this.type) {
|
||||
// Signed 32bit
|
||||
case ProtoBuf.TYPES["int32"]:
|
||||
case ProtoBuf.TYPES["sint32"]:
|
||||
case ProtoBuf.TYPES["sfixed32"]:
|
||||
// Account for !NaN: value === value
|
||||
if (typeof value !== 'number' || (value === value && value % 1 !== 0))
|
||||
fail(typeof value, "not an integer");
|
||||
return value > 4294967295 ? value | 0 : value;
|
||||
|
||||
// Unsigned 32bit
|
||||
case ProtoBuf.TYPES["uint32"]:
|
||||
case ProtoBuf.TYPES["fixed32"]:
|
||||
if (typeof value !== 'number' || (value === value && value % 1 !== 0))
|
||||
fail(typeof value, "not an integer");
|
||||
return value < 0 ? value >>> 0 : value;
|
||||
|
||||
// Signed 64bit
|
||||
case ProtoBuf.TYPES["int64"]:
|
||||
case ProtoBuf.TYPES["sint64"]:
|
||||
case ProtoBuf.TYPES["sfixed64"]: {
|
||||
if (ProtoBuf.Long)
|
||||
try {
|
||||
return mkLong(value, false);
|
||||
} catch (e) {
|
||||
fail(typeof value, e.message);
|
||||
}
|
||||
else
|
||||
fail(typeof value, "requires Long.js");
|
||||
}
|
||||
|
||||
// Unsigned 64bit
|
||||
case ProtoBuf.TYPES["uint64"]:
|
||||
case ProtoBuf.TYPES["fixed64"]: {
|
||||
if (ProtoBuf.Long)
|
||||
try {
|
||||
return mkLong(value, true);
|
||||
} catch (e) {
|
||||
fail(typeof value, e.message);
|
||||
}
|
||||
else
|
||||
fail(typeof value, "requires Long.js");
|
||||
}
|
||||
|
||||
// Bool
|
||||
case ProtoBuf.TYPES["bool"]:
|
||||
if (typeof value !== 'boolean')
|
||||
fail(typeof value, "not a boolean");
|
||||
return value;
|
||||
|
||||
// Float
|
||||
case ProtoBuf.TYPES["float"]:
|
||||
case ProtoBuf.TYPES["double"]:
|
||||
if (typeof value !== 'number')
|
||||
fail(typeof value, "not a number");
|
||||
return value;
|
||||
|
||||
// Length-delimited string
|
||||
case ProtoBuf.TYPES["string"]:
|
||||
if (typeof value !== 'string' && !(value && value instanceof String))
|
||||
fail(typeof value, "not a string");
|
||||
return ""+value; // Convert String object to string
|
||||
|
||||
// Length-delimited bytes
|
||||
case ProtoBuf.TYPES["bytes"]:
|
||||
if (ByteBuffer.isByteBuffer(value))
|
||||
return value;
|
||||
return ByteBuffer.wrap(value, "base64");
|
||||
|
||||
// Constant enum value
|
||||
case ProtoBuf.TYPES["enum"]: {
|
||||
var values = this.resolvedType.getChildren(ProtoBuf.Reflect.Enum.Value);
|
||||
for (i=0; i<values.length; i++)
|
||||
if (values[i].name == value)
|
||||
return values[i].id;
|
||||
else if (values[i].id == value)
|
||||
return values[i].id;
|
||||
|
||||
if (this.syntax === 'proto3') {
|
||||
// proto3: just make sure it's an integer.
|
||||
if (typeof value !== 'number' || (value === value && value % 1 !== 0))
|
||||
fail(typeof value, "not an integer");
|
||||
if (value > 4294967295 || value < 0)
|
||||
fail(typeof value, "not in range for uint32")
|
||||
return value;
|
||||
} else {
|
||||
// proto2 requires enum values to be valid.
|
||||
fail(value, "not a valid enum value");
|
||||
}
|
||||
}
|
||||
// Embedded message
|
||||
case ProtoBuf.TYPES["group"]:
|
||||
case ProtoBuf.TYPES["message"]: {
|
||||
if (!value || typeof value !== 'object')
|
||||
fail(typeof value, "object expected");
|
||||
if (value instanceof this.resolvedType.clazz)
|
||||
return value;
|
||||
if (value instanceof ProtoBuf.Builder.Message) {
|
||||
// Mismatched type: Convert to object (see: https://github.com/dcodeIO/ProtoBuf.js/issues/180)
|
||||
var obj = {};
|
||||
for (var i in value)
|
||||
if (value.hasOwnProperty(i))
|
||||
obj[i] = value[i];
|
||||
value = obj;
|
||||
}
|
||||
// Else let's try to construct one from a key-value object
|
||||
return new (this.resolvedType.clazz)(value); // May throw for a hundred of reasons
|
||||
}
|
||||
}
|
||||
|
||||
// We should never end here
|
||||
throw Error("[INTERNAL] Illegal value for "+this.toString(true)+": "+value+" (undefined type "+this.type+")");
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculates the byte length of an element on the wire.
|
||||
* @param {number} id Field number
|
||||
* @param {*} value Field value
|
||||
* @returns {number} Byte length
|
||||
* @throws {Error} If the value cannot be calculated
|
||||
* @expose
|
||||
*/
|
||||
ElementPrototype.calculateLength = function(id, value) {
|
||||
if (value === null) return 0; // Nothing to encode
|
||||
// Tag has already been written
|
||||
var n;
|
||||
switch (this.type) {
|
||||
case ProtoBuf.TYPES["int32"]:
|
||||
return value < 0 ? ByteBuffer.calculateVarint64(value) : ByteBuffer.calculateVarint32(value);
|
||||
case ProtoBuf.TYPES["uint32"]:
|
||||
return ByteBuffer.calculateVarint32(value);
|
||||
case ProtoBuf.TYPES["sint32"]:
|
||||
return ByteBuffer.calculateVarint32(ByteBuffer.zigZagEncode32(value));
|
||||
case ProtoBuf.TYPES["fixed32"]:
|
||||
case ProtoBuf.TYPES["sfixed32"]:
|
||||
case ProtoBuf.TYPES["float"]:
|
||||
return 4;
|
||||
case ProtoBuf.TYPES["int64"]:
|
||||
case ProtoBuf.TYPES["uint64"]:
|
||||
return ByteBuffer.calculateVarint64(value);
|
||||
case ProtoBuf.TYPES["sint64"]:
|
||||
return ByteBuffer.calculateVarint64(ByteBuffer.zigZagEncode64(value));
|
||||
case ProtoBuf.TYPES["fixed64"]:
|
||||
case ProtoBuf.TYPES["sfixed64"]:
|
||||
return 8;
|
||||
case ProtoBuf.TYPES["bool"]:
|
||||
return 1;
|
||||
case ProtoBuf.TYPES["enum"]:
|
||||
return ByteBuffer.calculateVarint32(value);
|
||||
case ProtoBuf.TYPES["double"]:
|
||||
return 8;
|
||||
case ProtoBuf.TYPES["string"]:
|
||||
n = ByteBuffer.calculateUTF8Bytes(value);
|
||||
return ByteBuffer.calculateVarint32(n) + n;
|
||||
case ProtoBuf.TYPES["bytes"]:
|
||||
if (value.remaining() < 0)
|
||||
throw Error("Illegal value for "+this.toString(true)+": "+value.remaining()+" bytes remaining");
|
||||
return ByteBuffer.calculateVarint32(value.remaining()) + value.remaining();
|
||||
case ProtoBuf.TYPES["message"]:
|
||||
n = this.resolvedType.calculate(value);
|
||||
return ByteBuffer.calculateVarint32(n) + n;
|
||||
case ProtoBuf.TYPES["group"]:
|
||||
n = this.resolvedType.calculate(value);
|
||||
return n + ByteBuffer.calculateVarint32((id << 3) | ProtoBuf.WIRE_TYPES.ENDGROUP);
|
||||
}
|
||||
// We should never end here
|
||||
throw Error("[INTERNAL] Illegal value to encode in "+this.toString(true)+": "+value+" (unknown type)");
|
||||
};
|
||||
|
||||
/**
|
||||
* Encodes a value to the specified buffer. Does not encode the key.
|
||||
* @param {number} id Field number
|
||||
* @param {*} value Field value
|
||||
* @param {ByteBuffer} buffer ByteBuffer to encode to
|
||||
* @return {ByteBuffer} The ByteBuffer for chaining
|
||||
* @throws {Error} If the value cannot be encoded
|
||||
* @expose
|
||||
*/
|
||||
ElementPrototype.encodeValue = function(id, value, buffer) {
|
||||
if (value === null) return buffer; // Nothing to encode
|
||||
// Tag has already been written
|
||||
|
||||
switch (this.type) {
|
||||
// 32bit signed varint
|
||||
case ProtoBuf.TYPES["int32"]:
|
||||
// "If you use int32 or int64 as the type for a negative number, the resulting varint is always ten bytes
|
||||
// long – it is, effectively, treated like a very large unsigned integer." (see #122)
|
||||
if (value < 0)
|
||||
buffer.writeVarint64(value);
|
||||
else
|
||||
buffer.writeVarint32(value);
|
||||
break;
|
||||
|
||||
// 32bit unsigned varint
|
||||
case ProtoBuf.TYPES["uint32"]:
|
||||
buffer.writeVarint32(value);
|
||||
break;
|
||||
|
||||
// 32bit varint zig-zag
|
||||
case ProtoBuf.TYPES["sint32"]:
|
||||
buffer.writeVarint32ZigZag(value);
|
||||
break;
|
||||
|
||||
// Fixed unsigned 32bit
|
||||
case ProtoBuf.TYPES["fixed32"]:
|
||||
buffer.writeUint32(value);
|
||||
break;
|
||||
|
||||
// Fixed signed 32bit
|
||||
case ProtoBuf.TYPES["sfixed32"]:
|
||||
buffer.writeInt32(value);
|
||||
break;
|
||||
|
||||
// 64bit varint as-is
|
||||
case ProtoBuf.TYPES["int64"]:
|
||||
case ProtoBuf.TYPES["uint64"]:
|
||||
buffer.writeVarint64(value); // throws
|
||||
break;
|
||||
|
||||
// 64bit varint zig-zag
|
||||
case ProtoBuf.TYPES["sint64"]:
|
||||
buffer.writeVarint64ZigZag(value); // throws
|
||||
break;
|
||||
|
||||
// Fixed unsigned 64bit
|
||||
case ProtoBuf.TYPES["fixed64"]:
|
||||
buffer.writeUint64(value); // throws
|
||||
break;
|
||||
|
||||
// Fixed signed 64bit
|
||||
case ProtoBuf.TYPES["sfixed64"]:
|
||||
buffer.writeInt64(value); // throws
|
||||
break;
|
||||
|
||||
// Bool
|
||||
case ProtoBuf.TYPES["bool"]:
|
||||
if (typeof value === 'string')
|
||||
buffer.writeVarint32(value.toLowerCase() === 'false' ? 0 : !!value);
|
||||
else
|
||||
buffer.writeVarint32(value ? 1 : 0);
|
||||
break;
|
||||
|
||||
// Constant enum value
|
||||
case ProtoBuf.TYPES["enum"]:
|
||||
buffer.writeVarint32(value);
|
||||
break;
|
||||
|
||||
// 32bit float
|
||||
case ProtoBuf.TYPES["float"]:
|
||||
buffer.writeFloat32(value);
|
||||
break;
|
||||
|
||||
// 64bit float
|
||||
case ProtoBuf.TYPES["double"]:
|
||||
buffer.writeFloat64(value);
|
||||
break;
|
||||
|
||||
// Length-delimited string
|
||||
case ProtoBuf.TYPES["string"]:
|
||||
buffer.writeVString(value);
|
||||
break;
|
||||
|
||||
// Length-delimited bytes
|
||||
case ProtoBuf.TYPES["bytes"]:
|
||||
if (value.remaining() < 0)
|
||||
throw Error("Illegal value for "+this.toString(true)+": "+value.remaining()+" bytes remaining");
|
||||
var prevOffset = value.offset;
|
||||
buffer.writeVarint32(value.remaining());
|
||||
buffer.append(value);
|
||||
value.offset = prevOffset;
|
||||
break;
|
||||
|
||||
// Embedded message
|
||||
case ProtoBuf.TYPES["message"]:
|
||||
var bb = new ByteBuffer().LE();
|
||||
this.resolvedType.encode(value, bb);
|
||||
buffer.writeVarint32(bb.offset);
|
||||
buffer.append(bb.flip());
|
||||
break;
|
||||
|
||||
// Legacy group
|
||||
case ProtoBuf.TYPES["group"]:
|
||||
this.resolvedType.encode(value, buffer);
|
||||
buffer.writeVarint32((id << 3) | ProtoBuf.WIRE_TYPES.ENDGROUP);
|
||||
break;
|
||||
|
||||
default:
|
||||
// We should never end here
|
||||
throw Error("[INTERNAL] Illegal value to encode in "+this.toString(true)+": "+value+" (unknown type)");
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Decode one element value from the specified buffer.
|
||||
* @param {ByteBuffer} buffer ByteBuffer to decode from
|
||||
* @param {number} wireType The field wire type
|
||||
* @param {number} id The field number
|
||||
* @return {*} Decoded value
|
||||
* @throws {Error} If the field cannot be decoded
|
||||
* @expose
|
||||
*/
|
||||
ElementPrototype.decode = function(buffer, wireType, id) {
|
||||
if (wireType != this.type.wireType)
|
||||
throw Error("Unexpected wire type for element");
|
||||
|
||||
var value, nBytes;
|
||||
switch (this.type) {
|
||||
// 32bit signed varint
|
||||
case ProtoBuf.TYPES["int32"]:
|
||||
return buffer.readVarint32() | 0;
|
||||
|
||||
// 32bit unsigned varint
|
||||
case ProtoBuf.TYPES["uint32"]:
|
||||
return buffer.readVarint32() >>> 0;
|
||||
|
||||
// 32bit signed varint zig-zag
|
||||
case ProtoBuf.TYPES["sint32"]:
|
||||
return buffer.readVarint32ZigZag() | 0;
|
||||
|
||||
// Fixed 32bit unsigned
|
||||
case ProtoBuf.TYPES["fixed32"]:
|
||||
return buffer.readUint32() >>> 0;
|
||||
|
||||
case ProtoBuf.TYPES["sfixed32"]:
|
||||
return buffer.readInt32() | 0;
|
||||
|
||||
// 64bit signed varint
|
||||
case ProtoBuf.TYPES["int64"]:
|
||||
return buffer.readVarint64();
|
||||
|
||||
// 64bit unsigned varint
|
||||
case ProtoBuf.TYPES["uint64"]:
|
||||
return buffer.readVarint64().toUnsigned();
|
||||
|
||||
// 64bit signed varint zig-zag
|
||||
case ProtoBuf.TYPES["sint64"]:
|
||||
return buffer.readVarint64ZigZag();
|
||||
|
||||
// Fixed 64bit unsigned
|
||||
case ProtoBuf.TYPES["fixed64"]:
|
||||
return buffer.readUint64();
|
||||
|
||||
// Fixed 64bit signed
|
||||
case ProtoBuf.TYPES["sfixed64"]:
|
||||
return buffer.readInt64();
|
||||
|
||||
// Bool varint
|
||||
case ProtoBuf.TYPES["bool"]:
|
||||
return !!buffer.readVarint32();
|
||||
|
||||
// Constant enum value (varint)
|
||||
case ProtoBuf.TYPES["enum"]:
|
||||
// The following Builder.Message#set will already throw
|
||||
return buffer.readVarint32();
|
||||
|
||||
// 32bit float
|
||||
case ProtoBuf.TYPES["float"]:
|
||||
return buffer.readFloat();
|
||||
|
||||
// 64bit float
|
||||
case ProtoBuf.TYPES["double"]:
|
||||
return buffer.readDouble();
|
||||
|
||||
// Length-delimited string
|
||||
case ProtoBuf.TYPES["string"]:
|
||||
return buffer.readVString();
|
||||
|
||||
// Length-delimited bytes
|
||||
case ProtoBuf.TYPES["bytes"]: {
|
||||
nBytes = buffer.readVarint32();
|
||||
if (buffer.remaining() < nBytes)
|
||||
throw Error("Illegal number of bytes for "+this.toString(true)+": "+nBytes+" required but got only "+buffer.remaining());
|
||||
value = buffer.clone(); // Offset already set
|
||||
value.limit = value.offset+nBytes;
|
||||
buffer.offset += nBytes;
|
||||
return value;
|
||||
}
|
||||
|
||||
// Length-delimited embedded message
|
||||
case ProtoBuf.TYPES["message"]: {
|
||||
nBytes = buffer.readVarint32();
|
||||
return this.resolvedType.decode(buffer, nBytes);
|
||||
}
|
||||
|
||||
// Legacy group
|
||||
case ProtoBuf.TYPES["group"]:
|
||||
return this.resolvedType.decode(buffer, -1, id);
|
||||
}
|
||||
|
||||
// We should never end here
|
||||
throw Error("[INTERNAL] Illegal decode type");
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a value from a string to the canonical element type.
|
||||
*
|
||||
* Legal only when isMapKey is true.
|
||||
*
|
||||
* @param {string} str The string value
|
||||
* @returns {*} The value
|
||||
*/
|
||||
ElementPrototype.valueFromString = function(str) {
|
||||
if (!this.isMapKey) {
|
||||
throw Error("valueFromString() called on non-map-key element");
|
||||
}
|
||||
|
||||
switch (this.type) {
|
||||
case ProtoBuf.TYPES["int32"]:
|
||||
case ProtoBuf.TYPES["sint32"]:
|
||||
case ProtoBuf.TYPES["sfixed32"]:
|
||||
case ProtoBuf.TYPES["uint32"]:
|
||||
case ProtoBuf.TYPES["fixed32"]:
|
||||
return this.verifyValue(parseInt(str));
|
||||
|
||||
case ProtoBuf.TYPES["int64"]:
|
||||
case ProtoBuf.TYPES["sint64"]:
|
||||
case ProtoBuf.TYPES["sfixed64"]:
|
||||
case ProtoBuf.TYPES["uint64"]:
|
||||
case ProtoBuf.TYPES["fixed64"]:
|
||||
// Long-based fields support conversions from string already.
|
||||
return this.verifyValue(str);
|
||||
|
||||
case ProtoBuf.TYPES["bool"]:
|
||||
return str === "true";
|
||||
|
||||
case ProtoBuf.TYPES["string"]:
|
||||
return this.verifyValue(str);
|
||||
|
||||
case ProtoBuf.TYPES["bytes"]:
|
||||
return ByteBuffer.fromBinary(str);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a value from the canonical element type to a string.
|
||||
*
|
||||
* It should be the case that `valueFromString(valueToString(val))` returns
|
||||
* a value equivalent to `verifyValue(val)` for every legal value of `val`
|
||||
* according to this element type.
|
||||
*
|
||||
* This may be used when the element must be stored or used as a string,
|
||||
* e.g., as a map key on an Object.
|
||||
*
|
||||
* Legal only when isMapKey is true.
|
||||
*
|
||||
* @param {*} val The value
|
||||
* @returns {string} The string form of the value.
|
||||
*/
|
||||
ElementPrototype.valueToString = function(value) {
|
||||
if (!this.isMapKey) {
|
||||
throw Error("valueToString() called on non-map-key element");
|
||||
}
|
||||
|
||||
if (this.type === ProtoBuf.TYPES["bytes"]) {
|
||||
return value.toString("binary");
|
||||
} else {
|
||||
return value.toString();
|
||||
}
|
||||
};
|
||||
68
node_modules/protobufjs/src/ProtoBuf/Reflect/Enum.js
generated
vendored
Normal file
68
node_modules/protobufjs/src/ProtoBuf/Reflect/Enum.js
generated
vendored
Normal file
@ -0,0 +1,68 @@
|
||||
/**
|
||||
* Constructs a new Enum.
|
||||
* @exports ProtoBuf.Reflect.Enum
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.T} parent Parent Reflect object
|
||||
* @param {string} name Enum name
|
||||
* @param {Object.<string,*>=} options Enum options
|
||||
* @param {string?} syntax The syntax level (e.g., proto3)
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.Namespace
|
||||
*/
|
||||
var Enum = function(builder, parent, name, options, syntax) {
|
||||
Namespace.call(this, builder, parent, name, options, syntax);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Enum";
|
||||
|
||||
/**
|
||||
* Runtime enum object.
|
||||
* @type {Object.<string,number>|null}
|
||||
* @expose
|
||||
*/
|
||||
this.object = null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets the string name of an enum value.
|
||||
* @param {!ProtoBuf.Builder.Enum} enm Runtime enum
|
||||
* @param {number} value Enum value
|
||||
* @returns {?string} Name or `null` if not present
|
||||
* @expose
|
||||
*/
|
||||
Enum.getName = function(enm, value) {
|
||||
var keys = Object.keys(enm);
|
||||
for (var i=0, key; i<keys.length; ++i)
|
||||
if (enm[key = keys[i]] === value)
|
||||
return key;
|
||||
return null;
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Enum.prototype
|
||||
* @inner
|
||||
*/
|
||||
var EnumPrototype = Enum.prototype = Object.create(Namespace.prototype);
|
||||
|
||||
/**
|
||||
* Builds this enum and returns the runtime counterpart.
|
||||
* @param {boolean} rebuild Whether to rebuild or not, defaults to false
|
||||
* @returns {!Object.<string,number>}
|
||||
* @expose
|
||||
*/
|
||||
EnumPrototype.build = function(rebuild) {
|
||||
if (this.object && !rebuild)
|
||||
return this.object;
|
||||
var enm = new ProtoBuf.Builder.Enum(),
|
||||
values = this.getChildren(Enum.Value);
|
||||
for (var i=0, k=values.length; i<k; ++i)
|
||||
enm[values[i]['name']] = values[i]['id'];
|
||||
if (Object.defineProperty)
|
||||
Object.defineProperty(enm, '$options', {
|
||||
"value": this.buildOpt(),
|
||||
"enumerable": false
|
||||
});
|
||||
return this.object = enm;
|
||||
};
|
||||
28
node_modules/protobufjs/src/ProtoBuf/Reflect/Enum/Value.js
generated
vendored
Normal file
28
node_modules/protobufjs/src/ProtoBuf/Reflect/Enum/Value.js
generated
vendored
Normal file
@ -0,0 +1,28 @@
|
||||
/**
|
||||
* Constructs a new Enum Value.
|
||||
* @exports ProtoBuf.Reflect.Enum.Value
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Enum} enm Enum reference
|
||||
* @param {string} name Field name
|
||||
* @param {number} id Unique field id
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.T
|
||||
*/
|
||||
var Value = function(builder, enm, name, id) {
|
||||
T.call(this, builder, enm, name);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Enum.Value";
|
||||
|
||||
/**
|
||||
* Unique enum value id.
|
||||
* @type {number}
|
||||
* @expose
|
||||
*/
|
||||
this.id = id;
|
||||
};
|
||||
|
||||
// Extends T
|
||||
Value.prototype = Object.create(T.prototype);
|
||||
22
node_modules/protobufjs/src/ProtoBuf/Reflect/Extension.js
generated
vendored
Normal file
22
node_modules/protobufjs/src/ProtoBuf/Reflect/Extension.js
generated
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
/**
|
||||
* An extension (field).
|
||||
* @exports ProtoBuf.Reflect.Extension
|
||||
* @constructor
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.T} parent Parent object
|
||||
* @param {string} name Object name
|
||||
* @param {!ProtoBuf.Reflect.Message.Field} field Extension field
|
||||
*/
|
||||
var Extension = function(builder, parent, name, field) {
|
||||
T.call(this, builder, parent, name);
|
||||
|
||||
/**
|
||||
* Extended message field.
|
||||
* @type {!ProtoBuf.Reflect.Message.Field}
|
||||
* @expose
|
||||
*/
|
||||
this.field = field;
|
||||
};
|
||||
|
||||
// Extends T
|
||||
Extension.prototype = Object.create(T.prototype);
|
||||
287
node_modules/protobufjs/src/ProtoBuf/Reflect/Message.js
generated
vendored
Normal file
287
node_modules/protobufjs/src/ProtoBuf/Reflect/Message.js
generated
vendored
Normal file
@ -0,0 +1,287 @@
|
||||
/**
|
||||
* Constructs a new Message.
|
||||
* @exports ProtoBuf.Reflect.Message
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Namespace} parent Parent message or namespace
|
||||
* @param {string} name Message name
|
||||
* @param {Object.<string,*>=} options Message options
|
||||
* @param {boolean=} isGroup `true` if this is a legacy group
|
||||
* @param {string?} syntax The syntax level of this definition (e.g., proto3)
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.Namespace
|
||||
*/
|
||||
var Message = function(builder, parent, name, options, isGroup, syntax) {
|
||||
Namespace.call(this, builder, parent, name, options, syntax);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Message";
|
||||
|
||||
/**
|
||||
* Extensions range.
|
||||
* @type {!Array.<number>|undefined}
|
||||
* @expose
|
||||
*/
|
||||
this.extensions = undefined;
|
||||
|
||||
/**
|
||||
* Runtime message class.
|
||||
* @type {?function(new:ProtoBuf.Builder.Message)}
|
||||
* @expose
|
||||
*/
|
||||
this.clazz = null;
|
||||
|
||||
/**
|
||||
* Whether this is a legacy group or not.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
this.isGroup = !!isGroup;
|
||||
|
||||
// The following cached collections are used to efficiently iterate over or look up fields when decoding.
|
||||
|
||||
/**
|
||||
* Cached fields.
|
||||
* @type {?Array.<!ProtoBuf.Reflect.Message.Field>}
|
||||
* @private
|
||||
*/
|
||||
this._fields = null;
|
||||
|
||||
/**
|
||||
* Cached fields by id.
|
||||
* @type {?Object.<number,!ProtoBuf.Reflect.Message.Field>}
|
||||
* @private
|
||||
*/
|
||||
this._fieldsById = null;
|
||||
|
||||
/**
|
||||
* Cached fields by name.
|
||||
* @type {?Object.<string,!ProtoBuf.Reflect.Message.Field>}
|
||||
* @private
|
||||
*/
|
||||
this._fieldsByName = null;
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Message.prototype
|
||||
* @inner
|
||||
*/
|
||||
var MessagePrototype = Message.prototype = Object.create(Namespace.prototype);
|
||||
|
||||
/**
|
||||
* Builds the message and returns the runtime counterpart, which is a fully functional class.
|
||||
* @see ProtoBuf.Builder.Message
|
||||
* @param {boolean=} rebuild Whether to rebuild or not, defaults to false
|
||||
* @return {ProtoBuf.Reflect.Message} Message class
|
||||
* @throws {Error} If the message cannot be built
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.build = function(rebuild) {
|
||||
if (this.clazz && !rebuild)
|
||||
return this.clazz;
|
||||
|
||||
// Create the runtime Message class in its own scope
|
||||
var clazz = (function(ProtoBuf, T) {
|
||||
|
||||
//? include("../Builder/Message.js");
|
||||
|
||||
return Message;
|
||||
|
||||
})(ProtoBuf, this);
|
||||
|
||||
// Static enums and prototyped sub-messages / cached collections
|
||||
this._fields = [];
|
||||
this._fieldsById = {};
|
||||
this._fieldsByName = {};
|
||||
this._oneofsByName = {};
|
||||
for (var i=0, k=this.children.length, child; i<k; i++) {
|
||||
child = this.children[i];
|
||||
if (child instanceof Enum || child instanceof Message || child instanceof Service) {
|
||||
if (clazz.hasOwnProperty(child.name))
|
||||
throw Error("Illegal reflect child of "+this.toString(true)+": "+child.toString(true)+" cannot override static property '"+child.name+"'");
|
||||
clazz[child.name] = child.build();
|
||||
} else if (child instanceof Message.Field)
|
||||
child.build(),
|
||||
this._fields.push(child),
|
||||
this._fieldsById[child.id] = child,
|
||||
this._fieldsByName[child.name] = child;
|
||||
else if (child instanceof Message.OneOf) {
|
||||
this._oneofsByName[child.name] = child;
|
||||
}
|
||||
else if (!(child instanceof Message.OneOf) && !(child instanceof Extension)) // Not built
|
||||
throw Error("Illegal reflect child of "+this.toString(true)+": "+this.children[i].toString(true));
|
||||
}
|
||||
|
||||
return this.clazz = clazz;
|
||||
};
|
||||
|
||||
/**
|
||||
* Encodes a runtime message's contents to the specified buffer.
|
||||
* @param {!ProtoBuf.Builder.Message} message Runtime message to encode
|
||||
* @param {ByteBuffer} buffer ByteBuffer to write to
|
||||
* @param {boolean=} noVerify Whether to not verify field values, defaults to `false`
|
||||
* @return {ByteBuffer} The ByteBuffer for chaining
|
||||
* @throws {Error} If required fields are missing or the message cannot be encoded for another reason
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.encode = function(message, buffer, noVerify) {
|
||||
var fieldMissing = null,
|
||||
field;
|
||||
for (var i=0, k=this._fields.length, val; i<k; ++i) {
|
||||
field = this._fields[i];
|
||||
val = message[field.name];
|
||||
if (field.required && val === null) {
|
||||
if (fieldMissing === null)
|
||||
fieldMissing = field;
|
||||
} else
|
||||
field.encode(noVerify ? val : field.verifyValue(val), buffer, message);
|
||||
}
|
||||
if (fieldMissing !== null) {
|
||||
var err = Error("Missing at least one required field for "+this.toString(true)+": "+fieldMissing);
|
||||
err["encoded"] = buffer; // Still expose what we got
|
||||
throw(err);
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculates a runtime message's byte length.
|
||||
* @param {!ProtoBuf.Builder.Message} message Runtime message to encode
|
||||
* @returns {number} Byte length
|
||||
* @throws {Error} If required fields are missing or the message cannot be calculated for another reason
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.calculate = function(message) {
|
||||
for (var n=0, i=0, k=this._fields.length, field, val; i<k; ++i) {
|
||||
field = this._fields[i];
|
||||
val = message[field.name];
|
||||
if (field.required && val === null)
|
||||
throw Error("Missing at least one required field for "+this.toString(true)+": "+field);
|
||||
else
|
||||
n += field.calculate(val, message);
|
||||
}
|
||||
return n;
|
||||
};
|
||||
|
||||
/**
|
||||
* Skips all data until the end of the specified group has been reached.
|
||||
* @param {number} expectedId Expected GROUPEND id
|
||||
* @param {!ByteBuffer} buf ByteBuffer
|
||||
* @returns {boolean} `true` if a value as been skipped, `false` if the end has been reached
|
||||
* @throws {Error} If it wasn't possible to find the end of the group (buffer overrun or end tag mismatch)
|
||||
* @inner
|
||||
*/
|
||||
function skipTillGroupEnd(expectedId, buf) {
|
||||
var tag = buf.readVarint32(), // Throws on OOB
|
||||
wireType = tag & 0x07,
|
||||
id = tag >>> 3;
|
||||
switch (wireType) {
|
||||
case ProtoBuf.WIRE_TYPES.VARINT:
|
||||
do tag = buf.readUint8();
|
||||
while ((tag & 0x80) === 0x80);
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.BITS64:
|
||||
buf.offset += 8;
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.LDELIM:
|
||||
tag = buf.readVarint32(); // reads the varint
|
||||
buf.offset += tag; // skips n bytes
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.STARTGROUP:
|
||||
skipTillGroupEnd(id, buf);
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.ENDGROUP:
|
||||
if (id === expectedId)
|
||||
return false;
|
||||
else
|
||||
throw Error("Illegal GROUPEND after unknown group: "+id+" ("+expectedId+" expected)");
|
||||
case ProtoBuf.WIRE_TYPES.BITS32:
|
||||
buf.offset += 4;
|
||||
break;
|
||||
default:
|
||||
throw Error("Illegal wire type in unknown group "+expectedId+": "+wireType);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decodes an encoded message and returns the decoded message.
|
||||
* @param {ByteBuffer} buffer ByteBuffer to decode from
|
||||
* @param {number=} length Message length. Defaults to decode all remaining data.
|
||||
* @param {number=} expectedGroupEndId Expected GROUPEND id if this is a legacy group
|
||||
* @return {ProtoBuf.Builder.Message} Decoded message
|
||||
* @throws {Error} If the message cannot be decoded
|
||||
* @expose
|
||||
*/
|
||||
MessagePrototype.decode = function(buffer, length, expectedGroupEndId) {
|
||||
if (typeof length !== 'number')
|
||||
length = -1;
|
||||
var start = buffer.offset,
|
||||
msg = new (this.clazz)(),
|
||||
tag, wireType, id, field;
|
||||
while (buffer.offset < start+length || (length === -1 && buffer.remaining() > 0)) {
|
||||
tag = buffer.readVarint32();
|
||||
wireType = tag & 0x07;
|
||||
id = tag >>> 3;
|
||||
if (wireType === ProtoBuf.WIRE_TYPES.ENDGROUP) {
|
||||
if (id !== expectedGroupEndId)
|
||||
throw Error("Illegal group end indicator for "+this.toString(true)+": "+id+" ("+(expectedGroupEndId ? expectedGroupEndId+" expected" : "not a group")+")");
|
||||
break;
|
||||
}
|
||||
if (!(field = this._fieldsById[id])) {
|
||||
// "messages created by your new code can be parsed by your old code: old binaries simply ignore the new field when parsing."
|
||||
switch (wireType) {
|
||||
case ProtoBuf.WIRE_TYPES.VARINT:
|
||||
buffer.readVarint32();
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.BITS32:
|
||||
buffer.offset += 4;
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.BITS64:
|
||||
buffer.offset += 8;
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.LDELIM:
|
||||
var len = buffer.readVarint32();
|
||||
buffer.offset += len;
|
||||
break;
|
||||
case ProtoBuf.WIRE_TYPES.STARTGROUP:
|
||||
while (skipTillGroupEnd(id, buffer)) {}
|
||||
break;
|
||||
default:
|
||||
throw Error("Illegal wire type for unknown field "+id+" in "+this.toString(true)+"#decode: "+wireType);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (field.repeated && !field.options["packed"]) {
|
||||
msg[field.name].push(field.decode(wireType, buffer));
|
||||
} else if (field.map) {
|
||||
var keyval = field.decode(wireType, buffer);
|
||||
msg[field.name].set(keyval[0], keyval[1]);
|
||||
} else {
|
||||
msg[field.name] = field.decode(wireType, buffer);
|
||||
if (field.oneof) { // Field is part of an OneOf (not a virtual OneOf field)
|
||||
var currentField = msg[field.oneof.name]; // Virtual field references currently set field
|
||||
if (currentField !== null && currentField !== field.name)
|
||||
msg[currentField] = null; // Clear currently set field
|
||||
msg[field.oneof.name] = field.name; // Point virtual field at this field
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check if all required fields are present and set default values for optional fields that are not
|
||||
for (var i=0, k=this._fields.length; i<k; ++i) {
|
||||
field = this._fields[i];
|
||||
if (msg[field.name] === null) {
|
||||
if (this.syntax === "proto3") { // Proto3 sets default values by specification
|
||||
msg[field.name] = field.defaultValue;
|
||||
} else if (field.required) {
|
||||
var err = Error("Missing at least one required field for " + this.toString(true) + ": " + field.name);
|
||||
err["decoded"] = msg; // Still expose what we got
|
||||
throw(err);
|
||||
} else if (ProtoBuf.populateDefaults && field.defaultValue !== null)
|
||||
msg[field.name] = field.defaultValue;
|
||||
}
|
||||
}
|
||||
return msg;
|
||||
};
|
||||
26
node_modules/protobufjs/src/ProtoBuf/Reflect/Message/ExtensionField.js
generated
vendored
Normal file
26
node_modules/protobufjs/src/ProtoBuf/Reflect/Message/ExtensionField.js
generated
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
/**
|
||||
* Constructs a new Message ExtensionField.
|
||||
* @exports ProtoBuf.Reflect.Message.ExtensionField
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Message} message Message reference
|
||||
* @param {string} rule Rule, one of requried, optional, repeated
|
||||
* @param {string} type Data type, e.g. int32
|
||||
* @param {string} name Field name
|
||||
* @param {number} id Unique field id
|
||||
* @param {!Object.<string,*>=} options Options
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.Message.Field
|
||||
*/
|
||||
var ExtensionField = function(builder, message, rule, type, name, id, options) {
|
||||
Field.call(this, builder, message, rule, /* keytype = */ null, type, name, id, options);
|
||||
|
||||
/**
|
||||
* Extension reference.
|
||||
* @type {!ProtoBuf.Reflect.Extension}
|
||||
* @expose
|
||||
*/
|
||||
this.extension;
|
||||
};
|
||||
|
||||
// Extends Field
|
||||
ExtensionField.prototype = Object.create(Field.prototype);
|
||||
458
node_modules/protobufjs/src/ProtoBuf/Reflect/Message/Field.js
generated
vendored
Normal file
458
node_modules/protobufjs/src/ProtoBuf/Reflect/Message/Field.js
generated
vendored
Normal file
@ -0,0 +1,458 @@
|
||||
/**
|
||||
* Constructs a new Message Field.
|
||||
* @exports ProtoBuf.Reflect.Message.Field
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Message} message Message reference
|
||||
* @param {string} rule Rule, one of requried, optional, repeated
|
||||
* @param {string?} keytype Key data type, if any.
|
||||
* @param {string} type Data type, e.g. int32
|
||||
* @param {string} name Field name
|
||||
* @param {number} id Unique field id
|
||||
* @param {Object.<string,*>=} options Options
|
||||
* @param {!ProtoBuf.Reflect.Message.OneOf=} oneof Enclosing OneOf
|
||||
* @param {string?} syntax The syntax level of this definition (e.g., proto3)
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.T
|
||||
*/
|
||||
var Field = function(builder, message, rule, keytype, type, name, id, options, oneof, syntax) {
|
||||
T.call(this, builder, message, name);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Message.Field";
|
||||
|
||||
/**
|
||||
* Message field required flag.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
this.required = rule === "required";
|
||||
|
||||
/**
|
||||
* Message field repeated flag.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
this.repeated = rule === "repeated";
|
||||
|
||||
/**
|
||||
* Message field map flag.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
this.map = rule === "map";
|
||||
|
||||
/**
|
||||
* Message field key type. Type reference string if unresolved, protobuf
|
||||
* type if resolved. Valid only if this.map === true, null otherwise.
|
||||
* @type {string|{name: string, wireType: number}|null}
|
||||
* @expose
|
||||
*/
|
||||
this.keyType = keytype || null;
|
||||
|
||||
/**
|
||||
* Message field type. Type reference string if unresolved, protobuf type if
|
||||
* resolved. In a map field, this is the value type.
|
||||
* @type {string|{name: string, wireType: number}}
|
||||
* @expose
|
||||
*/
|
||||
this.type = type;
|
||||
|
||||
/**
|
||||
* Resolved type reference inside the global namespace.
|
||||
* @type {ProtoBuf.Reflect.T|null}
|
||||
* @expose
|
||||
*/
|
||||
this.resolvedType = null;
|
||||
|
||||
/**
|
||||
* Unique message field id.
|
||||
* @type {number}
|
||||
* @expose
|
||||
*/
|
||||
this.id = id;
|
||||
|
||||
/**
|
||||
* Message field options.
|
||||
* @type {!Object.<string,*>}
|
||||
* @dict
|
||||
* @expose
|
||||
*/
|
||||
this.options = options || {};
|
||||
|
||||
/**
|
||||
* Default value.
|
||||
* @type {*}
|
||||
* @expose
|
||||
*/
|
||||
this.defaultValue = null;
|
||||
|
||||
/**
|
||||
* Enclosing OneOf.
|
||||
* @type {?ProtoBuf.Reflect.Message.OneOf}
|
||||
* @expose
|
||||
*/
|
||||
this.oneof = oneof || null;
|
||||
|
||||
/**
|
||||
* Syntax level of this definition (e.g., proto3).
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.syntax = syntax || 'proto2';
|
||||
|
||||
/**
|
||||
* Original field name.
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.originalName = this.name; // Used to revert camelcase transformation on naming collisions
|
||||
|
||||
/**
|
||||
* Element implementation. Created in build() after types are resolved.
|
||||
* @type {ProtoBuf.Element}
|
||||
* @expose
|
||||
*/
|
||||
this.element = null;
|
||||
|
||||
/**
|
||||
* Key element implementation, for map fields. Created in build() after
|
||||
* types are resolved.
|
||||
* @type {ProtoBuf.Element}
|
||||
* @expose
|
||||
*/
|
||||
this.keyElement = null;
|
||||
|
||||
// Convert field names to camel case notation if the override is set
|
||||
if (this.builder.options['convertFieldsToCamelCase'] && !(this instanceof Message.ExtensionField))
|
||||
this.name = ProtoBuf.Util.toCamelCase(this.name);
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Message.Field.prototype
|
||||
* @inner
|
||||
*/
|
||||
var FieldPrototype = Field.prototype = Object.create(T.prototype);
|
||||
|
||||
/**
|
||||
* Builds the field.
|
||||
* @override
|
||||
* @expose
|
||||
*/
|
||||
FieldPrototype.build = function() {
|
||||
this.element = new Element(this.type, this.resolvedType, false, this.syntax, this.name);
|
||||
if (this.map)
|
||||
this.keyElement = new Element(this.keyType, undefined, true, this.syntax, this.name);
|
||||
|
||||
// In proto3, fields do not have field presence, and every field is set to
|
||||
// its type's default value ("", 0, 0.0, or false).
|
||||
if (this.syntax === 'proto3' && !this.repeated && !this.map)
|
||||
this.defaultValue = Element.defaultFieldValue(this.type);
|
||||
|
||||
// Otherwise, default values are present when explicitly specified
|
||||
else if (typeof this.options['default'] !== 'undefined')
|
||||
this.defaultValue = this.verifyValue(this.options['default']);
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks if the given value can be set for this field.
|
||||
* @param {*} value Value to check
|
||||
* @param {boolean=} skipRepeated Whether to skip the repeated value check or not. Defaults to false.
|
||||
* @return {*} Verified, maybe adjusted, value
|
||||
* @throws {Error} If the value cannot be set for this field
|
||||
* @expose
|
||||
*/
|
||||
FieldPrototype.verifyValue = function(value, skipRepeated) {
|
||||
skipRepeated = skipRepeated || false;
|
||||
var self = this;
|
||||
function fail(val, msg) {
|
||||
throw Error("Illegal value for "+self.toString(true)+" of type "+self.type.name+": "+val+" ("+msg+")");
|
||||
}
|
||||
if (value === null) { // NULL values for optional fields
|
||||
if (this.required)
|
||||
fail(typeof value, "required");
|
||||
if (this.syntax === 'proto3' && this.type !== ProtoBuf.TYPES["message"])
|
||||
fail(typeof value, "proto3 field without field presence cannot be null");
|
||||
return null;
|
||||
}
|
||||
var i;
|
||||
if (this.repeated && !skipRepeated) { // Repeated values as arrays
|
||||
if (!Array.isArray(value))
|
||||
value = [value];
|
||||
var res = [];
|
||||
for (i=0; i<value.length; i++)
|
||||
res.push(this.element.verifyValue(value[i]));
|
||||
return res;
|
||||
}
|
||||
if (this.map && !skipRepeated) { // Map values as objects
|
||||
if (!(value instanceof ProtoBuf.Map)) {
|
||||
// If not already a Map, attempt to convert.
|
||||
if (!(value instanceof Object)) {
|
||||
fail(typeof value,
|
||||
"expected ProtoBuf.Map or raw object for map field");
|
||||
}
|
||||
return new ProtoBuf.Map(this, value);
|
||||
} else {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
// All non-repeated fields expect no array
|
||||
if (!this.repeated && Array.isArray(value))
|
||||
fail(typeof value, "no array expected");
|
||||
|
||||
return this.element.verifyValue(value);
|
||||
};
|
||||
|
||||
/**
|
||||
* Determines whether the field will have a presence on the wire given its
|
||||
* value.
|
||||
* @param {*} value Verified field value
|
||||
* @param {!ProtoBuf.Builder.Message} message Runtime message
|
||||
* @return {boolean} Whether the field will be present on the wire
|
||||
*/
|
||||
FieldPrototype.hasWirePresence = function(value, message) {
|
||||
if (this.syntax !== 'proto3')
|
||||
return (value !== null);
|
||||
if (this.oneof && message[this.oneof.name] === this.name)
|
||||
return true;
|
||||
switch (this.type) {
|
||||
case ProtoBuf.TYPES["int32"]:
|
||||
case ProtoBuf.TYPES["sint32"]:
|
||||
case ProtoBuf.TYPES["sfixed32"]:
|
||||
case ProtoBuf.TYPES["uint32"]:
|
||||
case ProtoBuf.TYPES["fixed32"]:
|
||||
return value !== 0;
|
||||
|
||||
case ProtoBuf.TYPES["int64"]:
|
||||
case ProtoBuf.TYPES["sint64"]:
|
||||
case ProtoBuf.TYPES["sfixed64"]:
|
||||
case ProtoBuf.TYPES["uint64"]:
|
||||
case ProtoBuf.TYPES["fixed64"]:
|
||||
return value.low !== 0 || value.high !== 0;
|
||||
|
||||
case ProtoBuf.TYPES["bool"]:
|
||||
return value;
|
||||
|
||||
case ProtoBuf.TYPES["float"]:
|
||||
case ProtoBuf.TYPES["double"]:
|
||||
return value !== 0.0;
|
||||
|
||||
case ProtoBuf.TYPES["string"]:
|
||||
return value.length > 0;
|
||||
|
||||
case ProtoBuf.TYPES["bytes"]:
|
||||
return value.remaining() > 0;
|
||||
|
||||
case ProtoBuf.TYPES["enum"]:
|
||||
return value !== 0;
|
||||
|
||||
case ProtoBuf.TYPES["message"]:
|
||||
return value !== null;
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Encodes the specified field value to the specified buffer.
|
||||
* @param {*} value Verified field value
|
||||
* @param {ByteBuffer} buffer ByteBuffer to encode to
|
||||
* @param {!ProtoBuf.Builder.Message} message Runtime message
|
||||
* @return {ByteBuffer} The ByteBuffer for chaining
|
||||
* @throws {Error} If the field cannot be encoded
|
||||
* @expose
|
||||
*/
|
||||
FieldPrototype.encode = function(value, buffer, message) {
|
||||
if (this.type === null || typeof this.type !== 'object')
|
||||
throw Error("[INTERNAL] Unresolved type in "+this.toString(true)+": "+this.type);
|
||||
if (value === null || (this.repeated && value.length == 0))
|
||||
return buffer; // Optional omitted
|
||||
try {
|
||||
if (this.repeated) {
|
||||
var i;
|
||||
// "Only repeated fields of primitive numeric types (types which use the varint, 32-bit, or 64-bit wire
|
||||
// types) can be declared 'packed'."
|
||||
if (this.options["packed"] && ProtoBuf.PACKABLE_WIRE_TYPES.indexOf(this.type.wireType) >= 0) {
|
||||
// "All of the elements of the field are packed into a single key-value pair with wire type 2
|
||||
// (length-delimited). Each element is encoded the same way it would be normally, except without a
|
||||
// tag preceding it."
|
||||
buffer.writeVarint32((this.id << 3) | ProtoBuf.WIRE_TYPES.LDELIM);
|
||||
buffer.ensureCapacity(buffer.offset += 1); // We do not know the length yet, so let's assume a varint of length 1
|
||||
var start = buffer.offset; // Remember where the contents begin
|
||||
for (i=0; i<value.length; i++)
|
||||
this.element.encodeValue(this.id, value[i], buffer);
|
||||
var len = buffer.offset-start,
|
||||
varintLen = ByteBuffer.calculateVarint32(len);
|
||||
if (varintLen > 1) { // We need to move the contents
|
||||
var contents = buffer.slice(start, buffer.offset);
|
||||
start += varintLen-1;
|
||||
buffer.offset = start;
|
||||
buffer.append(contents);
|
||||
}
|
||||
buffer.writeVarint32(len, start-varintLen);
|
||||
} else {
|
||||
// "If your message definition has repeated elements (without the [packed=true] option), the encoded
|
||||
// message has zero or more key-value pairs with the same tag number"
|
||||
for (i=0; i<value.length; i++)
|
||||
buffer.writeVarint32((this.id << 3) | this.type.wireType),
|
||||
this.element.encodeValue(this.id, value[i], buffer);
|
||||
}
|
||||
} else if (this.map) {
|
||||
// Write out each map entry as a submessage.
|
||||
value.forEach(function(val, key, m) {
|
||||
// Compute the length of the submessage (key, val) pair.
|
||||
var length =
|
||||
ByteBuffer.calculateVarint32((1 << 3) | this.keyType.wireType) +
|
||||
this.keyElement.calculateLength(1, key) +
|
||||
ByteBuffer.calculateVarint32((2 << 3) | this.type.wireType) +
|
||||
this.element.calculateLength(2, val);
|
||||
|
||||
// Submessage with wire type of length-delimited.
|
||||
buffer.writeVarint32((this.id << 3) | ProtoBuf.WIRE_TYPES.LDELIM);
|
||||
buffer.writeVarint32(length);
|
||||
|
||||
// Write out the key and val.
|
||||
buffer.writeVarint32((1 << 3) | this.keyType.wireType);
|
||||
this.keyElement.encodeValue(1, key, buffer);
|
||||
buffer.writeVarint32((2 << 3) | this.type.wireType);
|
||||
this.element.encodeValue(2, val, buffer);
|
||||
}, this);
|
||||
} else {
|
||||
if (this.hasWirePresence(value, message)) {
|
||||
buffer.writeVarint32((this.id << 3) | this.type.wireType);
|
||||
this.element.encodeValue(this.id, value, buffer);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
throw Error("Illegal value for "+this.toString(true)+": "+value+" ("+e+")");
|
||||
}
|
||||
return buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculates the length of this field's value on the network level.
|
||||
* @param {*} value Field value
|
||||
* @param {!ProtoBuf.Builder.Message} message Runtime message
|
||||
* @returns {number} Byte length
|
||||
* @expose
|
||||
*/
|
||||
FieldPrototype.calculate = function(value, message) {
|
||||
value = this.verifyValue(value); // May throw
|
||||
if (this.type === null || typeof this.type !== 'object')
|
||||
throw Error("[INTERNAL] Unresolved type in "+this.toString(true)+": "+this.type);
|
||||
if (value === null || (this.repeated && value.length == 0))
|
||||
return 0; // Optional omitted
|
||||
var n = 0;
|
||||
try {
|
||||
if (this.repeated) {
|
||||
var i, ni;
|
||||
if (this.options["packed"] && ProtoBuf.PACKABLE_WIRE_TYPES.indexOf(this.type.wireType) >= 0) {
|
||||
n += ByteBuffer.calculateVarint32((this.id << 3) | ProtoBuf.WIRE_TYPES.LDELIM);
|
||||
ni = 0;
|
||||
for (i=0; i<value.length; i++)
|
||||
ni += this.element.calculateLength(this.id, value[i]);
|
||||
n += ByteBuffer.calculateVarint32(ni);
|
||||
n += ni;
|
||||
} else {
|
||||
for (i=0; i<value.length; i++)
|
||||
n += ByteBuffer.calculateVarint32((this.id << 3) | this.type.wireType),
|
||||
n += this.element.calculateLength(this.id, value[i]);
|
||||
}
|
||||
} else if (this.map) {
|
||||
// Each map entry becomes a submessage.
|
||||
value.forEach(function(val, key, m) {
|
||||
// Compute the length of the submessage (key, val) pair.
|
||||
var length =
|
||||
ByteBuffer.calculateVarint32((1 << 3) | this.keyType.wireType) +
|
||||
this.keyElement.calculateLength(1, key) +
|
||||
ByteBuffer.calculateVarint32((2 << 3) | this.type.wireType) +
|
||||
this.element.calculateLength(2, val);
|
||||
|
||||
n += ByteBuffer.calculateVarint32((this.id << 3) | ProtoBuf.WIRE_TYPES.LDELIM);
|
||||
n += ByteBuffer.calculateVarint32(length);
|
||||
n += length;
|
||||
}, this);
|
||||
} else {
|
||||
if (this.hasWirePresence(value, message)) {
|
||||
n += ByteBuffer.calculateVarint32((this.id << 3) | this.type.wireType);
|
||||
n += this.element.calculateLength(this.id, value);
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
throw Error("Illegal value for "+this.toString(true)+": "+value+" ("+e+")");
|
||||
}
|
||||
return n;
|
||||
};
|
||||
|
||||
/**
|
||||
* Decode the field value from the specified buffer.
|
||||
* @param {number} wireType Leading wire type
|
||||
* @param {ByteBuffer} buffer ByteBuffer to decode from
|
||||
* @param {boolean=} skipRepeated Whether to skip the repeated check or not. Defaults to false.
|
||||
* @return {*} Decoded value: array for packed repeated fields, [key, value] for
|
||||
* map fields, or an individual value otherwise.
|
||||
* @throws {Error} If the field cannot be decoded
|
||||
* @expose
|
||||
*/
|
||||
FieldPrototype.decode = function(wireType, buffer, skipRepeated) {
|
||||
var value, nBytes;
|
||||
|
||||
// We expect wireType to match the underlying type's wireType unless we see
|
||||
// a packed repeated field, or unless this is a map field.
|
||||
var wireTypeOK =
|
||||
(!this.map && wireType == this.type.wireType) ||
|
||||
(!skipRepeated && this.repeated && this.options["packed"] &&
|
||||
wireType == ProtoBuf.WIRE_TYPES.LDELIM) ||
|
||||
(this.map && wireType == ProtoBuf.WIRE_TYPES.LDELIM);
|
||||
if (!wireTypeOK)
|
||||
throw Error("Illegal wire type for field "+this.toString(true)+": "+wireType+" ("+this.type.wireType+" expected)");
|
||||
|
||||
// Handle packed repeated fields.
|
||||
if (wireType == ProtoBuf.WIRE_TYPES.LDELIM && this.repeated && this.options["packed"] && ProtoBuf.PACKABLE_WIRE_TYPES.indexOf(this.type.wireType) >= 0) {
|
||||
if (!skipRepeated) {
|
||||
nBytes = buffer.readVarint32();
|
||||
nBytes = buffer.offset + nBytes; // Limit
|
||||
var values = [];
|
||||
while (buffer.offset < nBytes)
|
||||
values.push(this.decode(this.type.wireType, buffer, true));
|
||||
return values;
|
||||
}
|
||||
// Read the next value otherwise...
|
||||
}
|
||||
|
||||
// Handle maps.
|
||||
if (this.map) {
|
||||
// Read one (key, value) submessage, and return [key, value]
|
||||
var key = Element.defaultFieldValue(this.keyType);
|
||||
value = Element.defaultFieldValue(this.type);
|
||||
|
||||
// Read the length
|
||||
nBytes = buffer.readVarint32();
|
||||
if (buffer.remaining() < nBytes)
|
||||
throw Error("Illegal number of bytes for "+this.toString(true)+": "+nBytes+" required but got only "+buffer.remaining());
|
||||
|
||||
// Get a sub-buffer of this key/value submessage
|
||||
var msgbuf = buffer.clone();
|
||||
msgbuf.limit = msgbuf.offset + nBytes;
|
||||
buffer.offset += nBytes;
|
||||
|
||||
while (msgbuf.remaining() > 0) {
|
||||
var tag = msgbuf.readVarint32();
|
||||
wireType = tag & 0x07;
|
||||
var id = tag >>> 3;
|
||||
if (id === 1) {
|
||||
key = this.keyElement.decode(msgbuf, wireType, id);
|
||||
} else if (id === 2) {
|
||||
value = this.element.decode(msgbuf, wireType, id);
|
||||
} else {
|
||||
throw Error("Unexpected tag in map field key/value submessage");
|
||||
}
|
||||
}
|
||||
|
||||
return [key, value];
|
||||
}
|
||||
|
||||
// Handle singular and non-packed repeated field values.
|
||||
return this.element.decode(buffer, wireType, this.id);
|
||||
};
|
||||
19
node_modules/protobufjs/src/ProtoBuf/Reflect/Message/OneOf.js
generated
vendored
Normal file
19
node_modules/protobufjs/src/ProtoBuf/Reflect/Message/OneOf.js
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
/**
|
||||
* Constructs a new Message OneOf.
|
||||
* @exports ProtoBuf.Reflect.Message.OneOf
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Message} message Message reference
|
||||
* @param {string} name OneOf name
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.T
|
||||
*/
|
||||
var OneOf = function(builder, message, name) {
|
||||
T.call(this, builder, message, name);
|
||||
|
||||
/**
|
||||
* Enclosed fields.
|
||||
* @type {!Array.<!ProtoBuf.Reflect.Message.Field>}
|
||||
* @expose
|
||||
*/
|
||||
this.fields = [];
|
||||
};
|
||||
203
node_modules/protobufjs/src/ProtoBuf/Reflect/Namespace.js
generated
vendored
Normal file
203
node_modules/protobufjs/src/ProtoBuf/Reflect/Namespace.js
generated
vendored
Normal file
@ -0,0 +1,203 @@
|
||||
/**
|
||||
* Constructs a new Namespace.
|
||||
* @exports ProtoBuf.Reflect.Namespace
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {?ProtoBuf.Reflect.Namespace} parent Namespace parent
|
||||
* @param {string} name Namespace name
|
||||
* @param {Object.<string,*>=} options Namespace options
|
||||
* @param {string?} syntax The syntax level of this definition (e.g., proto3)
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.T
|
||||
*/
|
||||
var Namespace = function(builder, parent, name, options, syntax) {
|
||||
T.call(this, builder, parent, name);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Namespace";
|
||||
|
||||
/**
|
||||
* Children inside the namespace.
|
||||
* @type {!Array.<ProtoBuf.Reflect.T>}
|
||||
*/
|
||||
this.children = [];
|
||||
|
||||
/**
|
||||
* Options.
|
||||
* @type {!Object.<string, *>}
|
||||
*/
|
||||
this.options = options || {};
|
||||
|
||||
/**
|
||||
* Syntax level (e.g., proto2 or proto3).
|
||||
* @type {!string}
|
||||
*/
|
||||
this.syntax = syntax || "proto2";
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Namespace.prototype
|
||||
* @inner
|
||||
*/
|
||||
var NamespacePrototype = Namespace.prototype = Object.create(T.prototype);
|
||||
|
||||
/**
|
||||
* Returns an array of the namespace's children.
|
||||
* @param {ProtoBuf.Reflect.T=} type Filter type (returns instances of this type only). Defaults to null (all children).
|
||||
* @return {Array.<ProtoBuf.Reflect.T>}
|
||||
* @expose
|
||||
*/
|
||||
NamespacePrototype.getChildren = function(type) {
|
||||
type = type || null;
|
||||
if (type == null)
|
||||
return this.children.slice();
|
||||
var children = [];
|
||||
for (var i=0, k=this.children.length; i<k; ++i)
|
||||
if (this.children[i] instanceof type)
|
||||
children.push(this.children[i]);
|
||||
return children;
|
||||
};
|
||||
|
||||
/**
|
||||
* Adds a child to the namespace.
|
||||
* @param {ProtoBuf.Reflect.T} child Child
|
||||
* @throws {Error} If the child cannot be added (duplicate)
|
||||
* @expose
|
||||
*/
|
||||
NamespacePrototype.addChild = function(child) {
|
||||
var other;
|
||||
if (other = this.getChild(child.name)) {
|
||||
// Try to revert camelcase transformation on collision
|
||||
if (other instanceof Message.Field && other.name !== other.originalName && this.getChild(other.originalName) === null)
|
||||
other.name = other.originalName; // Revert previous first (effectively keeps both originals)
|
||||
else if (child instanceof Message.Field && child.name !== child.originalName && this.getChild(child.originalName) === null)
|
||||
child.name = child.originalName;
|
||||
else
|
||||
throw Error("Duplicate name in namespace "+this.toString(true)+": "+child.name);
|
||||
}
|
||||
this.children.push(child);
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets a child by its name or id.
|
||||
* @param {string|number} nameOrId Child name or id
|
||||
* @return {?ProtoBuf.Reflect.T} The child or null if not found
|
||||
* @expose
|
||||
*/
|
||||
NamespacePrototype.getChild = function(nameOrId) {
|
||||
var key = typeof nameOrId === 'number' ? 'id' : 'name';
|
||||
for (var i=0, k=this.children.length; i<k; ++i)
|
||||
if (this.children[i][key] === nameOrId)
|
||||
return this.children[i];
|
||||
return null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Resolves a reflect object inside of this namespace.
|
||||
* @param {string|!Array.<string>} qn Qualified name to resolve
|
||||
* @param {boolean=} excludeNonNamespace Excludes non-namespace types, defaults to `false`
|
||||
* @return {?ProtoBuf.Reflect.Namespace} The resolved type or null if not found
|
||||
* @expose
|
||||
*/
|
||||
NamespacePrototype.resolve = function(qn, excludeNonNamespace) {
|
||||
var part = typeof qn === 'string' ? qn.split(".") : qn,
|
||||
ptr = this,
|
||||
i = 0;
|
||||
if (part[i] === "") { // Fully qualified name, e.g. ".My.Message'
|
||||
while (ptr.parent !== null)
|
||||
ptr = ptr.parent;
|
||||
i++;
|
||||
}
|
||||
var child;
|
||||
do {
|
||||
do {
|
||||
if (!(ptr instanceof Reflect.Namespace)) {
|
||||
ptr = null;
|
||||
break;
|
||||
}
|
||||
child = ptr.getChild(part[i]);
|
||||
if (!child || !(child instanceof Reflect.T) || (excludeNonNamespace && !(child instanceof Reflect.Namespace))) {
|
||||
ptr = null;
|
||||
break;
|
||||
}
|
||||
ptr = child; i++;
|
||||
} while (i < part.length);
|
||||
if (ptr != null)
|
||||
break; // Found
|
||||
// Else search the parent
|
||||
if (this.parent !== null)
|
||||
return this.parent.resolve(qn, excludeNonNamespace);
|
||||
} while (ptr != null);
|
||||
return ptr;
|
||||
};
|
||||
|
||||
/**
|
||||
* Determines the shortest qualified name of the specified type, if any, relative to this namespace.
|
||||
* @param {!ProtoBuf.Reflect.T} t Reflection type
|
||||
* @returns {string} The shortest qualified name or, if there is none, the fqn
|
||||
* @expose
|
||||
*/
|
||||
NamespacePrototype.qn = function(t) {
|
||||
var part = [], ptr = t;
|
||||
do {
|
||||
part.unshift(ptr.name);
|
||||
ptr = ptr.parent;
|
||||
} while (ptr !== null);
|
||||
for (var len=1; len <= part.length; len++) {
|
||||
var qn = part.slice(part.length-len);
|
||||
if (t === this.resolve(qn, t instanceof Reflect.Namespace))
|
||||
return qn.join(".");
|
||||
}
|
||||
return t.fqn();
|
||||
};
|
||||
|
||||
/**
|
||||
* Builds the namespace and returns the runtime counterpart.
|
||||
* @return {Object.<string,Function|Object>} Runtime namespace
|
||||
* @expose
|
||||
*/
|
||||
NamespacePrototype.build = function() {
|
||||
/** @dict */
|
||||
var ns = {};
|
||||
var children = this.children;
|
||||
for (var i=0, k=children.length, child; i<k; ++i) {
|
||||
child = children[i];
|
||||
if (child instanceof Namespace)
|
||||
ns[child.name] = child.build();
|
||||
}
|
||||
if (Object.defineProperty)
|
||||
Object.defineProperty(ns, "$options", { "value": this.buildOpt() });
|
||||
return ns;
|
||||
};
|
||||
|
||||
/**
|
||||
* Builds the namespace's '$options' property.
|
||||
* @return {Object.<string,*>}
|
||||
*/
|
||||
NamespacePrototype.buildOpt = function() {
|
||||
var opt = {},
|
||||
keys = Object.keys(this.options);
|
||||
for (var i=0, k=keys.length; i<k; ++i) {
|
||||
var key = keys[i],
|
||||
val = this.options[keys[i]];
|
||||
// TODO: Options are not resolved, yet.
|
||||
// if (val instanceof Namespace) {
|
||||
// opt[key] = val.build();
|
||||
// } else {
|
||||
opt[key] = val;
|
||||
// }
|
||||
}
|
||||
return opt;
|
||||
};
|
||||
|
||||
/**
|
||||
* Gets the value assigned to the option with the specified name.
|
||||
* @param {string=} name Returns the option value if specified, otherwise all options are returned.
|
||||
* @return {*|Object.<string,*>}null} Option value or NULL if there is no such option
|
||||
*/
|
||||
NamespacePrototype.getOption = function(name) {
|
||||
if (typeof name === 'undefined')
|
||||
return this.options;
|
||||
return typeof this.options[name] !== 'undefined' ? this.options[name] : null;
|
||||
};
|
||||
52
node_modules/protobufjs/src/ProtoBuf/Reflect/Service.js
generated
vendored
Normal file
52
node_modules/protobufjs/src/ProtoBuf/Reflect/Service.js
generated
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Constructs a new Service.
|
||||
* @exports ProtoBuf.Reflect.Service
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Namespace} root Root
|
||||
* @param {string} name Service name
|
||||
* @param {Object.<string,*>=} options Options
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.Namespace
|
||||
*/
|
||||
var Service = function(builder, root, name, options) {
|
||||
Namespace.call(this, builder, root, name, options);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Service";
|
||||
|
||||
/**
|
||||
* Built runtime service class.
|
||||
* @type {?function(new:ProtoBuf.Builder.Service)}
|
||||
*/
|
||||
this.clazz = null;
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Service.prototype
|
||||
* @inner
|
||||
*/
|
||||
var ServicePrototype = Service.prototype = Object.create(Namespace.prototype);
|
||||
|
||||
/**
|
||||
* Builds the service and returns the runtime counterpart, which is a fully functional class.
|
||||
* @see ProtoBuf.Builder.Service
|
||||
* @param {boolean=} rebuild Whether to rebuild or not
|
||||
* @return {Function} Service class
|
||||
* @throws {Error} If the message cannot be built
|
||||
* @expose
|
||||
*/
|
||||
ServicePrototype.build = function(rebuild) {
|
||||
if (this.clazz && !rebuild)
|
||||
return this.clazz;
|
||||
|
||||
// Create the runtime Service class in its own scope
|
||||
return this.clazz = (function(ProtoBuf, T) {
|
||||
|
||||
//? include("../Builder/Service.js");
|
||||
|
||||
return Service;
|
||||
|
||||
})(ProtoBuf, this);
|
||||
};
|
||||
39
node_modules/protobufjs/src/ProtoBuf/Reflect/Service/Method.js
generated
vendored
Normal file
39
node_modules/protobufjs/src/ProtoBuf/Reflect/Service/Method.js
generated
vendored
Normal file
@ -0,0 +1,39 @@
|
||||
/**
|
||||
* Abstract service method.
|
||||
* @exports ProtoBuf.Reflect.Service.Method
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Service} svc Service
|
||||
* @param {string} name Method name
|
||||
* @param {Object.<string,*>=} options Options
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.T
|
||||
*/
|
||||
var Method = function(builder, svc, name, options) {
|
||||
T.call(this, builder, svc, name);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Service.Method";
|
||||
|
||||
/**
|
||||
* Options.
|
||||
* @type {Object.<string, *>}
|
||||
* @expose
|
||||
*/
|
||||
this.options = options || {};
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.Service.Method.prototype
|
||||
* @inner
|
||||
*/
|
||||
var MethodPrototype = Method.prototype = Object.create(T.prototype);
|
||||
|
||||
/**
|
||||
* Builds the method's '$options' property.
|
||||
* @name ProtoBuf.Reflect.Service.Method#buildOpt
|
||||
* @function
|
||||
* @return {Object.<string,*>}
|
||||
*/
|
||||
MethodPrototype.buildOpt = NamespacePrototype.buildOpt;
|
||||
67
node_modules/protobufjs/src/ProtoBuf/Reflect/Service/RPCMethod.js
generated
vendored
Normal file
67
node_modules/protobufjs/src/ProtoBuf/Reflect/Service/RPCMethod.js
generated
vendored
Normal file
@ -0,0 +1,67 @@
|
||||
/**
|
||||
* RPC service method.
|
||||
* @exports ProtoBuf.Reflect.Service.RPCMethod
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {!ProtoBuf.Reflect.Service} svc Service
|
||||
* @param {string} name Method name
|
||||
* @param {string} request Request message name
|
||||
* @param {string} response Response message name
|
||||
* @param {boolean} request_stream Whether requests are streamed
|
||||
* @param {boolean} response_stream Whether responses are streamed
|
||||
* @param {Object.<string,*>=} options Options
|
||||
* @constructor
|
||||
* @extends ProtoBuf.Reflect.Service.Method
|
||||
*/
|
||||
var RPCMethod = function(builder, svc, name, request, response, request_stream, response_stream, options) {
|
||||
Method.call(this, builder, svc, name, options);
|
||||
|
||||
/**
|
||||
* @override
|
||||
*/
|
||||
this.className = "Service.RPCMethod";
|
||||
|
||||
/**
|
||||
* Request message name.
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.requestName = request;
|
||||
|
||||
/**
|
||||
* Response message name.
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.responseName = response;
|
||||
|
||||
/**
|
||||
* Whether requests are streamed
|
||||
* @type {bool}
|
||||
* @expose
|
||||
*/
|
||||
this.requestStream = request_stream;
|
||||
|
||||
/**
|
||||
* Whether responses are streamed
|
||||
* @type {bool}
|
||||
* @expose
|
||||
*/
|
||||
this.responseStream = response_stream;
|
||||
|
||||
/**
|
||||
* Resolved request message type.
|
||||
* @type {ProtoBuf.Reflect.Message}
|
||||
* @expose
|
||||
*/
|
||||
this.resolvedRequestType = null;
|
||||
|
||||
/**
|
||||
* Resolved response message type.
|
||||
* @type {ProtoBuf.Reflect.Message}
|
||||
* @expose
|
||||
*/
|
||||
this.resolvedResponseType = null;
|
||||
};
|
||||
|
||||
// Extends Method
|
||||
RPCMethod.prototype = Object.create(Method.prototype);
|
||||
81
node_modules/protobufjs/src/ProtoBuf/Reflect/T.js
generated
vendored
Normal file
81
node_modules/protobufjs/src/ProtoBuf/Reflect/T.js
generated
vendored
Normal file
@ -0,0 +1,81 @@
|
||||
/**
|
||||
* Constructs a Reflect base class.
|
||||
* @exports ProtoBuf.Reflect.T
|
||||
* @constructor
|
||||
* @abstract
|
||||
* @param {!ProtoBuf.Builder} builder Builder reference
|
||||
* @param {?ProtoBuf.Reflect.T} parent Parent object
|
||||
* @param {string} name Object name
|
||||
*/
|
||||
var T = function(builder, parent, name) {
|
||||
|
||||
/**
|
||||
* Builder reference.
|
||||
* @type {!ProtoBuf.Builder}
|
||||
* @expose
|
||||
*/
|
||||
this.builder = builder;
|
||||
|
||||
/**
|
||||
* Parent object.
|
||||
* @type {?ProtoBuf.Reflect.T}
|
||||
* @expose
|
||||
*/
|
||||
this.parent = parent;
|
||||
|
||||
/**
|
||||
* Object name in namespace.
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.name = name;
|
||||
|
||||
/**
|
||||
* Fully qualified class name
|
||||
* @type {string}
|
||||
* @expose
|
||||
*/
|
||||
this.className;
|
||||
};
|
||||
|
||||
/**
|
||||
* @alias ProtoBuf.Reflect.T.prototype
|
||||
* @inner
|
||||
*/
|
||||
var TPrototype = T.prototype;
|
||||
|
||||
/**
|
||||
* Returns the fully qualified name of this object.
|
||||
* @returns {string} Fully qualified name as of ".PATH.TO.THIS"
|
||||
* @expose
|
||||
*/
|
||||
TPrototype.fqn = function() {
|
||||
var name = this.name,
|
||||
ptr = this;
|
||||
do {
|
||||
ptr = ptr.parent;
|
||||
if (ptr == null)
|
||||
break;
|
||||
name = ptr.name+"."+name;
|
||||
} while (true);
|
||||
return name;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a string representation of this Reflect object (its fully qualified name).
|
||||
* @param {boolean=} includeClass Set to true to include the class name. Defaults to false.
|
||||
* @return String representation
|
||||
* @expose
|
||||
*/
|
||||
TPrototype.toString = function(includeClass) {
|
||||
return (includeClass ? this.className + " " : "") + this.fqn();
|
||||
};
|
||||
|
||||
/**
|
||||
* Builds this type.
|
||||
* @throws {Error} If this type cannot be built directly
|
||||
* @expose
|
||||
*/
|
||||
TPrototype.build = function() {
|
||||
throw Error(this.toString(true)+" cannot be built directly");
|
||||
};
|
||||
116
node_modules/protobufjs/src/ProtoBuf/Util.js
generated
vendored
Normal file
116
node_modules/protobufjs/src/ProtoBuf/Util.js
generated
vendored
Normal file
@ -0,0 +1,116 @@
|
||||
/**
|
||||
* @alias ProtoBuf.Util
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.Util = (function() {
|
||||
"use strict";
|
||||
|
||||
/**
|
||||
* ProtoBuf utilities.
|
||||
* @exports ProtoBuf.Util
|
||||
* @namespace
|
||||
*/
|
||||
var Util = {};
|
||||
|
||||
/**
|
||||
* Flag if running in node or not.
|
||||
* @type {boolean}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
Util.IS_NODE = !!(
|
||||
typeof process === 'object' && process+'' === '[object process]' && !process['browser']
|
||||
);
|
||||
|
||||
/**
|
||||
* Constructs a XMLHttpRequest object.
|
||||
* @return {XMLHttpRequest}
|
||||
* @throws {Error} If XMLHttpRequest is not supported
|
||||
* @expose
|
||||
*/
|
||||
Util.XHR = function() {
|
||||
// No dependencies please, ref: http://www.quirksmode.org/js/xmlhttp.html
|
||||
var XMLHttpFactories = [
|
||||
function () {return new XMLHttpRequest()},
|
||||
function () {return new ActiveXObject("Msxml2.XMLHTTP")},
|
||||
function () {return new ActiveXObject("Msxml3.XMLHTTP")},
|
||||
function () {return new ActiveXObject("Microsoft.XMLHTTP")}
|
||||
];
|
||||
/** @type {?XMLHttpRequest} */
|
||||
var xhr = null;
|
||||
for (var i=0;i<XMLHttpFactories.length;i++) {
|
||||
try { xhr = XMLHttpFactories[i](); }
|
||||
catch (e) { continue; }
|
||||
break;
|
||||
}
|
||||
if (!xhr)
|
||||
throw Error("XMLHttpRequest is not supported");
|
||||
return xhr;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fetches a resource.
|
||||
* @param {string} path Resource path
|
||||
* @param {function(?string)=} callback Callback receiving the resource's contents. If omitted the resource will
|
||||
* be fetched synchronously. If the request failed, contents will be null.
|
||||
* @return {?string|undefined} Resource contents if callback is omitted (null if the request failed), else undefined.
|
||||
* @expose
|
||||
*/
|
||||
Util.fetch = function(path, callback) {
|
||||
if (callback && typeof callback != 'function')
|
||||
callback = null;
|
||||
if (Util.IS_NODE) {
|
||||
var fs = require("fs");
|
||||
if (callback) {
|
||||
fs.readFile(path, function(err, data) {
|
||||
if (err)
|
||||
callback(null);
|
||||
else
|
||||
callback(""+data);
|
||||
});
|
||||
} else
|
||||
try {
|
||||
return fs.readFileSync(path);
|
||||
} catch (e) {
|
||||
return null;
|
||||
}
|
||||
} else {
|
||||
var xhr = Util.XHR();
|
||||
xhr.open('GET', path, callback ? true : false);
|
||||
// xhr.setRequestHeader('User-Agent', 'XMLHTTP/1.0');
|
||||
xhr.setRequestHeader('Accept', 'text/plain');
|
||||
if (typeof xhr.overrideMimeType === 'function') xhr.overrideMimeType('text/plain');
|
||||
if (callback) {
|
||||
xhr.onreadystatechange = function() {
|
||||
if (xhr.readyState != 4) return;
|
||||
if (/* remote */ xhr.status == 200 || /* local */ (xhr.status == 0 && typeof xhr.responseText === 'string'))
|
||||
callback(xhr.responseText);
|
||||
else
|
||||
callback(null);
|
||||
};
|
||||
if (xhr.readyState == 4)
|
||||
return;
|
||||
xhr.send(null);
|
||||
} else {
|
||||
xhr.send(null);
|
||||
if (/* remote */ xhr.status == 200 || /* local */ (xhr.status == 0 && typeof xhr.responseText === 'string'))
|
||||
return xhr.responseText;
|
||||
return null;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts a string to camel case.
|
||||
* @param {string} str
|
||||
* @returns {string}
|
||||
* @expose
|
||||
*/
|
||||
Util.toCamelCase = function(str) {
|
||||
return str.replace(/_([a-zA-Z])/g, function ($0, $1) {
|
||||
return $1.toUpperCase();
|
||||
});
|
||||
};
|
||||
|
||||
return Util;
|
||||
})();
|
||||
19
node_modules/protobufjs/src/bower.json.in
generated
vendored
Normal file
19
node_modules/protobufjs/src/bower.json.in
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
{
|
||||
"name": "protobuf",
|
||||
"description": "Protocol Buffers for JavaScript. Finally.",
|
||||
"version": /*?== VERSION */,
|
||||
"main": "dist/protobuf.js",
|
||||
"license": "Apache-2.0",
|
||||
"homepage": "http://dcode.io/",
|
||||
"dependencies": {
|
||||
"bytebuffer": "~5"
|
||||
},
|
||||
"keywords": ["net", "buffer", "protobuf", "serialization", "bytebuffer", "websocket", "webrtc"],
|
||||
"ignore": [
|
||||
"**/.*",
|
||||
"node_modules",
|
||||
"bower_components",
|
||||
"test",
|
||||
"tests"
|
||||
]
|
||||
}
|
||||
43
node_modules/protobufjs/src/es5.js
generated
vendored
Normal file
43
node_modules/protobufjs/src/es5.js
generated
vendored
Normal file
@ -0,0 +1,43 @@
|
||||
// Starting with ProtoBuf.js 4.X we are no longer bundling any ES5 polyfills with the library.
|
||||
// It is now up to the user to provide these as needed. For reference, this is what we use:
|
||||
|
||||
// ref: https://developer.mozilla.org/de/docs/JavaScript/Reference/Global_Objects/Object/create
|
||||
if (!Object.create)
|
||||
/** @expose */
|
||||
Object.create = function (o) {
|
||||
if (arguments.length > 1)
|
||||
throw Error('illegal number of arguments');
|
||||
function F() {}
|
||||
F.prototype = o;
|
||||
return new F();
|
||||
};
|
||||
|
||||
// ref: https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
|
||||
if (!Array.isArray)
|
||||
/** @expose */
|
||||
Array.isArray = function(o) {
|
||||
return Object.prototype.toString.call(o) === "[object Array]";
|
||||
};
|
||||
|
||||
// ref: https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
|
||||
if (!Array.prototype.forEach)
|
||||
/** @expose */
|
||||
Array.prototype.forEach = function(callback, thisArg) {
|
||||
var T, k;
|
||||
if (this == null)
|
||||
throw new TypeError('this is null or not defined');
|
||||
var O = Object(this);
|
||||
var len = O.length >>> 0;
|
||||
if (typeof callback !== "function")
|
||||
throw new TypeError(callback + ' is not a function');
|
||||
if (arguments.length > 1)
|
||||
T = thisArg;
|
||||
k = 0;
|
||||
while (k < len) {
|
||||
var kValue;
|
||||
if (k in O)
|
||||
kValue = O[k],
|
||||
callback.call(T, kValue, k, O);
|
||||
k++;
|
||||
}
|
||||
};
|
||||
13
node_modules/protobufjs/src/google/protobuf/README.md
generated
vendored
Normal file
13
node_modules/protobufjs/src/google/protobuf/README.md
generated
vendored
Normal file
@ -0,0 +1,13 @@
|
||||
These files are by default not used by ProtoBuf.js and are here for the purpose of completeness. The library does not
|
||||
need and therefore does not use these files by design. In most use cases including the descriptor isn't even required
|
||||
and would just add about 10KB (minified JSON) to your application.
|
||||
|
||||
### Though it's possible to include them:
|
||||
|
||||
1. You may explicitly reference them by providing a relative or absolute path in your .proto files. E.g. use
|
||||
`./google/protobuf/descriptor.proto` and bundle the file with your application.
|
||||
|
||||
2. If you use the `proto2js` command line utility with the `-legacy` option and the descriptor namespace is explicitly
|
||||
referenced, it is included in the generated output.
|
||||
|
||||
You are then able to work with it as if it'd be no more and no less than a standard import.
|
||||
849
node_modules/protobufjs/src/google/protobuf/descriptor.json
generated
vendored
Normal file
849
node_modules/protobufjs/src/google/protobuf/descriptor.json
generated
vendored
Normal file
@ -0,0 +1,849 @@
|
||||
{
|
||||
"package": "google.protobuf",
|
||||
"syntax": "proto2",
|
||||
"options": {
|
||||
"java_package": "com.google.protobuf",
|
||||
"java_outer_classname": "DescriptorProtos",
|
||||
"optimize_for": "SPEED"
|
||||
},
|
||||
"messages": [
|
||||
{
|
||||
"name": "FileDescriptorSet",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "FileDescriptorProto",
|
||||
"name": "file",
|
||||
"id": 1
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "FileDescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "package",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "string",
|
||||
"name": "dependency",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "int32",
|
||||
"name": "public_dependency",
|
||||
"id": 10
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "int32",
|
||||
"name": "weak_dependency",
|
||||
"id": 11
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "DescriptorProto",
|
||||
"name": "message_type",
|
||||
"id": 4
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "EnumDescriptorProto",
|
||||
"name": "enum_type",
|
||||
"id": 5
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "ServiceDescriptorProto",
|
||||
"name": "service",
|
||||
"id": 6
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "FieldDescriptorProto",
|
||||
"name": "extension",
|
||||
"id": 7
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "FileOptions",
|
||||
"name": "options",
|
||||
"id": 8
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "SourceCodeInfo",
|
||||
"name": "source_code_info",
|
||||
"id": 9
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "DescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "FieldDescriptorProto",
|
||||
"name": "field",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "FieldDescriptorProto",
|
||||
"name": "extension",
|
||||
"id": 6
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "DescriptorProto",
|
||||
"name": "nested_type",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "EnumDescriptorProto",
|
||||
"name": "enum_type",
|
||||
"id": 4
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "ExtensionRange",
|
||||
"name": "extension_range",
|
||||
"id": 5
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "MessageOptions",
|
||||
"name": "options",
|
||||
"id": 7
|
||||
}
|
||||
],
|
||||
"messages": [
|
||||
{
|
||||
"name": "ExtensionRange",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "int32",
|
||||
"name": "start",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "int32",
|
||||
"name": "end",
|
||||
"id": 2
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "FieldDescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "int32",
|
||||
"name": "number",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "Label",
|
||||
"name": "label",
|
||||
"id": 4
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "Type",
|
||||
"name": "type",
|
||||
"id": 5
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "type_name",
|
||||
"id": 6
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "extendee",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "default_value",
|
||||
"id": 7
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "FieldOptions",
|
||||
"name": "options",
|
||||
"id": 8
|
||||
}
|
||||
],
|
||||
"enums": [
|
||||
{
|
||||
"name": "Type",
|
||||
"syntax": "proto2",
|
||||
"values": [
|
||||
{
|
||||
"name": "TYPE_DOUBLE",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"name": "TYPE_FLOAT",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"name": "TYPE_INT64",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"name": "TYPE_UINT64",
|
||||
"id": 4
|
||||
},
|
||||
{
|
||||
"name": "TYPE_INT32",
|
||||
"id": 5
|
||||
},
|
||||
{
|
||||
"name": "TYPE_FIXED64",
|
||||
"id": 6
|
||||
},
|
||||
{
|
||||
"name": "TYPE_FIXED32",
|
||||
"id": 7
|
||||
},
|
||||
{
|
||||
"name": "TYPE_BOOL",
|
||||
"id": 8
|
||||
},
|
||||
{
|
||||
"name": "TYPE_STRING",
|
||||
"id": 9
|
||||
},
|
||||
{
|
||||
"name": "TYPE_GROUP",
|
||||
"id": 10
|
||||
},
|
||||
{
|
||||
"name": "TYPE_MESSAGE",
|
||||
"id": 11
|
||||
},
|
||||
{
|
||||
"name": "TYPE_BYTES",
|
||||
"id": 12
|
||||
},
|
||||
{
|
||||
"name": "TYPE_UINT32",
|
||||
"id": 13
|
||||
},
|
||||
{
|
||||
"name": "TYPE_ENUM",
|
||||
"id": 14
|
||||
},
|
||||
{
|
||||
"name": "TYPE_SFIXED32",
|
||||
"id": 15
|
||||
},
|
||||
{
|
||||
"name": "TYPE_SFIXED64",
|
||||
"id": 16
|
||||
},
|
||||
{
|
||||
"name": "TYPE_SINT32",
|
||||
"id": 17
|
||||
},
|
||||
{
|
||||
"name": "TYPE_SINT64",
|
||||
"id": 18
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "Label",
|
||||
"syntax": "proto2",
|
||||
"values": [
|
||||
{
|
||||
"name": "LABEL_OPTIONAL",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"name": "LABEL_REQUIRED",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"name": "LABEL_REPEATED",
|
||||
"id": 3
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "EnumDescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "EnumValueDescriptorProto",
|
||||
"name": "value",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "EnumOptions",
|
||||
"name": "options",
|
||||
"id": 3
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "EnumValueDescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "int32",
|
||||
"name": "number",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "EnumValueOptions",
|
||||
"name": "options",
|
||||
"id": 3
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "ServiceDescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "MethodDescriptorProto",
|
||||
"name": "method",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "ServiceOptions",
|
||||
"name": "options",
|
||||
"id": 3
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "MethodDescriptorProto",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "name",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "input_type",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "output_type",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "MethodOptions",
|
||||
"name": "options",
|
||||
"id": 4
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "FileOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "java_package",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "java_outer_classname",
|
||||
"id": 8
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "java_multiple_files",
|
||||
"id": 10,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "java_generate_equals_and_hash",
|
||||
"id": 20,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "OptimizeMode",
|
||||
"name": "optimize_for",
|
||||
"id": 9,
|
||||
"options": {
|
||||
"default": "SPEED"
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "go_package",
|
||||
"id": 11
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "cc_generic_services",
|
||||
"id": 16,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "java_generic_services",
|
||||
"id": 17,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "py_generic_services",
|
||||
"id": 18,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
],
|
||||
"enums": [
|
||||
{
|
||||
"name": "OptimizeMode",
|
||||
"syntax": "proto2",
|
||||
"values": [
|
||||
{
|
||||
"name": "SPEED",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"name": "CODE_SIZE",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"name": "LITE_RUNTIME",
|
||||
"id": 3
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "MessageOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "message_set_wire_format",
|
||||
"id": 1,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "no_standard_descriptor_accessor",
|
||||
"id": 2,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "FieldOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "CType",
|
||||
"name": "ctype",
|
||||
"id": 1,
|
||||
"options": {
|
||||
"default": "STRING"
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "packed",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "lazy",
|
||||
"id": 5,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "deprecated",
|
||||
"id": 3,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "experimental_map_key",
|
||||
"id": 9
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "weak",
|
||||
"id": 10,
|
||||
"options": {
|
||||
"default": false
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
],
|
||||
"enums": [
|
||||
{
|
||||
"name": "CType",
|
||||
"syntax": "proto2",
|
||||
"values": [
|
||||
{
|
||||
"name": "STRING",
|
||||
"id": 0
|
||||
},
|
||||
{
|
||||
"name": "CORD",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"name": "STRING_PIECE",
|
||||
"id": 2
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "EnumOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bool",
|
||||
"name": "allow_alias",
|
||||
"id": 2,
|
||||
"options": {
|
||||
"default": true
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "EnumValueOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "ServiceOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "MethodOptions",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "UninterpretedOption",
|
||||
"name": "uninterpreted_option",
|
||||
"id": 999
|
||||
}
|
||||
],
|
||||
"extensions": [
|
||||
[
|
||||
1000,
|
||||
536870911
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "UninterpretedOption",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "NamePart",
|
||||
"name": "name",
|
||||
"id": 2
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "identifier_value",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "uint64",
|
||||
"name": "positive_int_value",
|
||||
"id": 4
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "int64",
|
||||
"name": "negative_int_value",
|
||||
"id": 5
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "double",
|
||||
"name": "double_value",
|
||||
"id": 6
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "bytes",
|
||||
"name": "string_value",
|
||||
"id": 7
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "aggregate_value",
|
||||
"id": 8
|
||||
}
|
||||
],
|
||||
"messages": [
|
||||
{
|
||||
"name": "NamePart",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "required",
|
||||
"type": "string",
|
||||
"name": "name_part",
|
||||
"id": 1
|
||||
},
|
||||
{
|
||||
"rule": "required",
|
||||
"type": "bool",
|
||||
"name": "is_extension",
|
||||
"id": 2
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "SourceCodeInfo",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "Location",
|
||||
"name": "location",
|
||||
"id": 1
|
||||
}
|
||||
],
|
||||
"messages": [
|
||||
{
|
||||
"name": "Location",
|
||||
"syntax": "proto2",
|
||||
"fields": [
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "int32",
|
||||
"name": "path",
|
||||
"id": 1,
|
||||
"options": {
|
||||
"packed": true
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "repeated",
|
||||
"type": "int32",
|
||||
"name": "span",
|
||||
"id": 2,
|
||||
"options": {
|
||||
"packed": true
|
||||
}
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "leading_comments",
|
||||
"id": 3
|
||||
},
|
||||
{
|
||||
"rule": "optional",
|
||||
"type": "string",
|
||||
"name": "trailing_comments",
|
||||
"id": 4
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"isNamespace": true
|
||||
}
|
||||
620
node_modules/protobufjs/src/google/protobuf/descriptor.proto
generated
vendored
Normal file
620
node_modules/protobufjs/src/google/protobuf/descriptor.proto
generated
vendored
Normal file
@ -0,0 +1,620 @@
|
||||
// Protocol Buffers - Google's data interchange format
|
||||
// Copyright 2008 Google Inc. All rights reserved.
|
||||
// http://code.google.com/p/protobuf/
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Author: kenton@google.com (Kenton Varda)
|
||||
// Based on original Protocol Buffers design by
|
||||
// Sanjay Ghemawat, Jeff Dean, and others.
|
||||
//
|
||||
// The messages in this file describe the definitions found in .proto files.
|
||||
// A valid .proto file can be translated directly to a FileDescriptorProto
|
||||
// without any other information (e.g. without reading its imports).
|
||||
|
||||
|
||||
|
||||
package google.protobuf;
|
||||
option java_package = "com.google.protobuf";
|
||||
option java_outer_classname = "DescriptorProtos";
|
||||
|
||||
// descriptor.proto must be optimized for speed because reflection-based
|
||||
// algorithms don't work during bootstrapping.
|
||||
option optimize_for = SPEED;
|
||||
|
||||
// The protocol compiler can output a FileDescriptorSet containing the .proto
|
||||
// files it parses.
|
||||
message FileDescriptorSet {
|
||||
repeated FileDescriptorProto file = 1;
|
||||
}
|
||||
|
||||
// Describes a complete .proto file.
|
||||
message FileDescriptorProto {
|
||||
optional string name = 1; // file name, relative to root of source tree
|
||||
optional string package = 2; // e.g. "foo", "foo.bar", etc.
|
||||
|
||||
// Names of files imported by this file.
|
||||
repeated string dependency = 3;
|
||||
// Indexes of the public imported files in the dependency list above.
|
||||
repeated int32 public_dependency = 10;
|
||||
// Indexes of the weak imported files in the dependency list.
|
||||
// For Google-internal migration only. Do not use.
|
||||
repeated int32 weak_dependency = 11;
|
||||
|
||||
// All top-level definitions in this file.
|
||||
repeated DescriptorProto message_type = 4;
|
||||
repeated EnumDescriptorProto enum_type = 5;
|
||||
repeated ServiceDescriptorProto service = 6;
|
||||
repeated FieldDescriptorProto extension = 7;
|
||||
|
||||
optional FileOptions options = 8;
|
||||
|
||||
// This field contains optional information about the original source code.
|
||||
// You may safely remove this entire field whithout harming runtime
|
||||
// functionality of the descriptors -- the information is needed only by
|
||||
// development tools.
|
||||
optional SourceCodeInfo source_code_info = 9;
|
||||
}
|
||||
|
||||
// Describes a message type.
|
||||
message DescriptorProto {
|
||||
optional string name = 1;
|
||||
|
||||
repeated FieldDescriptorProto field = 2;
|
||||
repeated FieldDescriptorProto extension = 6;
|
||||
|
||||
repeated DescriptorProto nested_type = 3;
|
||||
repeated EnumDescriptorProto enum_type = 4;
|
||||
|
||||
message ExtensionRange {
|
||||
optional int32 start = 1;
|
||||
optional int32 end = 2;
|
||||
}
|
||||
repeated ExtensionRange extension_range = 5;
|
||||
|
||||
optional MessageOptions options = 7;
|
||||
}
|
||||
|
||||
// Describes a field within a message.
|
||||
message FieldDescriptorProto {
|
||||
enum Type {
|
||||
// 0 is reserved for errors.
|
||||
// Order is weird for historical reasons.
|
||||
TYPE_DOUBLE = 1;
|
||||
TYPE_FLOAT = 2;
|
||||
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
|
||||
// negative values are likely.
|
||||
TYPE_INT64 = 3;
|
||||
TYPE_UINT64 = 4;
|
||||
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
|
||||
// negative values are likely.
|
||||
TYPE_INT32 = 5;
|
||||
TYPE_FIXED64 = 6;
|
||||
TYPE_FIXED32 = 7;
|
||||
TYPE_BOOL = 8;
|
||||
TYPE_STRING = 9;
|
||||
TYPE_GROUP = 10; // Tag-delimited aggregate.
|
||||
TYPE_MESSAGE = 11; // Length-delimited aggregate.
|
||||
|
||||
// New in version 2.
|
||||
TYPE_BYTES = 12;
|
||||
TYPE_UINT32 = 13;
|
||||
TYPE_ENUM = 14;
|
||||
TYPE_SFIXED32 = 15;
|
||||
TYPE_SFIXED64 = 16;
|
||||
TYPE_SINT32 = 17; // Uses ZigZag encoding.
|
||||
TYPE_SINT64 = 18; // Uses ZigZag encoding.
|
||||
};
|
||||
|
||||
enum Label {
|
||||
// 0 is reserved for errors
|
||||
LABEL_OPTIONAL = 1;
|
||||
LABEL_REQUIRED = 2;
|
||||
LABEL_REPEATED = 3;
|
||||
// TODO(sanjay): Should we add LABEL_MAP?
|
||||
};
|
||||
|
||||
optional string name = 1;
|
||||
optional int32 number = 3;
|
||||
optional Label label = 4;
|
||||
|
||||
// If type_name is set, this need not be set. If both this and type_name
|
||||
// are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
|
||||
optional Type type = 5;
|
||||
|
||||
// For message and enum types, this is the name of the type. If the name
|
||||
// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
|
||||
// rules are used to find the type (i.e. first the nested types within this
|
||||
// message are searched, then within the parent, on up to the root
|
||||
// namespace).
|
||||
optional string type_name = 6;
|
||||
|
||||
// For extensions, this is the name of the type being extended. It is
|
||||
// resolved in the same manner as type_name.
|
||||
optional string extendee = 2;
|
||||
|
||||
// For numeric types, contains the original text representation of the value.
|
||||
// For booleans, "true" or "false".
|
||||
// For strings, contains the default text contents (not escaped in any way).
|
||||
// For bytes, contains the C escaped value. All bytes >= 128 are escaped.
|
||||
// TODO(kenton): Base-64 encode?
|
||||
optional string default_value = 7;
|
||||
|
||||
optional FieldOptions options = 8;
|
||||
}
|
||||
|
||||
// Describes an enum type.
|
||||
message EnumDescriptorProto {
|
||||
optional string name = 1;
|
||||
|
||||
repeated EnumValueDescriptorProto value = 2;
|
||||
|
||||
optional EnumOptions options = 3;
|
||||
}
|
||||
|
||||
// Describes a value within an enum.
|
||||
message EnumValueDescriptorProto {
|
||||
optional string name = 1;
|
||||
optional int32 number = 2;
|
||||
|
||||
optional EnumValueOptions options = 3;
|
||||
}
|
||||
|
||||
// Describes a service.
|
||||
message ServiceDescriptorProto {
|
||||
optional string name = 1;
|
||||
repeated MethodDescriptorProto method = 2;
|
||||
|
||||
optional ServiceOptions options = 3;
|
||||
}
|
||||
|
||||
// Describes a method of a service.
|
||||
message MethodDescriptorProto {
|
||||
optional string name = 1;
|
||||
|
||||
// Input and output type names. These are resolved in the same way as
|
||||
// FieldDescriptorProto.type_name, but must refer to a message type.
|
||||
optional string input_type = 2;
|
||||
optional string output_type = 3;
|
||||
|
||||
optional MethodOptions options = 4;
|
||||
}
|
||||
|
||||
|
||||
// ===================================================================
|
||||
// Options
|
||||
|
||||
// Each of the definitions above may have "options" attached. These are
|
||||
// just annotations which may cause code to be generated slightly differently
|
||||
// or may contain hints for code that manipulates protocol messages.
|
||||
//
|
||||
// Clients may define custom options as extensions of the *Options messages.
|
||||
// These extensions may not yet be known at parsing time, so the parser cannot
|
||||
// store the values in them. Instead it stores them in a field in the *Options
|
||||
// message called uninterpreted_option. This field must have the same name
|
||||
// across all *Options messages. We then use this field to populate the
|
||||
// extensions when we build a descriptor, at which point all protos have been
|
||||
// parsed and so all extensions are known.
|
||||
//
|
||||
// Extension numbers for custom options may be chosen as follows:
|
||||
// * For options which will only be used within a single application or
|
||||
// organization, or for experimental options, use field numbers 50000
|
||||
// through 99999. It is up to you to ensure that you do not use the
|
||||
// same number for multiple options.
|
||||
// * For options which will be published and used publicly by multiple
|
||||
// independent entities, e-mail protobuf-global-extension-registry@google.com
|
||||
// to reserve extension numbers. Simply provide your project name (e.g.
|
||||
// Object-C plugin) and your porject website (if available) -- there's no need
|
||||
// to explain how you intend to use them. Usually you only need one extension
|
||||
// number. You can declare multiple options with only one extension number by
|
||||
// putting them in a sub-message. See the Custom Options section of the docs
|
||||
// for examples:
|
||||
// http://code.google.com/apis/protocolbuffers/docs/proto.html#options
|
||||
// If this turns out to be popular, a web service will be set up
|
||||
// to automatically assign option numbers.
|
||||
|
||||
|
||||
message FileOptions {
|
||||
|
||||
// Sets the Java package where classes generated from this .proto will be
|
||||
// placed. By default, the proto package is used, but this is often
|
||||
// inappropriate because proto packages do not normally start with backwards
|
||||
// domain names.
|
||||
optional string java_package = 1;
|
||||
|
||||
|
||||
// If set, all the classes from the .proto file are wrapped in a single
|
||||
// outer class with the given name. This applies to both Proto1
|
||||
// (equivalent to the old "--one_java_file" option) and Proto2 (where
|
||||
// a .proto always translates to a single class, but you may want to
|
||||
// explicitly choose the class name).
|
||||
optional string java_outer_classname = 8;
|
||||
|
||||
// If set true, then the Java code generator will generate a separate .java
|
||||
// file for each top-level message, enum, and service defined in the .proto
|
||||
// file. Thus, these types will *not* be nested inside the outer class
|
||||
// named by java_outer_classname. However, the outer class will still be
|
||||
// generated to contain the file's getDescriptor() method as well as any
|
||||
// top-level extensions defined in the file.
|
||||
optional bool java_multiple_files = 10 [default=false];
|
||||
|
||||
// If set true, then the Java code generator will generate equals() and
|
||||
// hashCode() methods for all messages defined in the .proto file. This is
|
||||
// purely a speed optimization, as the AbstractMessage base class includes
|
||||
// reflection-based implementations of these methods.
|
||||
optional bool java_generate_equals_and_hash = 20 [default=false];
|
||||
|
||||
// Generated classes can be optimized for speed or code size.
|
||||
enum OptimizeMode {
|
||||
SPEED = 1; // Generate complete code for parsing, serialization,
|
||||
// etc.
|
||||
CODE_SIZE = 2; // Use ReflectionOps to implement these methods.
|
||||
LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
|
||||
}
|
||||
optional OptimizeMode optimize_for = 9 [default=SPEED];
|
||||
|
||||
// Sets the Go package where structs generated from this .proto will be
|
||||
// placed. There is no default.
|
||||
optional string go_package = 11;
|
||||
|
||||
|
||||
|
||||
// Should generic services be generated in each language? "Generic" services
|
||||
// are not specific to any particular RPC system. They are generated by the
|
||||
// main code generators in each language (without additional plugins).
|
||||
// Generic services were the only kind of service generation supported by
|
||||
// early versions of proto2.
|
||||
//
|
||||
// Generic services are now considered deprecated in favor of using plugins
|
||||
// that generate code specific to your particular RPC system. Therefore,
|
||||
// these default to false. Old code which depends on generic services should
|
||||
// explicitly set them to true.
|
||||
optional bool cc_generic_services = 16 [default=false];
|
||||
optional bool java_generic_services = 17 [default=false];
|
||||
optional bool py_generic_services = 18 [default=false];
|
||||
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
message MessageOptions {
|
||||
// Set true to use the old proto1 MessageSet wire format for extensions.
|
||||
// This is provided for backwards-compatibility with the MessageSet wire
|
||||
// format. You should not use this for any other reason: It's less
|
||||
// efficient, has fewer features, and is more complicated.
|
||||
//
|
||||
// The message must be defined exactly as follows:
|
||||
// message Foo {
|
||||
// option message_set_wire_format = true;
|
||||
// extensions 4 to max;
|
||||
// }
|
||||
// Note that the message cannot have any defined fields; MessageSets only
|
||||
// have extensions.
|
||||
//
|
||||
// All extensions of your type must be singular messages; e.g. they cannot
|
||||
// be int32s, enums, or repeated messages.
|
||||
//
|
||||
// Because this is an option, the above two restrictions are not enforced by
|
||||
// the protocol compiler.
|
||||
optional bool message_set_wire_format = 1 [default=false];
|
||||
|
||||
// Disables the generation of the standard "descriptor()" accessor, which can
|
||||
// conflict with a field of the same name. This is meant to make migration
|
||||
// from proto1 easier; new code should avoid fields named "descriptor".
|
||||
optional bool no_standard_descriptor_accessor = 2 [default=false];
|
||||
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
message FieldOptions {
|
||||
// The ctype option instructs the C++ code generator to use a different
|
||||
// representation of the field than it normally would. See the specific
|
||||
// options below. This option is not yet implemented in the open source
|
||||
// release -- sorry, we'll try to include it in a future version!
|
||||
optional CType ctype = 1 [default = STRING];
|
||||
enum CType {
|
||||
// Default mode.
|
||||
STRING = 0;
|
||||
|
||||
CORD = 1;
|
||||
|
||||
STRING_PIECE = 2;
|
||||
}
|
||||
// The packed option can be enabled for repeated primitive fields to enable
|
||||
// a more efficient representation on the wire. Rather than repeatedly
|
||||
// writing the tag and type for each element, the entire array is encoded as
|
||||
// a single length-delimited blob.
|
||||
optional bool packed = 2;
|
||||
|
||||
|
||||
|
||||
// Should this field be parsed lazily? Lazy applies only to message-type
|
||||
// fields. It means that when the outer message is initially parsed, the
|
||||
// inner message's contents will not be parsed but instead stored in encoded
|
||||
// form. The inner message will actually be parsed when it is first accessed.
|
||||
//
|
||||
// This is only a hint. Implementations are free to choose whether to use
|
||||
// eager or lazy parsing regardless of the value of this option. However,
|
||||
// setting this option true suggests that the protocol author believes that
|
||||
// using lazy parsing on this field is worth the additional bookkeeping
|
||||
// overhead typically needed to implement it.
|
||||
//
|
||||
// This option does not affect the public interface of any generated code;
|
||||
// all method signatures remain the same. Furthermore, thread-safety of the
|
||||
// interface is not affected by this option; const methods remain safe to
|
||||
// call from multiple threads concurrently, while non-const methods continue
|
||||
// to require exclusive access.
|
||||
//
|
||||
//
|
||||
// Note that implementations may choose not to check required fields within
|
||||
// a lazy sub-message. That is, calling IsInitialized() on the outher message
|
||||
// may return true even if the inner message has missing required fields.
|
||||
// This is necessary because otherwise the inner message would have to be
|
||||
// parsed in order to perform the check, defeating the purpose of lazy
|
||||
// parsing. An implementation which chooses not to check required fields
|
||||
// must be consistent about it. That is, for any particular sub-message, the
|
||||
// implementation must either *always* check its required fields, or *never*
|
||||
// check its required fields, regardless of whether or not the message has
|
||||
// been parsed.
|
||||
optional bool lazy = 5 [default=false];
|
||||
|
||||
// Is this field deprecated?
|
||||
// Depending on the target platform, this can emit Deprecated annotations
|
||||
// for accessors, or it will be completely ignored; in the very least, this
|
||||
// is a formalization for deprecating fields.
|
||||
optional bool deprecated = 3 [default=false];
|
||||
|
||||
// EXPERIMENTAL. DO NOT USE.
|
||||
// For "map" fields, the name of the field in the enclosed type that
|
||||
// is the key for this map. For example, suppose we have:
|
||||
// message Item {
|
||||
// required string name = 1;
|
||||
// required string value = 2;
|
||||
// }
|
||||
// message Config {
|
||||
// repeated Item items = 1 [experimental_map_key="name"];
|
||||
// }
|
||||
// In this situation, the map key for Item will be set to "name".
|
||||
// TODO: Fully-implement this, then remove the "experimental_" prefix.
|
||||
optional string experimental_map_key = 9;
|
||||
|
||||
// For Google-internal migration only. Do not use.
|
||||
optional bool weak = 10 [default=false];
|
||||
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
message EnumOptions {
|
||||
|
||||
// Set this option to false to disallow mapping different tag names to a same
|
||||
// value.
|
||||
optional bool allow_alias = 2 [default=true];
|
||||
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
message EnumValueOptions {
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
message ServiceOptions {
|
||||
|
||||
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
|
||||
// framework. We apologize for hoarding these numbers to ourselves, but
|
||||
// we were already using them long before we decided to release Protocol
|
||||
// Buffers.
|
||||
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
message MethodOptions {
|
||||
|
||||
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
|
||||
// framework. We apologize for hoarding these numbers to ourselves, but
|
||||
// we were already using them long before we decided to release Protocol
|
||||
// Buffers.
|
||||
|
||||
// The parser stores options it doesn't recognize here. See above.
|
||||
repeated UninterpretedOption uninterpreted_option = 999;
|
||||
|
||||
// Clients can define custom options in extensions of this message. See above.
|
||||
extensions 1000 to max;
|
||||
}
|
||||
|
||||
|
||||
// A message representing a option the parser does not recognize. This only
|
||||
// appears in options protos created by the compiler::Parser class.
|
||||
// DescriptorPool resolves these when building Descriptor objects. Therefore,
|
||||
// options protos in descriptor objects (e.g. returned by Descriptor::options(),
|
||||
// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
|
||||
// in them.
|
||||
message UninterpretedOption {
|
||||
// The name of the uninterpreted option. Each string represents a segment in
|
||||
// a dot-separated name. is_extension is true iff a segment represents an
|
||||
// extension (denoted with parentheses in options specs in .proto files).
|
||||
// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
|
||||
// "foo.(bar.baz).qux".
|
||||
message NamePart {
|
||||
required string name_part = 1;
|
||||
required bool is_extension = 2;
|
||||
}
|
||||
repeated NamePart name = 2;
|
||||
|
||||
// The value of the uninterpreted option, in whatever type the tokenizer
|
||||
// identified it as during parsing. Exactly one of these should be set.
|
||||
optional string identifier_value = 3;
|
||||
optional uint64 positive_int_value = 4;
|
||||
optional int64 negative_int_value = 5;
|
||||
optional double double_value = 6;
|
||||
optional bytes string_value = 7;
|
||||
optional string aggregate_value = 8;
|
||||
}
|
||||
|
||||
// ===================================================================
|
||||
// Optional source code info
|
||||
|
||||
// Encapsulates information about the original source file from which a
|
||||
// FileDescriptorProto was generated.
|
||||
message SourceCodeInfo {
|
||||
// A Location identifies a piece of source code in a .proto file which
|
||||
// corresponds to a particular definition. This information is intended
|
||||
// to be useful to IDEs, code indexers, documentation generators, and similar
|
||||
// tools.
|
||||
//
|
||||
// For example, say we have a file like:
|
||||
// message Foo {
|
||||
// optional string foo = 1;
|
||||
// }
|
||||
// Let's look at just the field definition:
|
||||
// optional string foo = 1;
|
||||
// ^ ^^ ^^ ^ ^^^
|
||||
// a bc de f ghi
|
||||
// We have the following locations:
|
||||
// span path represents
|
||||
// [a,i) [ 4, 0, 2, 0 ] The whole field definition.
|
||||
// [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
|
||||
// [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
|
||||
// [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
|
||||
// [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
|
||||
//
|
||||
// Notes:
|
||||
// - A location may refer to a repeated field itself (i.e. not to any
|
||||
// particular index within it). This is used whenever a set of elements are
|
||||
// logically enclosed in a single code segment. For example, an entire
|
||||
// extend block (possibly containing multiple extension definitions) will
|
||||
// have an outer location whose path refers to the "extensions" repeated
|
||||
// field without an index.
|
||||
// - Multiple locations may have the same path. This happens when a single
|
||||
// logical declaration is spread out across multiple places. The most
|
||||
// obvious example is the "extend" block again -- there may be multiple
|
||||
// extend blocks in the same scope, each of which will have the same path.
|
||||
// - A location's span is not always a subset of its parent's span. For
|
||||
// example, the "extendee" of an extension declaration appears at the
|
||||
// beginning of the "extend" block and is shared by all extensions within
|
||||
// the block.
|
||||
// - Just because a location's span is a subset of some other location's span
|
||||
// does not mean that it is a descendent. For example, a "group" defines
|
||||
// both a type and a field in a single declaration. Thus, the locations
|
||||
// corresponding to the type and field and their components will overlap.
|
||||
// - Code which tries to interpret locations should probably be designed to
|
||||
// ignore those that it doesn't understand, as more types of locations could
|
||||
// be recorded in the future.
|
||||
repeated Location location = 1;
|
||||
message Location {
|
||||
// Identifies which part of the FileDescriptorProto was defined at this
|
||||
// location.
|
||||
//
|
||||
// Each element is a field number or an index. They form a path from
|
||||
// the root FileDescriptorProto to the place where the definition. For
|
||||
// example, this path:
|
||||
// [ 4, 3, 2, 7, 1 ]
|
||||
// refers to:
|
||||
// file.message_type(3) // 4, 3
|
||||
// .field(7) // 2, 7
|
||||
// .name() // 1
|
||||
// This is because FileDescriptorProto.message_type has field number 4:
|
||||
// repeated DescriptorProto message_type = 4;
|
||||
// and DescriptorProto.field has field number 2:
|
||||
// repeated FieldDescriptorProto field = 2;
|
||||
// and FieldDescriptorProto.name has field number 1:
|
||||
// optional string name = 1;
|
||||
//
|
||||
// Thus, the above path gives the location of a field name. If we removed
|
||||
// the last element:
|
||||
// [ 4, 3, 2, 7 ]
|
||||
// this path refers to the whole field declaration (from the beginning
|
||||
// of the label to the terminating semicolon).
|
||||
repeated int32 path = 1 [packed=true];
|
||||
|
||||
// Always has exactly three or four elements: start line, start column,
|
||||
// end line (optional, otherwise assumed same as start line), end column.
|
||||
// These are packed into a single field for efficiency. Note that line
|
||||
// and column numbers are zero-based -- typically you will want to add
|
||||
// 1 to each before displaying to a user.
|
||||
repeated int32 span = 2 [packed=true];
|
||||
|
||||
// If this SourceCodeInfo represents a complete declaration, these are any
|
||||
// comments appearing before and after the declaration which appear to be
|
||||
// attached to the declaration.
|
||||
//
|
||||
// A series of line comments appearing on consecutive lines, with no other
|
||||
// tokens appearing on those lines, will be treated as a single comment.
|
||||
//
|
||||
// Only the comment content is provided; comment markers (e.g. //) are
|
||||
// stripped out. For block comments, leading whitespace and an asterisk
|
||||
// will be stripped from the beginning of each line other than the first.
|
||||
// Newlines are included in the output.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// optional int32 foo = 1; // Comment attached to foo.
|
||||
// // Comment attached to bar.
|
||||
// optional int32 bar = 2;
|
||||
//
|
||||
// optional string baz = 3;
|
||||
// // Comment attached to baz.
|
||||
// // Another line attached to baz.
|
||||
//
|
||||
// // Comment attached to qux.
|
||||
// //
|
||||
// // Another line attached to qux.
|
||||
// optional double qux = 4;
|
||||
//
|
||||
// optional string corge = 5;
|
||||
// /* Block comment attached
|
||||
// * to corge. Leading asterisks
|
||||
// * will be removed. */
|
||||
// /* Block comment attached to
|
||||
// * grault. */
|
||||
// optional int32 grault = 6;
|
||||
optional string leading_comments = 3;
|
||||
optional string trailing_comments = 4;
|
||||
}
|
||||
}
|
||||
421
node_modules/protobufjs/src/protobuf.js
generated
vendored
Normal file
421
node_modules/protobufjs/src/protobuf.js
generated
vendored
Normal file
@ -0,0 +1,421 @@
|
||||
/**
|
||||
* The ProtoBuf namespace.
|
||||
* @exports ProtoBuf
|
||||
* @namespace
|
||||
* @expose
|
||||
*/
|
||||
var ProtoBuf = {};
|
||||
|
||||
/**
|
||||
* @type {!function(new: ByteBuffer, ...[*])}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.ByteBuffer = ByteBuffer;
|
||||
|
||||
/**
|
||||
* @type {?function(new: Long, ...[*])}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.Long = ByteBuffer.Long || null;
|
||||
|
||||
/**
|
||||
* ProtoBuf.js version.
|
||||
* @type {string}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.VERSION = "/*?= VERSION */";
|
||||
|
||||
/**
|
||||
* Wire types.
|
||||
* @type {Object.<string,number>}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES = {};
|
||||
|
||||
/**
|
||||
* Varint wire type.
|
||||
* @type {number}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES.VARINT = 0;
|
||||
|
||||
/**
|
||||
* Fixed 64 bits wire type.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES.BITS64 = 1;
|
||||
|
||||
/**
|
||||
* Length delimited wire type.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES.LDELIM = 2;
|
||||
|
||||
/**
|
||||
* Start group wire type.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES.STARTGROUP = 3;
|
||||
|
||||
/**
|
||||
* End group wire type.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES.ENDGROUP = 4;
|
||||
|
||||
/**
|
||||
* Fixed 32 bits wire type.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.WIRE_TYPES.BITS32 = 5;
|
||||
|
||||
/**
|
||||
* Packable wire types.
|
||||
* @type {!Array.<number>}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.PACKABLE_WIRE_TYPES = [
|
||||
ProtoBuf.WIRE_TYPES.VARINT,
|
||||
ProtoBuf.WIRE_TYPES.BITS64,
|
||||
ProtoBuf.WIRE_TYPES.BITS32
|
||||
];
|
||||
|
||||
/**
|
||||
* Types.
|
||||
* @dict
|
||||
* @type {!Object.<string,{name: string, wireType: number, defaultValue: *}>}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.TYPES = {
|
||||
// According to the protobuf spec.
|
||||
"int32": {
|
||||
name: "int32",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: 0
|
||||
},
|
||||
"uint32": {
|
||||
name: "uint32",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: 0
|
||||
},
|
||||
"sint32": {
|
||||
name: "sint32",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: 0
|
||||
},
|
||||
"int64": {
|
||||
name: "int64",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: ProtoBuf.Long ? ProtoBuf.Long.ZERO : undefined
|
||||
},
|
||||
"uint64": {
|
||||
name: "uint64",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: ProtoBuf.Long ? ProtoBuf.Long.UZERO : undefined
|
||||
},
|
||||
"sint64": {
|
||||
name: "sint64",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: ProtoBuf.Long ? ProtoBuf.Long.ZERO : undefined
|
||||
},
|
||||
"bool": {
|
||||
name: "bool",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: false
|
||||
},
|
||||
"double": {
|
||||
name: "double",
|
||||
wireType: ProtoBuf.WIRE_TYPES.BITS64,
|
||||
defaultValue: 0
|
||||
},
|
||||
"string": {
|
||||
name: "string",
|
||||
wireType: ProtoBuf.WIRE_TYPES.LDELIM,
|
||||
defaultValue: ""
|
||||
},
|
||||
"bytes": {
|
||||
name: "bytes",
|
||||
wireType: ProtoBuf.WIRE_TYPES.LDELIM,
|
||||
defaultValue: null // overridden in the code, must be a unique instance
|
||||
},
|
||||
"fixed32": {
|
||||
name: "fixed32",
|
||||
wireType: ProtoBuf.WIRE_TYPES.BITS32,
|
||||
defaultValue: 0
|
||||
},
|
||||
"sfixed32": {
|
||||
name: "sfixed32",
|
||||
wireType: ProtoBuf.WIRE_TYPES.BITS32,
|
||||
defaultValue: 0
|
||||
},
|
||||
"fixed64": {
|
||||
name: "fixed64",
|
||||
wireType: ProtoBuf.WIRE_TYPES.BITS64,
|
||||
defaultValue: ProtoBuf.Long ? ProtoBuf.Long.UZERO : undefined
|
||||
},
|
||||
"sfixed64": {
|
||||
name: "sfixed64",
|
||||
wireType: ProtoBuf.WIRE_TYPES.BITS64,
|
||||
defaultValue: ProtoBuf.Long ? ProtoBuf.Long.ZERO : undefined
|
||||
},
|
||||
"float": {
|
||||
name: "float",
|
||||
wireType: ProtoBuf.WIRE_TYPES.BITS32,
|
||||
defaultValue: 0
|
||||
},
|
||||
"enum": {
|
||||
name: "enum",
|
||||
wireType: ProtoBuf.WIRE_TYPES.VARINT,
|
||||
defaultValue: 0
|
||||
},
|
||||
"message": {
|
||||
name: "message",
|
||||
wireType: ProtoBuf.WIRE_TYPES.LDELIM,
|
||||
defaultValue: null
|
||||
},
|
||||
"group": {
|
||||
name: "group",
|
||||
wireType: ProtoBuf.WIRE_TYPES.STARTGROUP,
|
||||
defaultValue: null
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Valid map key types.
|
||||
* @type {!Array.<!Object.<string,{name: string, wireType: number, defaultValue: *}>>}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.MAP_KEY_TYPES = [
|
||||
ProtoBuf.TYPES["int32"],
|
||||
ProtoBuf.TYPES["sint32"],
|
||||
ProtoBuf.TYPES["sfixed32"],
|
||||
ProtoBuf.TYPES["uint32"],
|
||||
ProtoBuf.TYPES["fixed32"],
|
||||
ProtoBuf.TYPES["int64"],
|
||||
ProtoBuf.TYPES["sint64"],
|
||||
ProtoBuf.TYPES["sfixed64"],
|
||||
ProtoBuf.TYPES["uint64"],
|
||||
ProtoBuf.TYPES["fixed64"],
|
||||
ProtoBuf.TYPES["bool"],
|
||||
ProtoBuf.TYPES["string"],
|
||||
ProtoBuf.TYPES["bytes"]
|
||||
];
|
||||
|
||||
/**
|
||||
* Minimum field id.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.ID_MIN = 1;
|
||||
|
||||
/**
|
||||
* Maximum field id.
|
||||
* @type {number}
|
||||
* @const
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.ID_MAX = 0x1FFFFFFF;
|
||||
|
||||
/**
|
||||
* If set to `true`, field names will be converted from underscore notation to camel case. Defaults to `false`.
|
||||
* Must be set prior to parsing.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.convertFieldsToCamelCase = false;
|
||||
|
||||
/**
|
||||
* By default, messages are populated with (setX, set_x) accessors for each field. This can be disabled by
|
||||
* setting this to `false` prior to building messages.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.populateAccessors = true;
|
||||
|
||||
/**
|
||||
* By default, messages are populated with default values if a field is not present on the wire. To disable
|
||||
* this behavior, set this setting to `false`.
|
||||
* @type {boolean}
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.populateDefaults = true;
|
||||
|
||||
//? include("ProtoBuf/Util.js");
|
||||
|
||||
//? include("ProtoBuf/Lang.js");
|
||||
|
||||
//? if (DOTPROTO) include("ProtoBuf/DotProto.js");
|
||||
|
||||
//? include("ProtoBuf/Reflect.js");
|
||||
|
||||
//? include("ProtoBuf/Builder.js");
|
||||
|
||||
//? include("ProtoBuf/Map.js");
|
||||
|
||||
//? if (DOTPROTO) {
|
||||
|
||||
/**
|
||||
* Loads a .proto string and returns the Builder.
|
||||
* @param {string} proto .proto file contents
|
||||
* @param {(ProtoBuf.Builder|string|{root: string, file: string})=} builder Builder to append to. Will create a new one if omitted.
|
||||
* @param {(string|{root: string, file: string})=} filename The corresponding file name if known. Must be specified for imports.
|
||||
* @return {ProtoBuf.Builder} Builder to create new messages
|
||||
* @throws {Error} If the definition cannot be parsed or built
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.loadProto = function(proto, builder, filename) {
|
||||
if (typeof builder === 'string' || (builder && typeof builder["file"] === 'string' && typeof builder["root"] === 'string'))
|
||||
filename = builder,
|
||||
builder = undefined;
|
||||
return ProtoBuf.loadJson(ProtoBuf.DotProto.Parser.parse(proto), builder, filename);
|
||||
};
|
||||
|
||||
/**
|
||||
* Loads a .proto string and returns the Builder. This is an alias of {@link ProtoBuf.loadProto}.
|
||||
* @function
|
||||
* @param {string} proto .proto file contents
|
||||
* @param {(ProtoBuf.Builder|string)=} builder Builder to append to. Will create a new one if omitted.
|
||||
* @param {(string|{root: string, file: string})=} filename The corresponding file name if known. Must be specified for imports.
|
||||
* @return {ProtoBuf.Builder} Builder to create new messages
|
||||
* @throws {Error} If the definition cannot be parsed or built
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.protoFromString = ProtoBuf.loadProto; // Legacy
|
||||
|
||||
/**
|
||||
* Loads a .proto file and returns the Builder.
|
||||
* @param {string|{root: string, file: string}} filename Path to proto file or an object specifying 'file' with
|
||||
* an overridden 'root' path for all imported files.
|
||||
* @param {function(?Error, !ProtoBuf.Builder=)=} callback Callback that will receive `null` as the first and
|
||||
* the Builder as its second argument on success, otherwise the error as its first argument. If omitted, the
|
||||
* file will be read synchronously and this function will return the Builder.
|
||||
* @param {ProtoBuf.Builder=} builder Builder to append to. Will create a new one if omitted.
|
||||
* @return {?ProtoBuf.Builder|undefined} The Builder if synchronous (no callback specified, will be NULL if the
|
||||
* request has failed), else undefined
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.loadProtoFile = function(filename, callback, builder) {
|
||||
if (callback && typeof callback === 'object')
|
||||
builder = callback,
|
||||
callback = null;
|
||||
else if (!callback || typeof callback !== 'function')
|
||||
callback = null;
|
||||
if (callback)
|
||||
return ProtoBuf.Util.fetch(typeof filename === 'string' ? filename : filename["root"]+"/"+filename["file"], function(contents) {
|
||||
if (contents === null) {
|
||||
callback(Error("Failed to fetch file"));
|
||||
return;
|
||||
}
|
||||
try {
|
||||
callback(null, ProtoBuf.loadProto(contents, builder, filename));
|
||||
} catch (e) {
|
||||
callback(e);
|
||||
}
|
||||
});
|
||||
var contents = ProtoBuf.Util.fetch(typeof filename === 'object' ? filename["root"]+"/"+filename["file"] : filename);
|
||||
return contents === null ? null : ProtoBuf.loadProto(contents, builder, filename);
|
||||
};
|
||||
|
||||
/**
|
||||
* Loads a .proto file and returns the Builder. This is an alias of {@link ProtoBuf.loadProtoFile}.
|
||||
* @function
|
||||
* @param {string|{root: string, file: string}} filename Path to proto file or an object specifying 'file' with
|
||||
* an overridden 'root' path for all imported files.
|
||||
* @param {function(?Error, !ProtoBuf.Builder=)=} callback Callback that will receive `null` as the first and
|
||||
* the Builder as its second argument on success, otherwise the error as its first argument. If omitted, the
|
||||
* file will be read synchronously and this function will return the Builder.
|
||||
* @param {ProtoBuf.Builder=} builder Builder to append to. Will create a new one if omitted.
|
||||
* @return {!ProtoBuf.Builder|undefined} The Builder if synchronous (no callback specified, will be NULL if the
|
||||
* request has failed), else undefined
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.protoFromFile = ProtoBuf.loadProtoFile; // Legacy
|
||||
|
||||
//? } // DOTPROTO
|
||||
|
||||
/**
|
||||
* Constructs a new empty Builder.
|
||||
* @param {Object.<string,*>=} options Builder options, defaults to global options set on ProtoBuf
|
||||
* @return {!ProtoBuf.Builder} Builder
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.newBuilder = function(options) {
|
||||
options = options || {};
|
||||
if (typeof options['convertFieldsToCamelCase'] === 'undefined')
|
||||
options['convertFieldsToCamelCase'] = ProtoBuf.convertFieldsToCamelCase;
|
||||
if (typeof options['populateAccessors'] === 'undefined')
|
||||
options['populateAccessors'] = ProtoBuf.populateAccessors;
|
||||
return new ProtoBuf.Builder(options);
|
||||
};
|
||||
|
||||
/**
|
||||
* Loads a .json definition and returns the Builder.
|
||||
* @param {!*|string} json JSON definition
|
||||
* @param {(ProtoBuf.Builder|string|{root: string, file: string})=} builder Builder to append to. Will create a new one if omitted.
|
||||
* @param {(string|{root: string, file: string})=} filename The corresponding file name if known. Must be specified for imports.
|
||||
* @return {ProtoBuf.Builder} Builder to create new messages
|
||||
* @throws {Error} If the definition cannot be parsed or built
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.loadJson = function(json, builder, filename) {
|
||||
if (typeof builder === 'string' || (builder && typeof builder["file"] === 'string' && typeof builder["root"] === 'string'))
|
||||
filename = builder,
|
||||
builder = null;
|
||||
if (!builder || typeof builder !== 'object')
|
||||
builder = ProtoBuf.newBuilder();
|
||||
if (typeof json === 'string')
|
||||
json = JSON.parse(json);
|
||||
builder["import"](json, filename);
|
||||
builder.resolveAll();
|
||||
return builder;
|
||||
};
|
||||
|
||||
/**
|
||||
* Loads a .json file and returns the Builder.
|
||||
* @param {string|!{root: string, file: string}} filename Path to json file or an object specifying 'file' with
|
||||
* an overridden 'root' path for all imported files.
|
||||
* @param {function(?Error, !ProtoBuf.Builder=)=} callback Callback that will receive `null` as the first and
|
||||
* the Builder as its second argument on success, otherwise the error as its first argument. If omitted, the
|
||||
* file will be read synchronously and this function will return the Builder.
|
||||
* @param {ProtoBuf.Builder=} builder Builder to append to. Will create a new one if omitted.
|
||||
* @return {?ProtoBuf.Builder|undefined} The Builder if synchronous (no callback specified, will be NULL if the
|
||||
* request has failed), else undefined
|
||||
* @expose
|
||||
*/
|
||||
ProtoBuf.loadJsonFile = function(filename, callback, builder) {
|
||||
if (callback && typeof callback === 'object')
|
||||
builder = callback,
|
||||
callback = null;
|
||||
else if (!callback || typeof callback !== 'function')
|
||||
callback = null;
|
||||
if (callback)
|
||||
return ProtoBuf.Util.fetch(typeof filename === 'string' ? filename : filename["root"]+"/"+filename["file"], function(contents) {
|
||||
if (contents === null) {
|
||||
callback(Error("Failed to fetch file"));
|
||||
return;
|
||||
}
|
||||
try {
|
||||
callback(null, ProtoBuf.loadJson(JSON.parse(contents), builder, filename));
|
||||
} catch (e) {
|
||||
callback(e);
|
||||
}
|
||||
});
|
||||
var contents = ProtoBuf.Util.fetch(typeof filename === 'object' ? filename["root"]+"/"+filename["file"] : filename);
|
||||
return contents === null ? null : ProtoBuf.loadJson(JSON.parse(contents), builder, filename);
|
||||
};
|
||||
37
node_modules/protobufjs/src/wrap.js
generated
vendored
Normal file
37
node_modules/protobufjs/src/wrap.js
generated
vendored
Normal file
@ -0,0 +1,37 @@
|
||||
/*
|
||||
Copyright 2013 Daniel Wirtz <dcode@dcode.io>
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @license protobuf.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
|
||||
* Released under the Apache License, Version 2.0
|
||||
* see: https://github.com/dcodeIO/protobuf.js for details
|
||||
*/
|
||||
(function(global, factory) {
|
||||
|
||||
/* AMD */ if (typeof define === 'function' && define["amd"])
|
||||
define(["bytebuffer"], factory);
|
||||
/* CommonJS */ else if (typeof require === "function" && typeof module === "object" && module && module["exports"])
|
||||
module["exports"] = factory(require("bytebuffer"), true);
|
||||
/* Global */ else
|
||||
(global["dcodeIO"] = global["dcodeIO"] || {})["ProtoBuf"] = factory(global["dcodeIO"]["ByteBuffer"]);
|
||||
|
||||
})(this, function(ByteBuffer, isCommonJS) {
|
||||
"use strict";
|
||||
|
||||
//? include("protobuf.js");
|
||||
|
||||
return ProtoBuf;
|
||||
});
|
||||
Reference in New Issue
Block a user