legacy-libs/protobufjs/src/service.js

   1 "use strict";
   2 module.exports = Service;
   3
   4 // extends Namespace
   5 var Namespace = require("./namespace");
   6 ((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";
   7
   8 var Method = require("./method"),
   9     util   = require("./util"),
  10     rpc    = require("./rpc");
  11
  12 /**
  13  * Constructs a new service instance.
  14  * @classdesc Reflected service.
  15  * @extends NamespaceBase
  16  * @constructor
  17  * @param {string} name Service name
  18  * @param {Object.<string,*>} [options] Service options
  19  * @throws {TypeError} If arguments are invalid
  20  */
  21 function Service(name, options) {
  22     Namespace.call(this, name, options);
  23
  24     /**
  25      * Service methods.
  26      * @type {Object.<string,Method>}
  27      */
  28     this.methods = {}; // toJSON, marker
  29
  30     /**
  31      * Cached methods as an array.
  32      * @type {Method[]|null}
  33      * @private
  34      */
  35     this._methodsArray = null;
  36 }
  37
  38 /**
  39  * Service descriptor.
  40  * @interface IService
  41  * @extends INamespace
  42  * @property {Object.<string,IMethod>} methods Method descriptors
  43  */
  44
  45 /**
  46  * Constructs a service from a service descriptor.
  47  * @param {string} name Service name
  48  * @param {IService} json Service descriptor
  49  * @returns {Service} Created service
  50  * @throws {TypeError} If arguments are invalid
  51  */
  52 Service.fromJSON = function fromJSON(name, json) {
  53     var service = new Service(name, json.options);
  54     /* istanbul ignore else */
  55     if (json.methods)
  56         for (var names = Object.keys(json.methods), i = 0; i < names.length; ++i)
  57             service.add(Method.fromJSON(names[i], json.methods[names[i]]));
  58     if (json.nested)
  59         service.addJSON(json.nested);
  60     service.comment = json.comment;
  61     return service;
  62 };
  63
  64 /**
  65  * Converts this service to a service descriptor.
  66  * @param {IToJSONOptions} [toJSONOptions] JSON conversion options
  67  * @returns {IService} Service descriptor
  68  */
  69 Service.prototype.toJSON = function toJSON(toJSONOptions) {
  70     var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);
  71     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
  72     return util.toObject([
  73         "options" , inherited && inherited.options || undefined,
  74         "methods" , Namespace.arrayToJSON(this.methodsArray, toJSONOptions) || /* istanbul ignore next */ {},
  75         "nested"  , inherited && inherited.nested || undefined,
  76         "comment" , keepComments ? this.comment : undefined
  77     ]);
  78 };
  79
  80 /**
  81  * Methods of this service as an array for iteration.
  82  * @name Service#methodsArray
  83  * @type {Method[]}
  84  * @readonly
  85  */
  86 Object.defineProperty(Service.prototype, "methodsArray", {
  87     get: function() {
  88         return this._methodsArray || (this._methodsArray = util.toArray(this.methods));
  89     }
  90 });
  91
  92 function clearCache(service) {
  93     service._methodsArray = null;
  94     return service;
  95 }
  96
  97 /**
  98  * @override
  99  */
 100 Service.prototype.get = function get(name) {
 101     return this.methods[name]
 102         || Namespace.prototype.get.call(this, name);
 103 };
 104
 105 /**
 106  * @override
 107  */
 108 Service.prototype.resolveAll = function resolveAll() {
 109     var methods = this.methodsArray;
 110     for (var i = 0; i < methods.length; ++i)
 111         methods[i].resolve();
 112     return Namespace.prototype.resolve.call(this);
 113 };
 114
 115 /**
 116  * @override
 117  */
 118 Service.prototype.add = function add(object) {
 119
 120     /* istanbul ignore if */
 121     if (this.get(object.name))
 122         throw Error("duplicate name '" + object.name + "' in " + this);
 123
 124     if (object instanceof Method) {
 125         this.methods[object.name] = object;
 126         object.parent = this;
 127         return clearCache(this);
 128     }
 129     return Namespace.prototype.add.call(this, object);
 130 };
 131
 132 /**
 133  * @override
 134  */
 135 Service.prototype.remove = function remove(object) {
 136     if (object instanceof Method) {
 137
 138         /* istanbul ignore if */
 139         if (this.methods[object.name] !== object)
 140             throw Error(object + " is not a member of " + this);
 141
 142         delete this.methods[object.name];
 143         object.parent = null;
 144         return clearCache(this);
 145     }
 146     return Namespace.prototype.remove.call(this, object);
 147 };
 148
 149 /**
 150  * Creates a runtime service using the specified rpc implementation.
 151  * @param {RPCImpl} rpcImpl RPC implementation
 152  * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
 153  * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
 154  * @returns {rpc.Service} RPC service. Useful where requests and/or responses are streamed.
 155  */
 156 Service.prototype.create = function create(rpcImpl, requestDelimited, responseDelimited) {
 157     var rpcService = new rpc.Service(rpcImpl, requestDelimited, responseDelimited);
 158     for (var i = 0, method; i < /* initializes */ this.methodsArray.length; ++i) {
 159         var methodName = util.lcFirst((method = this._methodsArray[i]).resolve().name).replace(/[^$\w_]/g, "");
 160         rpcService[methodName] = util.codegen(["r","c"], util.isReserved(methodName) ? methodName + "_" : methodName)("return this.rpcCall(m,q,s,r,c)")({
 161             m: method,
 162             q: method.resolvedRequestType.ctor,
 163             s: method.resolvedResponseType.ctor
 164         });
 165     }
 166     return rpcService;
 167 };