1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// https://developers.google.com/protocol-buffers/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31/** 32 * @fileoverview Definition of jspb.Message. 33 * 34 * @author mwr@google.com (Mark Rawling) 35 */ 36 37goog.provide('jspb.ExtensionFieldInfo'); 38goog.provide('jspb.Message'); 39 40goog.require('goog.array'); 41goog.require('goog.asserts'); 42goog.require('goog.crypt.base64'); 43goog.require('goog.json'); 44 45// Not needed in compilation units that have no protos with xids. 46goog.forwardDeclare('xid.String'); 47 48 49 50/** 51 * Stores information for a single extension field. 52 * 53 * For example, an extension field defined like so: 54 * 55 * extend BaseMessage { 56 * optional MyMessage my_field = 123; 57 * } 58 * 59 * will result in an ExtensionFieldInfo object with these properties: 60 * 61 * { 62 * fieldIndex: 123, 63 * fieldName: {my_field_renamed: 0}, 64 * ctor: proto.example.MyMessage, 65 * toObjectFn: proto.example.MyMessage.toObject, 66 * isRepeated: 0 67 * } 68 * 69 * We include `toObjectFn` to allow the JSCompiler to perform dead-code removal 70 * on unused toObject() methods. 71 * 72 * If an extension field is primitive, ctor and toObjectFn will be null. 73 * isRepeated should be 0 or 1. 74 * 75 * binary{Reader,Writer}Fn and (if message type) binaryMessageSerializeFn are 76 * always provided. binaryReaderFn and binaryWriterFn are references to the 77 * appropriate methods on BinaryReader/BinaryWriter to read/write the value of 78 * this extension, and binaryMessageSerializeFn is a reference to the message 79 * class's .serializeBinary method, if available. 80 * 81 * @param {number} fieldNumber 82 * @param {Object} fieldName This has the extension field name as a property. 83 * @param {?function(new: jspb.Message, Array=)} ctor 84 * @param {?function((boolean|undefined),!jspb.Message):!Object} toObjectFn 85 * @param {number} isRepeated 86 * @param {?function(number,?)=} opt_binaryReaderFn 87 * @param {?function(number,?)|function(number,?,?,?,?,?)=} opt_binaryWriterFn 88 * @param {?function(?,?)=} opt_binaryMessageSerializeFn 89 * @param {?function(?,?)=} opt_binaryMessageDeserializeFn 90 * @param {?boolean=} opt_isPacked 91 * @constructor 92 * @struct 93 * @template T 94 */ 95jspb.ExtensionFieldInfo = function(fieldNumber, fieldName, ctor, toObjectFn, 96 isRepeated, opt_binaryReaderFn, opt_binaryWriterFn, 97 opt_binaryMessageSerializeFn, opt_binaryMessageDeserializeFn, 98 opt_isPacked) { 99 /** @const */ 100 this.fieldIndex = fieldNumber; 101 /** @const */ 102 this.fieldName = fieldName; 103 /** @const */ 104 this.ctor = ctor; 105 /** @const */ 106 this.toObjectFn = toObjectFn; 107 /** @const */ 108 this.binaryReaderFn = opt_binaryReaderFn; 109 /** @const */ 110 this.binaryWriterFn = opt_binaryWriterFn; 111 /** @const */ 112 this.binaryMessageSerializeFn = opt_binaryMessageSerializeFn; 113 /** @const */ 114 this.binaryMessageDeserializeFn = opt_binaryMessageDeserializeFn; 115 /** @const */ 116 this.isRepeated = isRepeated; 117 /** @const */ 118 this.isPacked = opt_isPacked; 119}; 120 121 122/** 123 * @return {boolean} Does this field represent a sub Message? 124 */ 125jspb.ExtensionFieldInfo.prototype.isMessageType = function() { 126 return !!this.ctor; 127}; 128 129 130/** 131 * Base class for all JsPb messages. 132 * @constructor 133 * @struct 134 */ 135jspb.Message = function() { 136}; 137 138 139/** 140 * @define {boolean} Whether to generate toObject methods for objects. Turn 141 * this off, if you do not want toObject to be ever used in your project. 142 * When turning off this flag, consider adding a conformance test that bans 143 * calling toObject. Enabling this will disable the JSCompiler's ability to 144 * dead code eliminate fields used in protocol buffers that are never used 145 * in an application. 146 */ 147goog.define('jspb.Message.GENERATE_TO_OBJECT', true); 148 149 150/** 151 * @define {boolean} Whether to generate fromObject methods for objects. Turn 152 * this off, if you do not want fromObject to be ever used in your project. 153 * When turning off this flag, consider adding a conformance test that bans 154 * calling fromObject. Enabling this might disable the JSCompiler's ability 155 * to dead code eliminate fields used in protocol buffers that are never 156 * used in an application. 157 * NOTE: By default no protos actually have a fromObject method. You need to 158 * add the jspb.generate_from_object options to the proto definition to 159 * activate the feature. 160 * By default this is enabled for test code only. 161 */ 162goog.define('jspb.Message.GENERATE_FROM_OBJECT', !goog.DISALLOW_TEST_ONLY_CODE); 163 164 165/** 166 * @define {boolean} Turning on this flag does NOT change the behavior of JSPB 167 * and only affects private internal state. It may, however, break some 168 * tests that use naive deeply-equals algorithms, because using a proto 169 * mutates its internal state. 170 * Projects are advised to turn this flag always on. 171 */ 172goog.define('jspb.Message.MINIMIZE_MEMORY_ALLOCATIONS', COMPILED); 173// TODO(b/19419436) Turn this on by default. 174 175 176/** 177 * Does this browser support Uint8Aray typed arrays? 178 * @type {boolean} 179 * @private 180 */ 181jspb.Message.SUPPORTS_UINT8ARRAY_ = (typeof Uint8Array == 'function'); 182 183 184/** 185 * The internal data array. 186 * @type {!Array} 187 * @protected 188 */ 189jspb.Message.prototype.array; 190 191 192/** 193 * Wrappers are the constructed instances of message-type fields. They are built 194 * on demand from the raw array data. Includes message fields, repeated message 195 * fields and extension message fields. Indexed by field number. 196 * @type {Object} 197 * @private 198 */ 199jspb.Message.prototype.wrappers_; 200 201 202/** 203 * The object that contains extension fields, if any. This is an object that 204 * maps from a proto field number to the field's value. 205 * @type {Object} 206 * @private 207 */ 208jspb.Message.prototype.extensionObject_; 209 210 211/** 212 * Non-extension fields with a field number at or above the pivot are 213 * stored in the extension object (in addition to all extension fields). 214 * @type {number} 215 * @private 216 */ 217jspb.Message.prototype.pivot_; 218 219 220/** 221 * The JsPb message_id of this proto. 222 * @type {string|undefined} the message id or undefined if this message 223 * has no id. 224 * @private 225 */ 226jspb.Message.prototype.messageId_; 227 228 229/** 230 * Repeated float or double fields which have been converted to include only 231 * numbers and not strings holding "NaN", "Infinity" and "-Infinity". 232 * @private {!Object<number,boolean>|undefined} 233 */ 234jspb.Message.prototype.convertedFloatingPointFields_; 235 236 237/** 238 * The xid of this proto type (The same for all instances of a proto). Provides 239 * a way to identify a proto by stable obfuscated name. 240 * @see {xid}. 241 * Available if {@link jspb.generate_xid} is added as a Message option to 242 * a protocol buffer. 243 * @const {!xid.String|undefined} The xid or undefined if message is 244 * annotated to generate the xid. 245 */ 246jspb.Message.prototype.messageXid; 247 248 249 250/** 251 * Returns the JsPb message_id of this proto. 252 * @return {string|undefined} the message id or undefined if this message 253 * has no id. 254 */ 255jspb.Message.prototype.getJsPbMessageId = function() { 256 return this.messageId_; 257}; 258 259 260/** 261 * An offset applied to lookups into this.array to account for the presence or 262 * absence of a messageId at position 0. For response messages, this will be 0. 263 * Otherwise, it will be -1 so that the first array position is not wasted. 264 * @type {number} 265 * @private 266 */ 267jspb.Message.prototype.arrayIndexOffset_; 268 269 270/** 271 * Returns the index into msg.array at which the proto field with tag number 272 * fieldNumber will be located. 273 * @param {!jspb.Message} msg Message for which we're calculating an index. 274 * @param {number} fieldNumber The field number. 275 * @return {number} The index. 276 * @private 277 */ 278jspb.Message.getIndex_ = function(msg, fieldNumber) { 279 return fieldNumber + msg.arrayIndexOffset_; 280}; 281 282 283/** 284 * Initializes a JsPb Message. 285 * @param {!jspb.Message} msg The JsPb proto to modify. 286 * @param {Array|undefined} data An initial data array. 287 * @param {string|number} messageId For response messages, the message id or '' 288 * if no message id is specified. For non-response messages, 0. 289 * @param {number} suggestedPivot The field number at which to start putting 290 * fields into the extension object. This is only used if data does not 291 * contain an extension object already. -1 if no extension object is 292 * required for this message type. 293 * @param {Array<number>} repeatedFields The message's repeated fields. 294 * @param {Array<!Array<number>>=} opt_oneofFields The fields belonging to 295 * each of the message's oneof unions. 296 * @protected 297 */ 298jspb.Message.initialize = function( 299 msg, data, messageId, suggestedPivot, repeatedFields, opt_oneofFields) { 300 msg.wrappers_ = jspb.Message.MINIMIZE_MEMORY_ALLOCATIONS ? null : {}; 301 if (!data) { 302 data = messageId ? [messageId] : []; 303 } 304 msg.messageId_ = messageId ? String(messageId) : undefined; 305 // If the messageId is 0, this message is not a response message, so we shift 306 // array indices down by 1 so as not to waste the first position in the array, 307 // which would otherwise go unused. 308 msg.arrayIndexOffset_ = messageId === 0 ? -1 : 0; 309 msg.array = data; 310 jspb.Message.materializeExtensionObject_(msg, suggestedPivot); 311 msg.convertedFloatingPointFields_ = {}; 312 313 if (repeatedFields) { 314 for (var i = 0; i < repeatedFields.length; i++) { 315 var fieldNumber = repeatedFields[i]; 316 if (fieldNumber < msg.pivot_) { 317 var index = jspb.Message.getIndex_(msg, fieldNumber); 318 msg.array[index] = msg.array[index] || 319 (jspb.Message.MINIMIZE_MEMORY_ALLOCATIONS ? 320 jspb.Message.EMPTY_LIST_SENTINEL_ : 321 []); 322 } else { 323 msg.extensionObject_[fieldNumber] = 324 msg.extensionObject_[fieldNumber] || 325 (jspb.Message.MINIMIZE_MEMORY_ALLOCATIONS ? 326 jspb.Message.EMPTY_LIST_SENTINEL_ : 327 []); 328 } 329 } 330 } 331 332 if (opt_oneofFields && opt_oneofFields.length) { 333 // Compute the oneof case for each union. This ensures only one value is 334 // set in the union. 335 goog.array.forEach( 336 opt_oneofFields, goog.partial(jspb.Message.computeOneofCase, msg)); 337 } 338}; 339 340 341/** 342 * Used to mark empty repeated fields. Serializes to null when serialized 343 * to JSON. 344 * When reading a repeated field readers must check the return value against 345 * this value and return and replace it with a new empty array if it is 346 * present. 347 * @private @const {!Object} 348 */ 349jspb.Message.EMPTY_LIST_SENTINEL_ = goog.DEBUG && Object.freeze ? 350 Object.freeze([]) : 351 []; 352 353 354/** 355 * Ensures that the array contains an extension object if necessary. 356 * If the array contains an extension object in its last position, then the 357 * object is kept in place and its position is used as the pivot. If not, then 358 * create an extension object using suggestedPivot. If suggestedPivot is -1, 359 * we don't have an extension object at all, in which case all fields are stored 360 * in the array. 361 * @param {!jspb.Message} msg The JsPb proto to modify. 362 * @param {number} suggestedPivot See description for initialize(). 363 * @private 364 */ 365jspb.Message.materializeExtensionObject_ = function(msg, suggestedPivot) { 366 if (msg.array.length) { 367 var foundIndex = msg.array.length - 1; 368 var obj = msg.array[foundIndex]; 369 // Normal fields are never objects, so we can be sure that if we find an 370 // object here, then it's the extension object. However, we must ensure that 371 // the object is not an array, since arrays are valid field values. 372 // NOTE(lukestebbing): We avoid looking at .length to avoid a JIT bug 373 // in Safari on iOS 8. See the description of CL/86511464 for details. 374 if (obj && typeof obj == 'object' && !goog.isArray(obj)) { 375 msg.pivot_ = foundIndex - msg.arrayIndexOffset_; 376 msg.extensionObject_ = obj; 377 return; 378 } 379 } 380 // This complexity exists because we keep all extension fields in the 381 // extensionObject_ regardless of proto field number. Changing this would 382 // simplify the code here, but it would require changing the serialization 383 // format from the server, which is not backwards compatible. 384 // TODO(jshneier): Should we just treat extension fields the same as 385 // non-extension fields, and select whether they appear in the object or in 386 // the array purely based on tag number? This would allow simplifying all the 387 // get/setExtension logic, but it would require the breaking change described 388 // above. 389 if (suggestedPivot > -1) { 390 msg.pivot_ = suggestedPivot; 391 var pivotIndex = jspb.Message.getIndex_(msg, suggestedPivot); 392 if (!jspb.Message.MINIMIZE_MEMORY_ALLOCATIONS) { 393 msg.extensionObject_ = msg.array[pivotIndex] = {}; 394 } else { 395 // Initialize to null to avoid changing the shape of the proto when it 396 // gets eventually set. 397 msg.extensionObject_ = null; 398 } 399 } else { 400 msg.pivot_ = Number.MAX_VALUE; 401 } 402}; 403 404 405/** 406 * Creates an empty extensionObject_ if non exists. 407 * @param {!jspb.Message} msg The JsPb proto to modify. 408 * @private 409 */ 410jspb.Message.maybeInitEmptyExtensionObject_ = function(msg) { 411 var pivotIndex = jspb.Message.getIndex_(msg, msg.pivot_); 412 if (!msg.array[pivotIndex]) { 413 msg.extensionObject_ = msg.array[pivotIndex] = {}; 414 } 415}; 416 417 418/** 419 * Converts a JsPb repeated message field into an object list. 420 * @param {!Array<T>} field The repeated message field to be 421 * converted. 422 * @param {?function(boolean=): Object| 423 * function((boolean|undefined),T): Object} toObjectFn The toObject 424 * function for this field. We need to pass this for effective dead code 425 * removal. 426 * @param {boolean=} opt_includeInstance Whether to include the JSPB instance 427 * for transitional soy proto support: http://goto/soy-param-migration 428 * @return {!Array<Object>} An array of converted message objects. 429 * @template T 430 */ 431jspb.Message.toObjectList = function(field, toObjectFn, opt_includeInstance) { 432 // Not using goog.array.map in the generated code to keep it small. 433 // And not using it here to avoid a function call. 434 var result = []; 435 for (var i = 0; i < field.length; i++) { 436 result[i] = toObjectFn.call(field[i], opt_includeInstance, 437 /** @type {!jspb.Message} */ (field[i])); 438 } 439 return result; 440}; 441 442 443/** 444 * Adds a proto's extension data to a Soy rendering object. 445 * @param {!jspb.Message} proto The proto whose extensions to convert. 446 * @param {!Object} obj The Soy object to add converted extension data to. 447 * @param {!Object} extensions The proto class' registered extensions. 448 * @param {function(this:?, jspb.ExtensionFieldInfo) : *} getExtensionFn 449 * The proto class' getExtension function. Passed for effective dead code 450 * removal. 451 * @param {boolean=} opt_includeInstance Whether to include the JSPB instance 452 * for transitional soy proto support: http://goto/soy-param-migration 453 */ 454jspb.Message.toObjectExtension = function(proto, obj, extensions, 455 getExtensionFn, opt_includeInstance) { 456 for (var fieldNumber in extensions) { 457 var fieldInfo = extensions[fieldNumber]; 458 var value = getExtensionFn.call(proto, fieldInfo); 459 if (value) { 460 for (var name in fieldInfo.fieldName) { 461 if (fieldInfo.fieldName.hasOwnProperty(name)) { 462 break; // the compiled field name 463 } 464 } 465 if (!fieldInfo.toObjectFn) { 466 obj[name] = value; 467 } else { 468 if (fieldInfo.isRepeated) { 469 obj[name] = jspb.Message.toObjectList( 470 /** @type {!Array<jspb.Message>} */ (value), 471 fieldInfo.toObjectFn, opt_includeInstance); 472 } else { 473 obj[name] = fieldInfo.toObjectFn(opt_includeInstance, value); 474 } 475 } 476 } 477 } 478}; 479 480 481/** 482 * Writes a proto's extension data to a binary-format output stream. 483 * @param {!jspb.Message} proto The proto whose extensions to convert. 484 * @param {*} writer The binary-format writer to write to. 485 * @param {!Object} extensions The proto class' registered extensions. 486 * @param {function(jspb.ExtensionFieldInfo) : *} getExtensionFn The proto 487 * class' getExtension function. Passed for effective dead code removal. 488 */ 489jspb.Message.serializeBinaryExtensions = function(proto, writer, extensions, 490 getExtensionFn) { 491 for (var fieldNumber in extensions) { 492 var fieldInfo = extensions[fieldNumber]; 493 // The old codegen doesn't add the extra fields to ExtensionFieldInfo, so we 494 // need to gracefully error-out here rather than produce a null dereference 495 // below. 496 if (!fieldInfo.binaryWriterFn) { 497 throw new Error('Message extension present that was generated ' + 498 'without binary serialization support'); 499 } 500 var value = getExtensionFn.call(proto, fieldInfo); 501 if (value) { 502 if (fieldInfo.isMessageType()) { 503 // If the message type of the extension was generated without binary 504 // support, there may not be a binary message serializer function, and 505 // we can't know when we codegen the extending message that the extended 506 // message may require binary support, so we can *only* catch this error 507 // here, at runtime (and this decoupled codegen is the whole point of 508 // extensions!). 509 if (fieldInfo.binaryMessageSerializeFn) { 510 fieldInfo.binaryWriterFn.call(writer, fieldInfo.fieldIndex, 511 value, fieldInfo.binaryMessageSerializeFn); 512 } else { 513 throw new Error('Message extension present holding submessage ' + 514 'without binary support enabled, and message is ' + 515 'being serialized to binary format'); 516 } 517 } else { 518 fieldInfo.binaryWriterFn.call(writer, fieldInfo.fieldIndex, value); 519 } 520 } 521 } 522}; 523 524 525/** 526 * Reads an extension field from the given reader and, if a valid extension, 527 * sets the extension value. 528 * @param {!jspb.Message} msg A jspb proto. 529 * @param {{skipField:function(),getFieldNumber:function():number}} reader 530 * @param {!Object} extensions The extensions object. 531 * @param {function(jspb.ExtensionFieldInfo)} getExtensionFn 532 * @param {function(jspb.ExtensionFieldInfo, ?)} setExtensionFn 533 */ 534jspb.Message.readBinaryExtension = function(msg, reader, extensions, 535 getExtensionFn, setExtensionFn) { 536 var fieldInfo = extensions[reader.getFieldNumber()]; 537 if (!fieldInfo) { 538 reader.skipField(); 539 return; 540 } 541 if (!fieldInfo.binaryReaderFn) { 542 throw new Error('Deserializing extension whose generated code does not ' + 543 'support binary format'); 544 } 545 546 var value; 547 if (fieldInfo.isMessageType()) { 548 value = new fieldInfo.ctor(); 549 fieldInfo.binaryReaderFn.call( 550 reader, value, fieldInfo.binaryMessageDeserializeFn); 551 } else { 552 // All other types. 553 value = fieldInfo.binaryReaderFn.call(reader); 554 } 555 556 if (fieldInfo.isRepeated && !fieldInfo.isPacked) { 557 var currentList = getExtensionFn.call(msg, fieldInfo); 558 if (!currentList) { 559 setExtensionFn.call(msg, fieldInfo, [value]); 560 } else { 561 currentList.push(value); 562 } 563 } else { 564 setExtensionFn.call(msg, fieldInfo, value); 565 } 566}; 567 568 569/** 570 * Gets the value of a non-extension field. 571 * @param {!jspb.Message} msg A jspb proto. 572 * @param {number} fieldNumber The field number. 573 * @return {string|number|boolean|Uint8Array|Array|null|undefined} 574 * The field's value. 575 * @protected 576 */ 577jspb.Message.getField = function(msg, fieldNumber) { 578 if (fieldNumber < msg.pivot_) { 579 var index = jspb.Message.getIndex_(msg, fieldNumber); 580 var val = msg.array[index]; 581 if (val === jspb.Message.EMPTY_LIST_SENTINEL_) { 582 return msg.array[index] = []; 583 } 584 return val; 585 } else { 586 var val = msg.extensionObject_[fieldNumber]; 587 if (val === jspb.Message.EMPTY_LIST_SENTINEL_) { 588 return msg.extensionObject_[fieldNumber] = []; 589 } 590 return val; 591 } 592}; 593 594 595/** 596 * Gets the value of an optional float or double field. 597 * @param {!jspb.Message} msg A jspb proto. 598 * @param {number} fieldNumber The field number. 599 * @return {?number|undefined} The field's value. 600 * @protected 601 */ 602jspb.Message.getOptionalFloatingPointField = function(msg, fieldNumber) { 603 var value = jspb.Message.getField(msg, fieldNumber); 604 // Converts "NaN", "Infinity" and "-Infinity" to their corresponding numbers. 605 return value == null ? value : +value; 606}; 607 608 609/** 610 * Gets the value of a repeated float or double field. 611 * @param {!jspb.Message} msg A jspb proto. 612 * @param {number} fieldNumber The field number. 613 * @return {!Array<number>} The field's value. 614 * @protected 615 */ 616jspb.Message.getRepeatedFloatingPointField = function(msg, fieldNumber) { 617 var values = jspb.Message.getField(msg, fieldNumber); 618 if (!msg.convertedFloatingPointFields_) { 619 msg.convertedFloatingPointFields_ = {}; 620 } 621 if (!msg.convertedFloatingPointFields_[fieldNumber]) { 622 for (var i = 0; i < values.length; i++) { 623 // Converts "NaN", "Infinity" and "-Infinity" to their corresponding 624 // numbers. 625 values[i] = +values[i]; 626 } 627 msg.convertedFloatingPointFields_[fieldNumber] = true; 628 } 629 return /** @type {!Array<number>} */ (values); 630}; 631 632 633/** 634 * Coerce a 'bytes' field to a base 64 string. 635 * @param {string|Uint8Array|null} value 636 * @return {?string} The field's coerced value. 637 */ 638jspb.Message.bytesAsB64 = function(value) { 639 if (value == null || goog.isString(value)) { 640 return value; 641 } 642 if (jspb.Message.SUPPORTS_UINT8ARRAY_ && value instanceof Uint8Array) { 643 return goog.crypt.base64.encodeByteArray(value); 644 } 645 goog.asserts.fail('Cannot coerce to b64 string: ' + goog.typeOf(value)); 646 return null; 647}; 648 649 650/** 651 * Coerce a 'bytes' field to a Uint8Array byte buffer. 652 * Note that Uint8Array is not supported on IE versions before 10 nor on Opera 653 * Mini. @see http://caniuse.com/Uint8Array 654 * @param {string|Uint8Array|null} value 655 * @return {?Uint8Array} The field's coerced value. 656 */ 657jspb.Message.bytesAsU8 = function(value) { 658 if (value == null || value instanceof Uint8Array) { 659 return value; 660 } 661 if (goog.isString(value)) { 662 return goog.crypt.base64.decodeStringToUint8Array(value); 663 } 664 goog.asserts.fail('Cannot coerce to Uint8Array: ' + goog.typeOf(value)); 665 return null; 666}; 667 668 669/** 670 * Coerce a repeated 'bytes' field to an array of base 64 strings. 671 * Note: the returned array should be treated as immutable. 672 * @param {!Array<string>|!Array<!Uint8Array>} value 673 * @return {!Array<string?>} The field's coerced value. 674 */ 675jspb.Message.bytesListAsB64 = function(value) { 676 jspb.Message.assertConsistentTypes_(value); 677 if (!value.length || goog.isString(value[0])) { 678 return /** @type {!Array<string>} */ (value); 679 } 680 return goog.array.map(value, jspb.Message.bytesAsB64); 681}; 682 683 684/** 685 * Coerce a repeated 'bytes' field to an array of Uint8Array byte buffers. 686 * Note: the returned array should be treated as immutable. 687 * Note that Uint8Array is not supported on IE versions before 10 nor on Opera 688 * Mini. @see http://caniuse.com/Uint8Array 689 * @param {!Array<string>|!Array<!Uint8Array>} value 690 * @return {!Array<Uint8Array?>} The field's coerced value. 691 */ 692jspb.Message.bytesListAsU8 = function(value) { 693 jspb.Message.assertConsistentTypes_(value); 694 if (!value.length || value[0] instanceof Uint8Array) { 695 return /** @type {!Array<!Uint8Array>} */ (value); 696 } 697 return goog.array.map(value, jspb.Message.bytesAsU8); 698}; 699 700 701/** 702 * Asserts that all elements of an array are of the same type. 703 * @param {Array?} array The array to test. 704 * @private 705 */ 706jspb.Message.assertConsistentTypes_ = function(array) { 707 if (goog.DEBUG && array && array.length > 1) { 708 var expected = goog.typeOf(array[0]); 709 goog.array.forEach(array, function(e) { 710 if (goog.typeOf(e) != expected) { 711 goog.asserts.fail('Inconsistent type in JSPB repeated field array. ' + 712 'Got ' + goog.typeOf(e) + ' expected ' + expected); 713 } 714 }); 715 } 716}; 717 718 719/** 720 * Gets the value of a non-extension primitive field, with proto3 (non-nullable 721 * primitives) semantics. Returns `defaultValue` if the field is not otherwise 722 * set. 723 * @template T 724 * @param {!jspb.Message} msg A jspb proto. 725 * @param {number} fieldNumber The field number. 726 * @param {T} defaultValue The default value. 727 * @return {T} The field's value. 728 * @protected 729 */ 730jspb.Message.getFieldProto3 = function(msg, fieldNumber, defaultValue) { 731 var value = jspb.Message.getField(msg, fieldNumber); 732 if (value == null) { 733 return defaultValue; 734 } else { 735 return value; 736 } 737}; 738 739 740/** 741 * Sets the value of a non-extension field. 742 * @param {!jspb.Message} msg A jspb proto. 743 * @param {number} fieldNumber The field number. 744 * @param {string|number|boolean|Uint8Array|Array|undefined} value New value 745 * @protected 746 */ 747jspb.Message.setField = function(msg, fieldNumber, value) { 748 if (fieldNumber < msg.pivot_) { 749 msg.array[jspb.Message.getIndex_(msg, fieldNumber)] = value; 750 } else { 751 msg.extensionObject_[fieldNumber] = value; 752 } 753}; 754 755 756/** 757 * Sets the value of a field in a oneof union and clears all other fields in 758 * the union. 759 * @param {!jspb.Message} msg A jspb proto. 760 * @param {number} fieldNumber The field number. 761 * @param {!Array<number>} oneof The fields belonging to the union. 762 * @param {string|number|boolean|Uint8Array|Array|undefined} value New value 763 * @protected 764 */ 765jspb.Message.setOneofField = function(msg, fieldNumber, oneof, value) { 766 var currentCase = jspb.Message.computeOneofCase(msg, oneof); 767 if (currentCase && currentCase !== fieldNumber && value !== undefined) { 768 if (msg.wrappers_ && currentCase in msg.wrappers_) { 769 msg.wrappers_[currentCase] = undefined; 770 } 771 jspb.Message.setField(msg, currentCase, undefined); 772 } 773 jspb.Message.setField(msg, fieldNumber, value); 774}; 775 776 777/** 778 * Computes the selection in a oneof group for the given message, ensuring 779 * only one field is set in the process. 780 * 781 * According to the protobuf language guide ( 782 * https://developers.google.com/protocol-buffers/docs/proto#oneof), "if the 783 * parser encounters multiple members of the same oneof on the wire, only the 784 * last member seen is used in the parsed message." Since JSPB serializes 785 * messages to a JSON array, the "last member seen" will always be the field 786 * with the greatest field number (directly corresponding to the greatest 787 * array index). 788 * 789 * @param {!jspb.Message} msg A jspb proto. 790 * @param {!Array<number>} oneof The field numbers belonging to the union. 791 * @return {number} The field number currently set in the union, or 0 if none. 792 * @protected 793 */ 794jspb.Message.computeOneofCase = function(msg, oneof) { 795 var oneofField; 796 var oneofValue; 797 798 goog.array.forEach(oneof, function(fieldNumber) { 799 var value = jspb.Message.getField(msg, fieldNumber); 800 if (goog.isDefAndNotNull(value)) { 801 oneofField = fieldNumber; 802 oneofValue = value; 803 jspb.Message.setField(msg, fieldNumber, undefined); 804 } 805 }); 806 807 if (oneofField) { 808 // NB: We know the value is unique, so we can call jspb.Message.setField 809 // directly instead of jpsb.Message.setOneofField. Also, setOneofField 810 // calls this function. 811 jspb.Message.setField(msg, oneofField, oneofValue); 812 return oneofField; 813 } 814 815 return 0; 816}; 817 818 819/** 820 * Gets and wraps a proto field on access. 821 * @param {!jspb.Message} msg A jspb proto. 822 * @param {function(new:jspb.Message, Array)} ctor Constructor for the field. 823 * @param {number} fieldNumber The field number. 824 * @param {number=} opt_required True (1) if this is a required field. 825 * @return {jspb.Message} The field as a jspb proto. 826 * @protected 827 */ 828jspb.Message.getWrapperField = function(msg, ctor, fieldNumber, opt_required) { 829 // TODO(mwr): Consider copying data and/or arrays. 830 if (!msg.wrappers_) { 831 msg.wrappers_ = {}; 832 } 833 if (!msg.wrappers_[fieldNumber]) { 834 var data = /** @type {Array} */ (jspb.Message.getField(msg, fieldNumber)); 835 if (opt_required || data) { 836 // TODO(mwr): Remove existence test for always valid default protos. 837 msg.wrappers_[fieldNumber] = new ctor(data); 838 } 839 } 840 return /** @type {jspb.Message} */ (msg.wrappers_[fieldNumber]); 841}; 842 843 844/** 845 * Gets and wraps a repeated proto field on access. 846 * @param {!jspb.Message} msg A jspb proto. 847 * @param {function(new:jspb.Message, Array)} ctor Constructor for the field. 848 * @param {number} fieldNumber The field number. 849 * @return {Array<!jspb.Message>} The repeated field as an array of protos. 850 * @protected 851 */ 852jspb.Message.getRepeatedWrapperField = function(msg, ctor, fieldNumber) { 853 if (!msg.wrappers_) { 854 msg.wrappers_ = {}; 855 } 856 if (!msg.wrappers_[fieldNumber]) { 857 var data = jspb.Message.getField(msg, fieldNumber); 858 for (var wrappers = [], i = 0; i < data.length; i++) { 859 wrappers[i] = new ctor(data[i]); 860 } 861 msg.wrappers_[fieldNumber] = wrappers; 862 } 863 var val = msg.wrappers_[fieldNumber]; 864 if (val == jspb.Message.EMPTY_LIST_SENTINEL_) { 865 val = msg.wrappers_[fieldNumber] = []; 866 } 867 return /** @type {Array<!jspb.Message>} */ (val); 868}; 869 870 871/** 872 * Sets a proto field and syncs it to the backing array. 873 * @param {!jspb.Message} msg A jspb proto. 874 * @param {number} fieldNumber The field number. 875 * @param {jspb.Message|undefined} value A new value for this proto field. 876 * @protected 877 */ 878jspb.Message.setWrapperField = function(msg, fieldNumber, value) { 879 if (!msg.wrappers_) { 880 msg.wrappers_ = {}; 881 } 882 var data = value ? value.toArray() : value; 883 msg.wrappers_[fieldNumber] = value; 884 jspb.Message.setField(msg, fieldNumber, data); 885}; 886 887 888/** 889 * Sets a proto field in a oneof union and syncs it to the backing array. 890 * @param {!jspb.Message} msg A jspb proto. 891 * @param {number} fieldNumber The field number. 892 * @param {!Array<number>} oneof The fields belonging to the union. 893 * @param {jspb.Message|undefined} value A new value for this proto field. 894 * @protected 895 */ 896jspb.Message.setOneofWrapperField = function(msg, fieldNumber, oneof, value) { 897 if (!msg.wrappers_) { 898 msg.wrappers_ = {}; 899 } 900 var data = value ? value.toArray() : value; 901 msg.wrappers_[fieldNumber] = value; 902 jspb.Message.setOneofField(msg, fieldNumber, oneof, data); 903}; 904 905 906/** 907 * Sets a repeated proto field and syncs it to the backing array. 908 * @param {!jspb.Message} msg A jspb proto. 909 * @param {number} fieldNumber The field number. 910 * @param {Array<!jspb.Message>|undefined} value An array of protos. 911 * @protected 912 */ 913jspb.Message.setRepeatedWrapperField = function(msg, fieldNumber, value) { 914 if (!msg.wrappers_) { 915 msg.wrappers_ = {}; 916 } 917 value = value || []; 918 for (var data = [], i = 0; i < value.length; i++) { 919 data[i] = value[i].toArray(); 920 } 921 msg.wrappers_[fieldNumber] = value; 922 jspb.Message.setField(msg, fieldNumber, data); 923}; 924 925 926/** 927 * Converts a JsPb repeated message field into a map. The map will contain 928 * protos unless an optional toObject function is given, in which case it will 929 * contain objects suitable for Soy rendering. 930 * @param {!Array<T>} field The repeated message field to be 931 * converted. 932 * @param {function() : string?} mapKeyGetterFn The function to get the key of 933 * the map. 934 * @param {?function(boolean=): Object| 935 * function((boolean|undefined),T): Object} opt_toObjectFn The 936 * toObject function for this field. We need to pass this for effective 937 * dead code removal. 938 * @param {boolean=} opt_includeInstance Whether to include the JSPB instance 939 * for transitional soy proto support: http://goto/soy-param-migration 940 * @return {!Object.<string, Object>} A map of proto or Soy objects. 941 * @template T 942 */ 943jspb.Message.toMap = function( 944 field, mapKeyGetterFn, opt_toObjectFn, opt_includeInstance) { 945 var result = {}; 946 for (var i = 0; i < field.length; i++) { 947 result[mapKeyGetterFn.call(field[i])] = opt_toObjectFn ? 948 opt_toObjectFn.call(field[i], opt_includeInstance, 949 /** @type {!jspb.Message} */ (field[i])) : field[i]; 950 } 951 return result; 952}; 953 954 955/** 956 * Returns the internal array of this proto. 957 * <p>Note: If you use this array to construct a second proto, the content 958 * would then be partially shared between the two protos. 959 * @return {!Array} The proto represented as an array. 960 */ 961jspb.Message.prototype.toArray = function() { 962 return this.array; 963}; 964 965 966 967 968/** 969 * Creates a string representation of the internal data array of this proto. 970 * <p>NOTE: This string is *not* suitable for use in server requests. 971 * @return {string} A string representation of this proto. 972 * @override 973 */ 974jspb.Message.prototype.toString = function() { 975 return this.array.toString(); 976}; 977 978 979/** 980 * Gets the value of the extension field from the extended object. 981 * @param {jspb.ExtensionFieldInfo.<T>} fieldInfo Specifies the field to get. 982 * @return {T} The value of the field. 983 * @template T 984 */ 985jspb.Message.prototype.getExtension = function(fieldInfo) { 986 if (!this.extensionObject_) { 987 return undefined; 988 } 989 if (!this.wrappers_) { 990 this.wrappers_ = {}; 991 } 992 var fieldNumber = fieldInfo.fieldIndex; 993 if (fieldInfo.isRepeated) { 994 if (fieldInfo.isMessageType()) { 995 if (!this.wrappers_[fieldNumber]) { 996 this.wrappers_[fieldNumber] = 997 goog.array.map(this.extensionObject_[fieldNumber] || [], 998 function(arr) { 999 return new fieldInfo.ctor(arr); 1000 }); 1001 } 1002 return this.wrappers_[fieldNumber]; 1003 } else { 1004 return this.extensionObject_[fieldNumber]; 1005 } 1006 } else { 1007 if (fieldInfo.isMessageType()) { 1008 if (!this.wrappers_[fieldNumber] && this.extensionObject_[fieldNumber]) { 1009 this.wrappers_[fieldNumber] = new fieldInfo.ctor( 1010 /** @type {Array|undefined} */ ( 1011 this.extensionObject_[fieldNumber])); 1012 } 1013 return this.wrappers_[fieldNumber]; 1014 } else { 1015 return this.extensionObject_[fieldNumber]; 1016 } 1017 } 1018}; 1019 1020 1021/** 1022 * Sets the value of the extension field in the extended object. 1023 * @param {jspb.ExtensionFieldInfo} fieldInfo Specifies the field to set. 1024 * @param {jspb.Message|string|Uint8Array|number|boolean|Array?} value The value 1025 * to set. 1026 */ 1027jspb.Message.prototype.setExtension = function(fieldInfo, value) { 1028 if (!this.wrappers_) { 1029 this.wrappers_ = {}; 1030 } 1031 jspb.Message.maybeInitEmptyExtensionObject_(this); 1032 var fieldNumber = fieldInfo.fieldIndex; 1033 if (fieldInfo.isRepeated) { 1034 value = value || []; 1035 if (fieldInfo.isMessageType()) { 1036 this.wrappers_[fieldNumber] = value; 1037 this.extensionObject_[fieldNumber] = goog.array.map( 1038 /** @type {Array<jspb.Message>} */ (value), function(msg) { 1039 return msg.toArray(); 1040 }); 1041 } else { 1042 this.extensionObject_[fieldNumber] = value; 1043 } 1044 } else { 1045 if (fieldInfo.isMessageType()) { 1046 this.wrappers_[fieldNumber] = value; 1047 this.extensionObject_[fieldNumber] = value ? value.toArray() : value; 1048 } else { 1049 this.extensionObject_[fieldNumber] = value; 1050 } 1051 } 1052}; 1053 1054 1055/** 1056 * Creates a difference object between two messages. 1057 * 1058 * The result will contain the top-level fields of m2 that differ from those of 1059 * m1 at any level of nesting. No data is cloned, the result object will 1060 * share its top-level elements with m2 (but not with m1). 1061 * 1062 * Note that repeated fields should not have null/undefined elements, but if 1063 * they do, this operation will treat repeated fields of different length as 1064 * the same if the only difference between them is due to trailing 1065 * null/undefined values. 1066 * 1067 * @param {!jspb.Message} m1 The first message object. 1068 * @param {!jspb.Message} m2 The second message object. 1069 * @return {!jspb.Message} The difference returned as a proto message. 1070 * Note that the returned message may be missing required fields. This is 1071 * currently tolerated in Js, but would cause an error if you tried to 1072 * send such a proto to the server. You can access the raw difference 1073 * array with result.toArray(). 1074 * @throws {Error} If the messages are responses with different types. 1075 */ 1076jspb.Message.difference = function(m1, m2) { 1077 if (!(m1 instanceof m2.constructor)) { 1078 throw new Error('Messages have different types.'); 1079 } 1080 var arr1 = m1.toArray(); 1081 var arr2 = m2.toArray(); 1082 var res = []; 1083 var start = 0; 1084 var length = arr1.length > arr2.length ? arr1.length : arr2.length; 1085 if (m1.getJsPbMessageId()) { 1086 res[0] = m1.getJsPbMessageId(); 1087 start = 1; 1088 } 1089 for (var i = start; i < length; i++) { 1090 if (!jspb.Message.compareFields(arr1[i], arr2[i])) { 1091 res[i] = arr2[i]; 1092 } 1093 } 1094 return new m1.constructor(res); 1095}; 1096 1097 1098/** 1099 * Tests whether two messages are equal. 1100 * @param {jspb.Message|undefined} m1 The first message object. 1101 * @param {jspb.Message|undefined} m2 The second message object. 1102 * @return {boolean} true if both messages are null/undefined, or if both are 1103 * of the same type and have the same field values. 1104 */ 1105jspb.Message.equals = function(m1, m2) { 1106 return m1 == m2 || (!!(m1 && m2) && (m1 instanceof m2.constructor) && 1107 jspb.Message.compareFields(m1.toArray(), m2.toArray())); 1108}; 1109 1110 1111/** 1112 * Compares two message extension fields recursively. 1113 * @param {!Object} extension1 The first field. 1114 * @param {!Object} extension2 The second field. 1115 * @return {boolean} true if the extensions are null/undefined, or otherwise 1116 * equal. 1117 */ 1118jspb.Message.compareExtensions = function(extension1, extension2) { 1119 extension1 = extension1 || {}; 1120 extension2 = extension2 || {}; 1121 1122 var keys = {}; 1123 for (var name in extension1) { 1124 keys[name] = 0; 1125 } 1126 for (var name in extension2) { 1127 keys[name] = 0; 1128 } 1129 for (name in keys) { 1130 if (!jspb.Message.compareFields(extension1[name], extension2[name])) { 1131 return false; 1132 } 1133 } 1134 return true; 1135}; 1136 1137 1138/** 1139 * Compares two message fields recursively. 1140 * @param {*} field1 The first field. 1141 * @param {*} field2 The second field. 1142 * @return {boolean} true if the fields are null/undefined, or otherwise equal. 1143 */ 1144jspb.Message.compareFields = function(field1, field2) { 1145 // If the fields are trivially equal, they're equal. 1146 if (field1 == field2) return true; 1147 1148 // If the fields aren't trivially equal and one of them isn't an object, 1149 // they can't possibly be equal. 1150 if (!goog.isObject(field1) || !goog.isObject(field2)) { 1151 return false; 1152 } 1153 1154 // We have two objects. If they're different types, they're not equal. 1155 field1 = /** @type {!Object} */(field1); 1156 field2 = /** @type {!Object} */(field2); 1157 if (field1.constructor != field2.constructor) return false; 1158 1159 // If both are Uint8Arrays, compare them element-by-element. 1160 if (jspb.Message.SUPPORTS_UINT8ARRAY_ && field1.constructor === Uint8Array) { 1161 var bytes1 = /** @type {!Uint8Array} */(field1); 1162 var bytes2 = /** @type {!Uint8Array} */(field2); 1163 if (bytes1.length != bytes2.length) return false; 1164 for (var i = 0; i < bytes1.length; i++) { 1165 if (bytes1[i] != bytes2[i]) return false; 1166 } 1167 return true; 1168 } 1169 1170 // If they're both Arrays, compare them element by element except for the 1171 // optional extension objects at the end, which we compare separately. 1172 if (field1.constructor === Array) { 1173 var extension1 = undefined; 1174 var extension2 = undefined; 1175 1176 var length = Math.max(field1.length, field2.length); 1177 for (var i = 0; i < length; i++) { 1178 var val1 = field1[i]; 1179 var val2 = field2[i]; 1180 1181 if (val1 && (val1.constructor == Object)) { 1182 goog.asserts.assert(extension1 === undefined); 1183 goog.asserts.assert(i === field1.length - 1); 1184 extension1 = val1; 1185 val1 = undefined; 1186 } 1187 1188 if (val2 && (val2.constructor == Object)) { 1189 goog.asserts.assert(extension2 === undefined); 1190 goog.asserts.assert(i === field2.length - 1); 1191 extension2 = val2; 1192 val2 = undefined; 1193 } 1194 1195 if (!jspb.Message.compareFields(val1, val2)) { 1196 return false; 1197 } 1198 } 1199 1200 if (extension1 || extension2) { 1201 extension1 = extension1 || {}; 1202 extension2 = extension2 || {}; 1203 return jspb.Message.compareExtensions(extension1, extension2); 1204 } 1205 1206 return true; 1207 } 1208 1209 // If they're both plain Objects (i.e. extensions), compare them as 1210 // extensions. 1211 if (field1.constructor === Object) { 1212 return jspb.Message.compareExtensions(field1, field2); 1213 } 1214 1215 throw new Error('Invalid type in JSPB array'); 1216}; 1217 1218 1219/** 1220 * Static clone function. NOTE: A type-safe method called "cloneMessage" exists 1221 * on each generated JsPb class. Do not call this function directly. 1222 * @param {!jspb.Message} msg A message to clone. 1223 * @return {!jspb.Message} A deep clone of the given message. 1224 */ 1225jspb.Message.clone = function(msg) { 1226 // Although we could include the wrappers, we leave them out here. 1227 return jspb.Message.cloneMessage(msg); 1228}; 1229 1230 1231/** 1232 * @param {!jspb.Message} msg A message to clone. 1233 * @return {!jspb.Message} A deep clone of the given message. 1234 * @protected 1235 */ 1236jspb.Message.cloneMessage = function(msg) { 1237 // Although we could include the wrappers, we leave them out here. 1238 return new msg.constructor(jspb.Message.clone_(msg.toArray())); 1239}; 1240 1241 1242/** 1243 * Takes 2 messages of the same type and copies the contents of the first 1244 * message into the second. After this the 2 messages will equals in terms of 1245 * value semantics but share no state. All data in the destination message will 1246 * be overridden. 1247 * 1248 * @param {MESSAGE} fromMessage Message that will be copied into toMessage. 1249 * @param {MESSAGE} toMessage Message which will receive a copy of fromMessage 1250 * as its contents. 1251 * @template MESSAGE 1252 */ 1253jspb.Message.copyInto = function(fromMessage, toMessage) { 1254 goog.asserts.assertInstanceof(fromMessage, jspb.Message); 1255 goog.asserts.assertInstanceof(toMessage, jspb.Message); 1256 goog.asserts.assert(fromMessage.constructor == toMessage.constructor, 1257 'Copy source and target message should have the same type.'); 1258 var copyOfFrom = jspb.Message.clone(fromMessage); 1259 1260 var to = toMessage.toArray(); 1261 var from = copyOfFrom.toArray(); 1262 1263 // Empty destination in case it has more values at the end of the array. 1264 to.length = 0; 1265 // and then copy everything from the new to the existing message. 1266 for (var i = 0; i < from.length; i++) { 1267 to[i] = from[i]; 1268 } 1269 1270 // This is either null or empty for a fresh copy. 1271 toMessage.wrappers_ = copyOfFrom.wrappers_; 1272 // Just a reference into the shared array. 1273 toMessage.extensionObject_ = copyOfFrom.extensionObject_; 1274}; 1275 1276 1277/** 1278 * Helper for cloning an internal JsPb object. 1279 * @param {!Object} obj A JsPb object, eg, a field, to be cloned. 1280 * @return {!Object} A clone of the input object. 1281 * @private 1282 */ 1283jspb.Message.clone_ = function(obj) { 1284 var o; 1285 if (goog.isArray(obj)) { 1286 // Allocate array of correct size. 1287 var clonedArray = new Array(obj.length); 1288 // Use array iteration where possible because it is faster than for-in. 1289 for (var i = 0; i < obj.length; i++) { 1290 if ((o = obj[i]) != null) { 1291 clonedArray[i] = typeof o == 'object' ? jspb.Message.clone_(o) : o; 1292 } 1293 } 1294 return clonedArray; 1295 } 1296 var clone = {}; 1297 for (var key in obj) { 1298 if ((o = obj[key]) != null) { 1299 clone[key] = typeof o == 'object' ? jspb.Message.clone_(o) : o; 1300 } 1301 } 1302 return clone; 1303}; 1304 1305 1306/** 1307 * Registers a JsPb message type id with its constructor. 1308 * @param {string} id The id for this type of message. 1309 * @param {Function} constructor The message constructor. 1310 */ 1311jspb.Message.registerMessageType = function(id, constructor) { 1312 jspb.Message.registry_[id] = constructor; 1313 // This is needed so we can later access messageId directly on the contructor, 1314 // otherwise it is not available due to 'property collapsing' by the compiler. 1315 constructor.messageId = id; 1316}; 1317 1318 1319/** 1320 * The registry of message ids to message constructors. 1321 * @private 1322 */ 1323jspb.Message.registry_ = {}; 1324 1325 1326/** 1327 * The extensions registered on MessageSet. This is a map of extension 1328 * field number to field info object. This should be considered as a 1329 * private API. 1330 * 1331 * This is similar to [jspb class name].extensions object for 1332 * non-MessageSet. We special case MessageSet so that we do not need 1333 * to goog.require MessageSet from classes that extends MessageSet. 1334 * 1335 * @type {!Object.<number, jspb.ExtensionFieldInfo>} 1336 */ 1337jspb.Message.messageSetExtensions = {}; 1338