legacy-libs/grpc-cloned/node_modules/protobufjs/src/ProtoBuf/Builder/Message.js

   1 /*?\r
   2  // --- Scope ------------------\r
   3  // T : Reflect.Message instance\r
   4  */\r
   5 var fields = T.getChildren(ProtoBuf.Reflect.Message.Field),\r
   6     oneofs = T.getChildren(ProtoBuf.Reflect.Message.OneOf);\r
   7 \r
   8 /**\r
   9  * Constructs a new runtime Message.\r
  10  * @name ProtoBuf.Builder.Message\r
  11  * @class Barebone of all runtime messages.\r
  12  * @param {!Object.<string,*>|string} values Preset values\r
  13  * @param {...string} var_args\r
  14  * @constructor\r
  15  * @throws {Error} If the message cannot be created\r
  16  */\r
  17 var Message = function(values, var_args) {\r
  18     ProtoBuf.Builder.Message.call(this);\r
  19 \r
  20     // Create virtual oneof properties\r
  21     for (var i=0, k=oneofs.length; i<k; ++i)\r
  22         this[oneofs[i].name] = null;\r
  23     // Create fields and set default values\r
  24     for (i=0, k=fields.length; i<k; ++i) {\r
  25         var field = fields[i];\r
  26         this[field.name] =\r
  27             field.repeated ? [] :\r
  28             (field.map ? new ProtoBuf.Map(field) : null);\r
  29         if ((field.required || T.syntax === 'proto3') &&\r
  30             field.defaultValue !== null)\r
  31             this[field.name] = field.defaultValue;\r
  32     }\r
  33 \r
  34     if (arguments.length > 0) {\r
  35         var value;\r
  36         // Set field values from a values object\r
  37         if (arguments.length === 1 && values !== null && typeof values === 'object' &&\r
  38             /* not _another_ Message */ (typeof values.encode !== 'function' || values instanceof Message) &&\r
  39             /* not a repeated field */ !Array.isArray(values) &&\r
  40             /* not a Map */ !(values instanceof ProtoBuf.Map) &&\r
  41             /* not a ByteBuffer */ !ByteBuffer.isByteBuffer(values) &&\r
  42             /* not an ArrayBuffer */ !(values instanceof ArrayBuffer) &&\r
  43             /* not a Long */ !(ProtoBuf.Long && values instanceof ProtoBuf.Long)) {\r
  44             this.$set(values);\r
  45         } else // Set field values from arguments, in declaration order\r
  46             for (i=0, k=arguments.length; i<k; ++i)\r
  47                 if (typeof (value = arguments[i]) !== 'undefined')\r
  48                     this.$set(fields[i].name, value); // May throw\r
  49     }\r
  50 };\r
  51 \r
  52 /**\r
  53  * @alias ProtoBuf.Builder.Message.prototype\r
  54  * @inner\r
  55  */\r
  56 var MessagePrototype = Message.prototype = Object.create(ProtoBuf.Builder.Message.prototype);\r
  57 \r
  58 /**\r
  59  * Adds a value to a repeated field.\r
  60  * @name ProtoBuf.Builder.Message#add\r
  61  * @function\r
  62  * @param {string} key Field name\r
  63  * @param {*} value Value to add\r
  64  * @param {boolean=} noAssert Whether to assert the value or not (asserts by default)\r
  65  * @returns {!ProtoBuf.Builder.Message} this\r
  66  * @throws {Error} If the value cannot be added\r
  67  * @expose\r
  68  */\r
  69 MessagePrototype.add = function(key, value, noAssert) {\r
  70     var field = T._fieldsByName[key];\r
  71     if (!noAssert) {\r
  72         if (!field)\r
  73             throw Error(this+"#"+key+" is undefined");\r
  74         if (!(field instanceof ProtoBuf.Reflect.Message.Field))\r
  75             throw Error(this+"#"+key+" is not a field: "+field.toString(true)); // May throw if it's an enum or embedded message\r
  76         if (!field.repeated)\r
  77             throw Error(this+"#"+key+" is not a repeated field");\r
  78         value = field.verifyValue(value, true);\r
  79     }\r
  80     if (this[key] === null)\r
  81         this[key] = [];\r
  82     this[key].push(value);\r
  83     return this;\r
  84 };\r
  85 \r
  86 /**\r
  87  * Adds a value to a repeated field. This is an alias for {@link ProtoBuf.Builder.Message#add}.\r
  88  * @name ProtoBuf.Builder.Message#$add\r
  89  * @function\r
  90  * @param {string} key Field name\r
  91  * @param {*} value Value to add\r
  92  * @param {boolean=} noAssert Whether to assert the value or not (asserts by default)\r
  93  * @returns {!ProtoBuf.Builder.Message} this\r
  94  * @throws {Error} If the value cannot be added\r
  95  * @expose\r
  96  */\r
  97 MessagePrototype.$add = MessagePrototype.add;\r
  98 \r
  99 /**\r
 100  * Sets a field's value.\r
 101  * @name ProtoBuf.Builder.Message#set\r
 102  * @function\r
 103  * @param {string|!Object.<string,*>} keyOrObj String key or plain object holding multiple values\r
 104  * @param {(*|boolean)=} value Value to set if key is a string, otherwise omitted\r
 105  * @param {boolean=} noAssert Whether to not assert for an actual field / proper value type, defaults to `false`\r
 106  * @returns {!ProtoBuf.Builder.Message} this\r
 107  * @throws {Error} If the value cannot be set\r
 108  * @expose\r
 109  */\r
 110 MessagePrototype.set = function(keyOrObj, value, noAssert) {\r
 111     if (keyOrObj && typeof keyOrObj === 'object') {\r
 112         noAssert = value;\r
 113         for (var ikey in keyOrObj) {\r
 114             // Check if virtual oneof field - don't set these\r
 115             if (keyOrObj.hasOwnProperty(ikey) && typeof (value = keyOrObj[ikey]) !== 'undefined' && T._oneofsByName[ikey] === undefined)\r
 116                 this.$set(ikey, value, noAssert);\r
 117         }\r
 118         return this;\r
 119     }\r
 120     var field = T._fieldsByName[keyOrObj];\r
 121     if (!noAssert) {\r
 122         if (!field)\r
 123             throw Error(this+"#"+keyOrObj+" is not a field: undefined");\r
 124         if (!(field instanceof ProtoBuf.Reflect.Message.Field))\r
 125             throw Error(this+"#"+keyOrObj+" is not a field: "+field.toString(true));\r
 126         this[field.name] = (value = field.verifyValue(value)); // May throw\r
 127     } else\r
 128         this[keyOrObj] = value;\r
 129     if (field && field.oneof) { // Field is part of an OneOf (not a virtual OneOf field)\r
 130         var currentField = this[field.oneof.name]; // Virtual field references currently set field\r
 131         if (value !== null) {\r
 132             if (currentField !== null && currentField !== field.name)\r
 133                 this[currentField] = null; // Clear currently set field\r
 134             this[field.oneof.name] = field.name; // Point virtual field at this field\r
 135         } else if (/* value === null && */currentField === keyOrObj)\r
 136             this[field.oneof.name] = null; // Clear virtual field (current field explicitly cleared)\r
 137     }\r
 138     return this;\r
 139 };\r
 140 \r
 141 /**\r
 142  * Sets a field's value. This is an alias for [@link ProtoBuf.Builder.Message#set}.\r
 143  * @name ProtoBuf.Builder.Message#$set\r
 144  * @function\r
 145  * @param {string|!Object.<string,*>} keyOrObj String key or plain object holding multiple values\r
 146  * @param {(*|boolean)=} value Value to set if key is a string, otherwise omitted\r
 147  * @param {boolean=} noAssert Whether to not assert the value, defaults to `false`\r
 148  * @throws {Error} If the value cannot be set\r
 149  * @expose\r
 150  */\r
 151 MessagePrototype.$set = MessagePrototype.set;\r
 152 \r
 153 /**\r
 154  * Gets a field's value.\r
 155  * @name ProtoBuf.Builder.Message#get\r
 156  * @function\r
 157  * @param {string} key Key\r
 158  * @param {boolean=} noAssert Whether to not assert for an actual field, defaults to `false`\r
 159  * @return {*} Value\r
 160  * @throws {Error} If there is no such field\r
 161  * @expose\r
 162  */\r
 163 MessagePrototype.get = function(key, noAssert) {\r
 164     if (noAssert)\r
 165         return this[key];\r
 166     var field = T._fieldsByName[key];\r
 167     if (!field || !(field instanceof ProtoBuf.Reflect.Message.Field))\r
 168         throw Error(this+"#"+key+" is not a field: undefined");\r
 169     if (!(field instanceof ProtoBuf.Reflect.Message.Field))\r
 170         throw Error(this+"#"+key+" is not a field: "+field.toString(true));\r
 171     return this[field.name];\r
 172 };\r
 173 \r
 174 /**\r
 175  * Gets a field's value. This is an alias for {@link ProtoBuf.Builder.Message#$get}.\r
 176  * @name ProtoBuf.Builder.Message#$get\r
 177  * @function\r
 178  * @param {string} key Key\r
 179  * @return {*} Value\r
 180  * @throws {Error} If there is no such field\r
 181  * @expose\r
 182  */\r
 183 MessagePrototype.$get = MessagePrototype.get;\r
 184 \r
 185 // Getters and setters\r
 186 \r
 187 for (var i=0; i<fields.length; i++) {\r
 188     var field = fields[i];\r
 189     // no setters for extension fields as these are named by their fqn\r
 190     if (field instanceof ProtoBuf.Reflect.Message.ExtensionField)\r
 191         continue;\r
 192 \r
 193     if (T.builder.options['populateAccessors'])\r
 194         (function(field) {\r
 195             // set/get[SomeValue]\r
 196             var Name = field.originalName.replace(/(_[a-zA-Z])/g, function(match) {\r
 197                 return match.toUpperCase().replace('_','');\r
 198             });\r
 199             Name = Name.substring(0,1).toUpperCase() + Name.substring(1);\r
 200 \r
 201             // set/get_[some_value] FIXME: Do we really need these?\r
 202             var name = field.originalName.replace(/([A-Z])/g, function(match) {\r
 203                 return "_"+match;\r
 204             });\r
 205 \r
 206             /**\r
 207              * The current field's unbound setter function.\r
 208              * @function\r
 209              * @param {*} value\r
 210              * @param {boolean=} noAssert\r
 211              * @returns {!ProtoBuf.Builder.Message}\r
 212              * @inner\r
 213              */\r
 214             var setter = function(value, noAssert) {\r
 215                 this[field.name] = noAssert ? value : field.verifyValue(value);\r
 216                 return this;\r
 217             };\r
 218 \r
 219             /**\r
 220              * The current field's unbound getter function.\r
 221              * @function\r
 222              * @returns {*}\r
 223              * @inner\r
 224              */\r
 225             var getter = function() {\r
 226                 return this[field.name];\r
 227             };\r
 228 \r
 229             if (T.getChild("set"+Name) === null)\r
 230                 /**\r
 231                  * Sets a value. This method is present for each field, but only if there is no name conflict with\r
 232                  *  another field.\r
 233                  * @name ProtoBuf.Builder.Message#set[SomeField]\r
 234                  * @function\r
 235                  * @param {*} value Value to set\r
 236                  * @param {boolean=} noAssert Whether to not assert the value, defaults to `false`\r
 237                  * @returns {!ProtoBuf.Builder.Message} this\r
 238                  * @abstract\r
 239                  * @throws {Error} If the value cannot be set\r
 240                  */\r
 241                 MessagePrototype["set"+Name] = setter;\r
 242 \r
 243             if (T.getChild("set_"+name) === null)\r
 244                 /**\r
 245                  * Sets a value. This method is present for each field, but only if there is no name conflict with\r
 246                  *  another field.\r
 247                  * @name ProtoBuf.Builder.Message#set_[some_field]\r
 248                  * @function\r
 249                  * @param {*} value Value to set\r
 250                  * @param {boolean=} noAssert Whether to not assert the value, defaults to `false`\r
 251                  * @returns {!ProtoBuf.Builder.Message} this\r
 252                  * @abstract\r
 253                  * @throws {Error} If the value cannot be set\r
 254                  */\r
 255                 MessagePrototype["set_"+name] = setter;\r
 256 \r
 257             if (T.getChild("get"+Name) === null)\r
 258                 /**\r
 259                  * Gets a value. This method is present for each field, but only if there is no name conflict with\r
 260                  *  another field.\r
 261                  * @name ProtoBuf.Builder.Message#get[SomeField]\r
 262                  * @function\r
 263                  * @abstract\r
 264                  * @return {*} The value\r
 265                  */\r
 266                 MessagePrototype["get"+Name] = getter;\r
 267 \r
 268             if (T.getChild("get_"+name) === null)\r
 269                 /**\r
 270                  * Gets a value. This method is present for each field, but only if there is no name conflict with\r
 271                  *  another field.\r
 272                  * @name ProtoBuf.Builder.Message#get_[some_field]\r
 273                  * @function\r
 274                  * @return {*} The value\r
 275                  * @abstract\r
 276                  */\r
 277                 MessagePrototype["get_"+name] = getter;\r
 278 \r
 279         })(field);\r
 280 }\r
 281 \r
 282 // En-/decoding\r
 283 \r
 284 /**\r
 285  * Encodes the message.\r
 286  * @name ProtoBuf.Builder.Message#$encode\r
 287  * @function\r
 288  * @param {(!ByteBuffer|boolean)=} buffer ByteBuffer to encode to. Will create a new one and flip it if omitted.\r
 289  * @param {boolean=} noVerify Whether to not verify field values, defaults to `false`\r
 290  * @return {!ByteBuffer} Encoded message as a ByteBuffer\r
 291  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 292  *  returns the encoded ByteBuffer in the `encoded` property on the error.\r
 293  * @expose\r
 294  * @see ProtoBuf.Builder.Message#encode64\r
 295  * @see ProtoBuf.Builder.Message#encodeHex\r
 296  * @see ProtoBuf.Builder.Message#encodeAB\r
 297  */\r
 298 MessagePrototype.encode = function(buffer, noVerify) {\r
 299     if (typeof buffer === 'boolean')\r
 300         noVerify = buffer,\r
 301         buffer = undefined;\r
 302     var isNew = false;\r
 303     if (!buffer)\r
 304         buffer = new ByteBuffer(),\r
 305         isNew = true;\r
 306     var le = buffer.littleEndian;\r
 307     try {\r
 308         T.encode(this, buffer.LE(), noVerify);\r
 309         return (isNew ? buffer.flip() : buffer).LE(le);\r
 310     } catch (e) {\r
 311         buffer.LE(le);\r
 312         throw(e);\r
 313     }\r
 314 };\r
 315 \r
 316 /**\r
 317  * Encodes a message using the specified data payload.\r
 318  * @param {!Object.<string,*>} data Data payload\r
 319  * @param {(!ByteBuffer|boolean)=} buffer ByteBuffer to encode to. Will create a new one and flip it if omitted.\r
 320  * @param {boolean=} noVerify Whether to not verify field values, defaults to `false`\r
 321  * @return {!ByteBuffer} Encoded message as a ByteBuffer\r
 322  * @expose\r
 323  */\r
 324 Message.encode = function(data, buffer, noVerify) {\r
 325     return new Message(data).encode(buffer, noVerify);\r
 326 };\r
 327 \r
 328 /**\r
 329  * Calculates the byte length of the message.\r
 330  * @name ProtoBuf.Builder.Message#calculate\r
 331  * @function\r
 332  * @returns {number} Byte length\r
 333  * @throws {Error} If the message cannot be calculated or if required fields are missing.\r
 334  * @expose\r
 335  */\r
 336 MessagePrototype.calculate = function() {\r
 337     return T.calculate(this);\r
 338 };\r
 339 \r
 340 /**\r
 341  * Encodes the varint32 length-delimited message.\r
 342  * @name ProtoBuf.Builder.Message#encodeDelimited\r
 343  * @function\r
 344  * @param {(!ByteBuffer|boolean)=} buffer ByteBuffer to encode to. Will create a new one and flip it if omitted.\r
 345  * @param {boolean=} noVerify Whether to not verify field values, defaults to `false`\r
 346  * @return {!ByteBuffer} Encoded message as a ByteBuffer\r
 347  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 348  *  returns the encoded ByteBuffer in the `encoded` property on the error.\r
 349  * @expose\r
 350  */\r
 351 MessagePrototype.encodeDelimited = function(buffer, noVerify) {\r
 352     var isNew = false;\r
 353     if (!buffer)\r
 354         buffer = new ByteBuffer(),\r
 355         isNew = true;\r
 356     var enc = new ByteBuffer().LE();\r
 357     T.encode(this, enc, noVerify).flip();\r
 358     buffer.writeVarint32(enc.remaining());\r
 359     buffer.append(enc);\r
 360     return isNew ? buffer.flip() : buffer;\r
 361 };\r
 362 \r
 363 /**\r
 364  * Directly encodes the message to an ArrayBuffer.\r
 365  * @name ProtoBuf.Builder.Message#encodeAB\r
 366  * @function\r
 367  * @return {ArrayBuffer} Encoded message as ArrayBuffer\r
 368  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 369  *  returns the encoded ArrayBuffer in the `encoded` property on the error.\r
 370  * @expose\r
 371  */\r
 372 MessagePrototype.encodeAB = function() {\r
 373     try {\r
 374         return this.encode().toArrayBuffer();\r
 375     } catch (e) {\r
 376         if (e["encoded"]) e["encoded"] = e["encoded"].toArrayBuffer();\r
 377         throw(e);\r
 378     }\r
 379 };\r
 380 \r
 381 /**\r
 382  * Returns the message as an ArrayBuffer. This is an alias for {@link ProtoBuf.Builder.Message#encodeAB}.\r
 383  * @name ProtoBuf.Builder.Message#toArrayBuffer\r
 384  * @function\r
 385  * @return {ArrayBuffer} Encoded message as ArrayBuffer\r
 386  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 387  *  returns the encoded ArrayBuffer in the `encoded` property on the error.\r
 388  * @expose\r
 389  */\r
 390 MessagePrototype.toArrayBuffer = MessagePrototype.encodeAB;\r
 391 \r
 392 /**\r
 393  * Directly encodes the message to a node Buffer.\r
 394  * @name ProtoBuf.Builder.Message#encodeNB\r
 395  * @function\r
 396  * @return {!Buffer}\r
 397  * @throws {Error} If the message cannot be encoded, not running under node.js or if required fields are\r
 398  *  missing. The later still returns the encoded node Buffer in the `encoded` property on the error.\r
 399  * @expose\r
 400  */\r
 401 MessagePrototype.encodeNB = function() {\r
 402     try {\r
 403         return this.encode().toBuffer();\r
 404     } catch (e) {\r
 405         if (e["encoded"]) e["encoded"] = e["encoded"].toBuffer();\r
 406         throw(e);\r
 407     }\r
 408 };\r
 409 \r
 410 /**\r
 411  * Returns the message as a node Buffer. This is an alias for {@link ProtoBuf.Builder.Message#encodeNB}.\r
 412  * @name ProtoBuf.Builder.Message#toBuffer\r
 413  * @function\r
 414  * @return {!Buffer}\r
 415  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 416  *  returns the encoded node Buffer in the `encoded` property on the error.\r
 417  * @expose\r
 418  */\r
 419 MessagePrototype.toBuffer = MessagePrototype.encodeNB;\r
 420 \r
 421 /**\r
 422  * Directly encodes the message to a base64 encoded string.\r
 423  * @name ProtoBuf.Builder.Message#encode64\r
 424  * @function\r
 425  * @return {string} Base64 encoded string\r
 426  * @throws {Error} If the underlying buffer cannot be encoded or if required fields are missing. The later\r
 427  *  still returns the encoded base64 string in the `encoded` property on the error.\r
 428  * @expose\r
 429  */\r
 430 MessagePrototype.encode64 = function() {\r
 431     try {\r
 432         return this.encode().toBase64();\r
 433     } catch (e) {\r
 434         if (e["encoded"]) e["encoded"] = e["encoded"].toBase64();\r
 435         throw(e);\r
 436     }\r
 437 };\r
 438 \r
 439 /**\r
 440  * Returns the message as a base64 encoded string. This is an alias for {@link ProtoBuf.Builder.Message#encode64}.\r
 441  * @name ProtoBuf.Builder.Message#toBase64\r
 442  * @function\r
 443  * @return {string} Base64 encoded string\r
 444  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 445  *  returns the encoded base64 string in the `encoded` property on the error.\r
 446  * @expose\r
 447  */\r
 448 MessagePrototype.toBase64 = MessagePrototype.encode64;\r
 449 \r
 450 /**\r
 451  * Directly encodes the message to a hex encoded string.\r
 452  * @name ProtoBuf.Builder.Message#encodeHex\r
 453  * @function\r
 454  * @return {string} Hex encoded string\r
 455  * @throws {Error} If the underlying buffer cannot be encoded or if required fields are missing. The later\r
 456  *  still returns the encoded hex string in the `encoded` property on the error.\r
 457  * @expose\r
 458  */\r
 459 MessagePrototype.encodeHex = function() {\r
 460     try {\r
 461         return this.encode().toHex();\r
 462     } catch (e) {\r
 463         if (e["encoded"]) e["encoded"] = e["encoded"].toHex();\r
 464         throw(e);\r
 465     }\r
 466 };\r
 467 \r
 468 /**\r
 469  * Returns the message as a hex encoded string. This is an alias for {@link ProtoBuf.Builder.Message#encodeHex}.\r
 470  * @name ProtoBuf.Builder.Message#toHex\r
 471  * @function\r
 472  * @return {string} Hex encoded string\r
 473  * @throws {Error} If the message cannot be encoded or if required fields are missing. The later still\r
 474  *  returns the encoded hex string in the `encoded` property on the error.\r
 475  * @expose\r
 476  */\r
 477 MessagePrototype.toHex = MessagePrototype.encodeHex;\r
 478 \r
 479 /**\r
 480  * Clones a message object or field value to a raw object.\r
 481  * @param {*} obj Object to clone\r
 482  * @param {boolean} binaryAsBase64 Whether to include binary data as base64 strings or as a buffer otherwise\r
 483  * @param {boolean} longsAsStrings Whether to encode longs as strings\r
 484  * @param {!ProtoBuf.Reflect.T=} resolvedType The resolved field type if a field\r
 485  * @returns {*} Cloned object\r
 486  * @inner\r
 487  */\r
 488 function cloneRaw(obj, binaryAsBase64, longsAsStrings, resolvedType) {\r
 489     if (obj === null || typeof obj !== 'object') {\r
 490         // Convert enum values to their respective names\r
 491         if (resolvedType && resolvedType instanceof ProtoBuf.Reflect.Enum) {\r
 492             var name = ProtoBuf.Reflect.Enum.getName(resolvedType.object, obj);\r
 493             if (name !== null)\r
 494                 return name;\r
 495         }\r
 496         // Pass-through string, number, boolean, null...\r
 497         return obj;\r
 498     }\r
 499     // Convert ByteBuffers to raw buffer or strings\r
 500     if (ByteBuffer.isByteBuffer(obj))\r
 501         return binaryAsBase64 ? obj.toBase64() : obj.toBuffer();\r
 502     // Convert Longs to proper objects or strings\r
 503     if (ProtoBuf.Long.isLong(obj))\r
 504         return longsAsStrings ? obj.toString() : ProtoBuf.Long.fromValue(obj);\r
 505     var clone;\r
 506     // Clone arrays\r
 507     if (Array.isArray(obj)) {\r
 508         clone = [];\r
 509         obj.forEach(function(v, k) {\r
 510             clone[k] = cloneRaw(v, binaryAsBase64, longsAsStrings, resolvedType);\r
 511         });\r
 512         return clone;\r
 513     }\r
 514     clone = {};\r
 515     // Convert maps to objects\r
 516     if (obj instanceof ProtoBuf.Map) {\r
 517         var it = obj.entries();\r
 518         for (var e = it.next(); !e.done; e = it.next())\r
 519             clone[obj.keyElem.valueToString(e.value[0])] = cloneRaw(e.value[1], binaryAsBase64, longsAsStrings, obj.valueElem.resolvedType);\r
 520         return clone;\r
 521     }\r
 522     // Everything else is a non-null object\r
 523     var type = obj.$type,\r
 524         field = undefined;\r
 525     for (var i in obj)\r
 526         if (obj.hasOwnProperty(i)) {\r
 527             if (type && (field = type.getChild(i)))\r
 528                 clone[i] = cloneRaw(obj[i], binaryAsBase64, longsAsStrings, field.resolvedType);\r
 529             else\r
 530                 clone[i] = cloneRaw(obj[i], binaryAsBase64, longsAsStrings);\r
 531         }\r
 532     return clone;\r
 533 }\r
 534 \r
 535 /**\r
 536  * Returns the message's raw payload.\r
 537  * @param {boolean=} binaryAsBase64 Whether to include binary data as base64 strings instead of Buffers, defaults to `false`\r
 538  * @param {boolean} longsAsStrings Whether to encode longs as strings\r
 539  * @returns {Object.<string,*>} Raw payload\r
 540  * @expose\r
 541  */\r
 542 MessagePrototype.toRaw = function(binaryAsBase64, longsAsStrings) {\r
 543     return cloneRaw(this, !!binaryAsBase64, !!longsAsStrings, this.$type);\r
 544 };\r
 545 \r
 546 /**\r
 547  * Encodes a message to JSON.\r
 548  * @returns {string} JSON string\r
 549  * @expose\r
 550  */\r
 551 MessagePrototype.encodeJSON = function() {\r
 552     return JSON.stringify(\r
 553         cloneRaw(this,\r
 554              /* binary-as-base64 */ true,\r
 555              /* longs-as-strings */ true,\r
 556              this.$type\r
 557         )\r
 558     );\r
 559 };\r
 560 \r
 561 /**\r
 562  * Decodes a message from the specified buffer or string.\r
 563  * @name ProtoBuf.Builder.Message.decode\r
 564  * @function\r
 565  * @param {!ByteBuffer|!ArrayBuffer|!Buffer|string} buffer Buffer to decode from\r
 566  * @param {(number|string)=} length Message length. Defaults to decode all the remainig data.\r
 567  * @param {string=} enc Encoding if buffer is a string: hex, utf8 (not recommended), defaults to base64\r
 568  * @return {!ProtoBuf.Builder.Message} Decoded message\r
 569  * @throws {Error} If the message cannot be decoded or if required fields are missing. The later still\r
 570  *  returns the decoded message with missing fields in the `decoded` property on the error.\r
 571  * @expose\r
 572  * @see ProtoBuf.Builder.Message.decode64\r
 573  * @see ProtoBuf.Builder.Message.decodeHex\r
 574  */\r
 575 Message.decode = function(buffer, length, enc) {\r
 576     if (typeof length === 'string')\r
 577         enc = length,\r
 578         length = -1;\r
 579     if (typeof buffer === 'string')\r
 580         buffer = ByteBuffer.wrap(buffer, enc ? enc : "base64");\r
 581     else if (!ByteBuffer.isByteBuffer(buffer))\r
 582         buffer = ByteBuffer.wrap(buffer); // May throw\r
 583     var le = buffer.littleEndian;\r
 584     try {\r
 585         var msg = T.decode(buffer.LE(), length);\r
 586         buffer.LE(le);\r
 587         return msg;\r
 588     } catch (e) {\r
 589         buffer.LE(le);\r
 590         throw(e);\r
 591     }\r
 592 };\r
 593 \r
 594 /**\r
 595  * Decodes a varint32 length-delimited message from the specified buffer or string.\r
 596  * @name ProtoBuf.Builder.Message.decodeDelimited\r
 597  * @function\r
 598  * @param {!ByteBuffer|!ArrayBuffer|!Buffer|string} buffer Buffer to decode from\r
 599  * @param {string=} enc Encoding if buffer is a string: hex, utf8 (not recommended), defaults to base64\r
 600  * @return {ProtoBuf.Builder.Message} Decoded message or `null` if not enough bytes are available yet\r
 601  * @throws {Error} If the message cannot be decoded or if required fields are missing. The later still\r
 602  *  returns the decoded message with missing fields in the `decoded` property on the error.\r
 603  * @expose\r
 604  */\r
 605 Message.decodeDelimited = function(buffer, enc) {\r
 606     if (typeof buffer === 'string')\r
 607         buffer = ByteBuffer.wrap(buffer, enc ? enc : "base64");\r
 608     else if (!ByteBuffer.isByteBuffer(buffer))\r
 609         buffer = ByteBuffer.wrap(buffer); // May throw\r
 610     if (buffer.remaining() < 1)\r
 611         return null;\r
 612     var off = buffer.offset,\r
 613         len = buffer.readVarint32();\r
 614     if (buffer.remaining() < len) {\r
 615         buffer.offset = off;\r
 616         return null;\r
 617     }\r
 618     try {\r
 619         var msg = T.decode(buffer.slice(buffer.offset, buffer.offset + len).LE());\r
 620         buffer.offset += len;\r
 621         return msg;\r
 622     } catch (err) {\r
 623         buffer.offset += len;\r
 624         throw err;\r
 625     }\r
 626 };\r
 627 \r
 628 /**\r
 629  * Decodes the message from the specified base64 encoded string.\r
 630  * @name ProtoBuf.Builder.Message.decode64\r
 631  * @function\r
 632  * @param {string} str String to decode from\r
 633  * @return {!ProtoBuf.Builder.Message} Decoded message\r
 634  * @throws {Error} If the message cannot be decoded or if required fields are missing. The later still\r
 635  *  returns the decoded message with missing fields in the `decoded` property on the error.\r
 636  * @expose\r
 637  */\r
 638 Message.decode64 = function(str) {\r
 639     return Message.decode(str, "base64");\r
 640 };\r
 641 \r
 642 /**\r
 643  * Decodes the message from the specified hex encoded string.\r
 644  * @name ProtoBuf.Builder.Message.decodeHex\r
 645  * @function\r
 646  * @param {string} str String to decode from\r
 647  * @return {!ProtoBuf.Builder.Message} Decoded message\r
 648  * @throws {Error} If the message cannot be decoded or if required fields are missing. The later still\r
 649  *  returns the decoded message with missing fields in the `decoded` property on the error.\r
 650  * @expose\r
 651  */\r
 652 Message.decodeHex = function(str) {\r
 653     return Message.decode(str, "hex");\r
 654 };\r
 655 \r
 656 /**\r
 657  * Decodes the message from a JSON string.\r
 658  * @name ProtoBuf.Builder.Message.decodeJSON\r
 659  * @function\r
 660  * @param {string} str String to decode from\r
 661  * @return {!ProtoBuf.Builder.Message} Decoded message\r
 662  * @throws {Error} If the message cannot be decoded or if required fields are\r
 663  * missing.\r
 664  * @expose\r
 665  */\r
 666 Message.decodeJSON = function(str) {\r
 667     return new Message(JSON.parse(str));\r
 668 };\r
 669 \r
 670 // Utility\r
 671 \r
 672 /**\r
 673  * Returns a string representation of this Message.\r
 674  * @name ProtoBuf.Builder.Message#toString\r
 675  * @function\r
 676  * @return {string} String representation as of ".Fully.Qualified.MessageName"\r
 677  * @expose\r
 678  */\r
 679 MessagePrototype.toString = function() {\r
 680     return T.toString();\r
 681 };\r
 682 \r
 683 // Properties\r
 684 \r
 685 /**\r
 686  * Message options.\r
 687  * @name ProtoBuf.Builder.Message.$options\r
 688  * @type {Object.<string,*>}\r
 689  * @expose\r
 690  */\r
 691 var $optionsS; // cc needs this\r
 692 \r
 693 /**\r
 694  * Message options.\r
 695  * @name ProtoBuf.Builder.Message#$options\r
 696  * @type {Object.<string,*>}\r
 697  * @expose\r
 698  */\r
 699 var $options;\r
 700 \r
 701 /**\r
 702  * Reflection type.\r
 703  * @name ProtoBuf.Builder.Message.$type\r
 704  * @type {!ProtoBuf.Reflect.Message}\r
 705  * @expose\r
 706  */\r
 707 var $typeS;\r
 708 \r
 709 /**\r
 710  * Reflection type.\r
 711  * @name ProtoBuf.Builder.Message#$type\r
 712  * @type {!ProtoBuf.Reflect.Message}\r
 713  * @expose\r
 714  */\r
 715 var $type;\r
 716 \r
 717 if (Object.defineProperty)\r
 718     Object.defineProperty(Message, '$options', { "value": T.buildOpt() }),\r
 719     Object.defineProperty(MessagePrototype, "$options", { "value": Message["$options"] }),\r
 720     Object.defineProperty(Message, "$type", { "value": T }),\r
 721     Object.defineProperty(MessagePrototype, "$type", { "value": T });\r