Misterzym
/
Rambox-CE
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Форк Rambox
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1313 Commits
16 Branches
43 Tags
40 MiB
 
 
 
Tree: 04413c81eb
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '04413c81eb'
${ noResults }
Rambox-CE/ext/packages/sencha-amf/src-ext/data/amf/Packet.js

978 lines
38 KiB
Raw Blame History

// @tag enterprise
/**
* @class Ext.data.amf.Packet
* This class represents an Action Message Format (AMF) Packet. It contains all
* the logic required to decode an AMF Packet from a byte array.
* To decode a Packet, first construct a Packet:
*
* var packet = Ext.create('Ext.data.amf.Packet');
*
* Then use the decode method to decode an AMF byte array:
*
* packet.decode(bytes);
*
* where "bytes" is a Uint8Array or an array of numbers representing the binary
* AMF data.
*
* To access the decoded data use the #version, #headers, and #messages properties:
*
* console.log(packet.version, packet.headers, packet.messages);
*
* For more information on working with AMF data please refer to the
* [AMF Guide](#/guide/amf).
*/
Ext.define('Ext.data.amf.Packet', function() {
var twoPowN52 = Math.pow(2, -52),
twoPow8 = Math.pow(2, 8),
pos = 0,
bytes, strings, objects, traits;
return {
/**
* @property {Array} headers
* @readonly
* The decoded headers. Each header has the following properties:
*
* - `name`: String
* The header name. Typically identifies a remote operation or method to
* be invoked by this context header.
* - `mustUnderstand`: Boolean
* If `true` this flag instructs the endpoint to abort and generate an
* error if the header is not understood.
* - `byteLength`: Number
* If the byte-length of a header is known it can be specified to optimize
* memory allocation at the remote endpoint.
* - `value`: Mixed
* The header value
*/
/**
* @property {Array} messages
* @readonly
* The decoded messages. Each message has the following properties:
*
* - `targetURI`: String
* Describes which operation, function, or method is to be remotely
* invoked.
* - `responseURI`: String
* A unique operation name
* - `byteLength`: Number
* Optional byte-length of the message body
* - `body`: Mixed
* The message body
*/
/**
* @property {Number} version
* @readonly
* The AMF version number (0 or 3)
*/
/**
* Mapping of AMF data types to the names of the methods responsible for
* reading them.
* @private
*/
typeMap: {
// AMF0 mapping
0: {
0: 'readDouble',
1: 'readBoolean',
2: 'readAmf0String',
3: 'readAmf0Object',
5: 'readNull',
6: 'readUndefined',
7: 'readReference',
8: 'readEcmaArray',
10: 'readStrictArray',
11: 'readAmf0Date',
12: 'readLongString',
13: 'readUnsupported',
15: 'readAmf0Xml',
16: 'readTypedObject'
},
// AMF3 mapping
3: {
0: 'readUndefined',
1: 'readNull',
2: 'readFalse',
3: 'readTrue',
4: 'readUInt29',
5: 'readDouble',
6: 'readAmf3String',
7: 'readAmf3Xml',
8: 'readAmf3Date',
9: 'readAmf3Array',
10: 'readAmf3Object',
11: 'readAmf3Xml',
12: 'readByteArray'
}
},
/**
* Decodes an AMF btye array and sets the decoded data as the
* Packet's #version, #headers, and #messages properties
* @param {Array} byteArray A byte array containing the encoded AMF data.
* @return {Ext.data.amf.Packet} this AMF Packet
*/
decode: function(byteArray) {
var me = this,
headers = me.headers = [],
messages = me.messages = [],
headerCount, messageCount;
pos = 0;
bytes = me.bytes = byteArray;
// The strings array holds references to all of the deserialized
// AMF3 strings for a given header value or message body so that
// repeat instances of the same string can be deserialized by
// reference
strings = me.strings = [];
// The objects array holds references to deserialized objects so
// that repeat occurrences of the same object instance in the byte
// array can be deserialized by reference.
// If version is AMF0 this array holds anonymous objects, typed
// objects, arrays, and ecma-arrays.
// If version is AMF3 this array holds instances of Object, Array, XML,
// XMLDocument, ByteArray, Date, and instances of user defined Classes
objects = me.objects = [];
// The traits array holds references to the "traits" (the
// characteristics of objects that define a strong type such as the
// class name and public member names) of deserialized AMF3 objects
// so that if they are repeated they can be deserialized by reference.
traits = me.traits = [];
// The first two bytes of an AMF packet contain the AMF version
// as an unsigned 16 bit integer.
me.version = me.readUInt(2);
// the next 2 bytes contain the header count
for (headerCount = me.readUInt(2); headerCount--;) {
headers.push({
name: me.readAmf0String(),
mustUnderstand: me.readBoolean(),
byteLength: me.readUInt(4),
value: me.readValue()
});
// reset references (reference indices are local to each header)
strings = me.strings = [];
objects = me.objects = [];
traits = me.traits = [];
}
// The 2 bytes immediately after the header contain the message count.
for (messageCount = me.readUInt(2); messageCount--;) {
messages.push({
targetURI: me.readAmf0String(),
responseURI: me.readAmf0String(),
byteLength: me.readUInt(4),
body: me.readValue()
});
// reset references (reference indices are local to each message)
strings = me.strings = [];
objects = me.objects = [];
traits = me.traits = [];
}
// reset the pointer
pos = 0;
// null the bytes array and reference arrays to free up memory.
bytes = strings = objects = traits =
me.bytes = me.strings = me.objects = me.traits = null;
return me;
},
/**
* Decodes an AMF3 byte array and that has one value and returns it.
* Note: Destroys previously stored data in this Packet.
* @param {Array} byteArray A byte array containing the encoded AMF data.
* @return {Object} the decoded object
*/
decodeValue: function(byteArray) {
var me = this;
bytes = me.bytes = byteArray;
// reset the pointer
pos = 0;
// The first two bytes of an AMF packet contain the AMF version
// as an unsigned 16 bit integer.
me.version = 3;
// The strings array holds references to all of the deserialized
// AMF3 strings for a given header value or message body so that
// repeat instances of the same string can be deserialized by
// reference
strings = me.strings = [];
// The objects array holds references to deserialized objects so
// that repeat occurrences of the same object instance in the byte
// array can be deserialized by reference.
// If version is AMF0 this array holds anonymous objects, typed
// objects, arrays, and ecma-arrays.
// If version is AMF3 this array holds instances of Object, Array, XML,
// XMLDocument, ByteArray, Date, and instances of user defined Classes
objects = me.objects = [];
// The traits array holds references to the "traits" (the
// characteristics of objects that define a strong type such as the
// class name and public member names) of deserialized AMF3 objects
// so that if they are repeated they can be deserialized by reference.
traits = me.traits = [];
// read one value and return it
return me.readValue();
},
/**
* Parses an xml string and returns an xml document
* @private
* @param {String} xml
*/
parseXml: function(xml) {
var doc;
if (window.DOMParser) {
doc = (new DOMParser()).parseFromString(xml, "text/xml");
} else {
doc = new ActiveXObject("Microsoft.XMLDOM");
doc.loadXML(xml);
}
return doc;
},
/**
* Reads an AMF0 date from the byte array
* @private
*/
readAmf0Date: function() {
var date = new Date(this.readDouble());
// An AMF0 date type ends with a 16 bit integer time-zone, but
// according to the spec time-zone is "reserved, not supported,
// should be set to 0x000".
pos += 2; // discard the time zone
return date;
},
/**
* Reads an AMF0 Object from the byte array
* @private
*/
readAmf0Object: function(obj) {
var me = this,
key;
obj = obj || {};
// add the object to the objects array so that the AMF0 reference
// type decoder can refer to it by index if needed.
objects.push(obj);
// An AMF0 object consists of a series of string keys and variable-
// type values. The end of the series is marked by an empty string
// followed by the object-end marker (9).
while ((key = me.readAmf0String()) || bytes[pos] !== 9) {
obj[key] = me.readValue();
}
// move the pointer past the object-end marker
pos++;
return obj;
},
/**
* Reads an AMF0 string from the byte array
* @private
*/
readAmf0String: function() {
// AMF0 strings begin with a 16 bit byte-length header.
return this.readUtf8(this.readUInt(2));
},
readAmf0Xml: function() {
return this.parseXml(this.readLongString());
},
readAmf3Array: function() {
var me = this,
header = me.readUInt29(),
count, key, array, i;
// AMF considers Arrays in two parts, the dense portion and the
// associative portion. The binary representation of the associative
// portion consists of name/value pairs (potentially none) terminated
// by an empty string. The binary representation of the dense portion
// is the size of the dense portion (potentially zero) followed by an
// ordered list of values (potentially none).
if (header & 1) {
// If the first (low) bit is a 1 read an array instance. The
// remaining 1-28 bits are used to encode the length of the
// dense portion of the array.
count = (header >> 1);
// First read the associative portion of the array (if any). If
// there is an associative portion, the array will be read as a
// javascript object, otherwise it will be a javascript array.
key = me.readAmf3String();
if (key) {
// First key is not an empty string - this is an associative
// array. Read keys and values from the byte array until
// we get to an empty string key
array = {};
objects.push(array);
do {
array[key] = me.readValue();
} while((key = me.readAmf3String()));
// The dense portion of the array is then read into the
// associative object, keyed by ordinal index.
for (i = 0; i < count; i++) {
array[i] = me.readValue();
}
} else {
// First key is an empty string - this is an array with
// ordinal indices.
array = [];
objects.push(array);
for (i = 0; i < count; i++) {
array.push(me.readValue());
}
}
} else {
// If the first (low) bit is a 0 read an array reference. The
// remaining 1-28 bits are used to encode the reference index
array = objects[header >> 1];
}
return array;
},
/**
* Reads an AMF3 date from the byte array
* @private
*/
readAmf3Date: function() {
var me = this,
header = me.readUInt29(),
date;
if (header & 1) {
// If the first (low) bit is a 1, this is a date instance.
date = new Date(me.readDouble());
objects.push(date);
} else {
// If the first (low) bit is a 0, this is a date reference.
// The remaining 1-28 bits encode the reference index
date = objects[header >> 1];
}
return date;
},
/**
* Reads an AMF3 object from the byte array
* @private
*/
readAmf3Object: function() {
var me = this,
header = me.readUInt29(),
members = [],
headerLast3Bits, memberCount, className,
dynamic, objectTraits, obj, key, klass, i;
// There are 3 different types of object headers, distinguishable
// by the 1-3 least significant bits. All object instances have
// a 1 in the low bit position, while references have a 0:
//
// 0 : object reference
// 011 : traits
// 01 : traits-ref
// 111 : traits-ext
if (header & 1) {
// first (low) bit of 1, denotes an encoded object instance
// The next string is the class name.
headerLast3Bits = (header & 0x07);
if (headerLast3Bits === 3) {
// If the 3 least significant bits of the header are "011"
// then trait information follows.
className = me.readAmf3String();
// A 1 in the header's 4th least significant byte position
// indicates that dynamic members may follow the sealed
// members.
dynamic = !!(header & 0x08);
// Shift off the 4 least significant bits, and the remaining
// 1-25 bits encode the number of sealed member names. Read
// as many strings from the byte array as member names.
memberCount = (header >> 4);
for (i = 0; i < memberCount; i++) {
members.push(me.readAmf3String());
}
objectTraits = {
className: className,
dynamic: dynamic,
members: members
};
// An objects traits are cached in the traits array enabling
// the traits for a given class to only be encoded once for
// a series of instances.
traits.push(objectTraits);
} else if ((header & 0x03) === 1) {
// If the 2 least significant bits are "01", then a traits
// reference follows. The remaining 1-27 bits are used
// to encode the trait reference index.
objectTraits = traits[header >> 2];
className = objectTraits.className;
dynamic = objectTraits.dynamic;
members = objectTraits.members;
memberCount = members.length;
} else if (headerLast3Bits === 7) {
// if the 3 lease significant bits are "111" then
// externalizable trait data follows
// TODO: implement externalizable traits
}
if (className) {
klass = Ext.ClassManager.getByAlias('amf.' + className);
obj = klass ? new klass() : {$className: className};
} else {
obj = {};
}
objects.push(obj);
// read the sealed member values
for (i = 0; i < memberCount; i++) {
obj[members[i]] = me.readValue();
}
if (dynamic) {
// If the dynamic flag is set, dynamic members may follow
// the sealed members. Read key/value pairs until we
// encounter an empty string key signifying the end of the
// dynamic members.
while ((key = me.readAmf3String())) {
obj[key] = me.readValue();
}
}
// finally, check if we need to convert this class
if ((!klass) && this.converters[className]) {
obj = this.converters[className](obj);
}
} else {
// If the first (low) bit of the header is a 0, this is an
// object reference. The remaining 1-28 significant bits are
// used to encode an object reference index.
obj = objects[header >> 1];
}
return obj;
},
/**
* Reads an AMF3 string from the byte array
* @private
*/
readAmf3String: function() {
var me = this,
header = me.readUInt29(),
value;
if (header & 1) {
// If the first (low) bit is a 1, this is a string literal.
// Discard the low bit. The remaining 1-28 bits are used to
// encode the string's byte-length.
value = me.readUtf8(header >> 1);
if (value) {
// the emtpy string is never encoded by reference
strings.push(value);
}
return value;
} else {
// If the first (low) bit is a 0, this is a string reference.
// Discard the low bit, then look up and return the reference
// from the strings array using the remaining 1-28 bits as the
// index.
return strings[header >> 1];
}
},
/**
* Reads an AMF3 XMLDocument type or XML type from the byte array
* @private
*/
readAmf3Xml: function() {
var me = this,
header = me.readUInt29(),
doc;
if (header & 1) {
// If the first (low) bit is a 1, this is an xml instance. The
// remaining 1-28 bits encode the byte-length of the xml string.
doc = me.parseXml(me.readUtf8(header >> 1));
objects.push(doc);
} else {
// if the first (low) bit is a 1, this is an xml reference. The
// remaining 1-28 bits encode the reference index.
doc = objects[header >> 1];
}
return doc;
},
/**
* Reads an AMF0 boolean from the byte array
* @private
*/
readBoolean: function() {
return !!bytes[pos++];
},
/**
* Reads an AMF3 ByteArray type from the byte array
* @private
*/
readByteArray: function() {
var header = this.readUInt29(),
byteArray, end;
if (header & 1) {
// If the first (low) bit is a 1, this is a ByteArray instance.
// The remaining 1-28 bits encode the ByteArray's byte-length.
end = pos + (header >> 1);
// Depending on the browser, "bytes" may be either a Uint8Array
// or an Array. Uint8Arrays don't have Array methods, so
// we have to use Array.prototype.slice to get the byteArray
byteArray = Array.prototype.slice.call(bytes, pos, end);
objects.push(byteArray);
// move the pointer to the first byte after the byteArray that
// was just read
pos = end;
} else {
// if the first (low) bit is a 1, this is a ByteArray reference.
// The remaining 1-28 bits encode the reference index.
byteArray = objects[header >> 1];
}
return byteArray;
},
/**
* Reads a IEEE 754 double-precision binary floating-point number
* @private
*/
readDouble: function() {
var byte1 = bytes[pos++],
byte2 = bytes[pos++],
// the first bit of byte1 is the sign (0 = positive, 1 = negative.
// We read this bit by shifting the 7 least significant bits of
// byte1 off to the right.
sign = (byte1 >> 7) ? -1 : 1,
// the exponent takes up the next 11 bits.
exponent =
// extract the 7 least significant bits from byte1 and then
// shift them left by 4 bits to make room for the 4 remaining
// bits from byte 2
(((byte1 & 0x7F) << 4)
// add the 4 most significant bits from byte 2 to complete
// the exponent
| (byte2 >> 4)),
// the remaining 52 bits make up the significand. read the 4
// least significant bytes of byte 2 to begin the significand
significand = (byte2 & 0x0F),
// The most significant bit of the significand is always 1 for
// a normalized number, therefore it is not stored. This bit is
// referred to as the "hidden bit". The true bit width of the
// significand is 53 if you include the hidden bit. An exponent
// of 0 indicates that this is a subnormal number, and subnormal
// numbers always have a 0 hidden bit.
hiddenBit = exponent ? 1 : 0,
i = 6;
// The operands of all bitwise operators in javascript are converted
// to signed 32 bit integers. It is therefore impossible to construct
// the 52 bit significand by repeatedly shifting its bits and then
// bitwise OR-ing the result with the the next byte. To work around
// this issue, we repeatedly multiply the significand by 2^8 which
// produces the same result as (significand << 8), then we add the
// next byte, which has the same result as a bitwise OR.
while (i--) {
significand = (significand * twoPow8) + bytes[pos++];
}
if (!exponent) {
if (!significand) {
// if both exponent and significand are 0, the number is 0
return 0;
}
// If the exponent is 0, but the significand is not 0, this
// is a subnormal number. Subnormal numbers are encoded with a
// biased exponent of 0, but are interpreted with the value of
// the smallest allowed exponent, which is one greater.
exponent = 1;
}
// 0x7FF (2047) is a special exponent value that represents infinity
// if the significand is 0, and NaN if the significand is not 0
if (exponent === 0x7FF) {
return significand ? NaN : (Infinity * sign);
}
return sign *
// The exponent is encoded using an offset binary
// representation with the zero offset being 0x3FF (1023),
// so we have to subtract 0x3FF to get the true exponent
Math.pow(2, exponent - 0x3FF) *
// convert the significand to its decimal value by multiplying
// it by 2^52 and then add the hidden bit
(hiddenBit + twoPowN52 * significand);
},
/**
* Reads an AMF0 ECMA Array from the byte array
* @private
*/
readEcmaArray: function() {
// An ecma array type is encoded exactly like an anonymous object
// with the exception that it has a 32 bit "count" at the beginning.
// We handle emca arrays by just throwing away the count and then
// letting the object decoder handle the rest.
pos += 4;
return this.readAmf0Object();
},
/**
* Returns false. Used for reading the false type
* @private
*/
readFalse: function() {
return false;
},
/**
* Reads a long string (longer than 65535 bytes) from the byte array
* @private
*/
readLongString: function() {
// long strings begin with a 32 bit byte-length header.
return this.readUtf8(this.readUInt(4));
},
/**
* Returns null. Used for reading the null type
* @private
*/
readNull: function() {
return null;
},
/**
* Reads a reference from the byte array. Reference types are used to
* avoid duplicating data if the same instance of a complex object (which
* is defined in AMF0 as an anonymous object, typed object, array, or
* ecma-array) is included in the data more than once.
* @private
*/
readReference: function() {
// a reference type contains a single 16 bit integer that represents
// the index of an already deserialized object in the objects array
return objects[this.readUInt(2)];
},
/**
* Reads an AMF0 strict array (an array with ordinal indices)
* @private
*/
readStrictArray: function() {
var me = this,
len = me.readUInt(4),
arr = [];
objects.push(arr);
while (len--) {
arr.push(me.readValue());
}
return arr;
},
/**
* Returns true. Used for reading the true type
* @private
*/
readTrue: Ext.returnTrue,
/**
* Reads an AMF0 typed object from the byte array
* @private
*/
readTypedObject: function() {
var me = this,
className = me.readAmf0String(),
klass, instance, modified;
klass = Ext.ClassManager.getByAlias('amf.' + className);
instance = klass ? new klass() : {$className: className}; // if there is no klass, mark the classname for easier parsing of returned results
modified = me.readAmf0Object(instance);
// check if we need to convert this class
if ((!klass) && this.converters[className]) {
modified = this.converters[className](instance);
}
return modified;
},
/**
* Reads an unsigned integer from the byte array
* @private
* @param {Number} byteCount the number of bytes to read, e.g. 2 to read
* a 16 bit integer, 4 to read a 32 bit integer, etc.
* @return {Number}
*/
readUInt: function(byteCount) {
var i = 1,
result;
// read the first byte
result = bytes[pos++];
// if this is a multi-byte int, loop over the remaining bytes
for (; i < byteCount; ++i) {
// shift the result 8 bits to the left and add the next byte.
result = (result << 8) | bytes[pos++];
}
return result;
},
/**
* Reads an unsigned 29-bit integer from the byte array.
* AMF 3 makes use of a special compact format for writing integers to
* reduce the number of bytes required for encoding. As with a normal
* 32-bit integer, up to 4 bytes are required to hold the value however
* the high bit of the first 3 bytes are used as flags to determine
* whether the next byte is part of the integer. With up to 3 bits of
* the 32 bits being used as flags, only 29 significant bits remain for
* encoding an integer. This means the largest unsigned integer value
* that can be represented is 2^29-1.
*
* (hex) : (binary)
* 0x00000000 - 0x0000007F : 0xxxxxxx
* 0x00000080 - 0x00003FFF : 1xxxxxxx 0xxxxxxx
* 0x00004000 - 0x001FFFFF : 1xxxxxxx 1xxxxxxx 0xxxxxxx
* 0x00200000 - 0x3FFFFFFF : 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx
* @private
* @return {Number}
*/
readUInt29: function() {
var value = bytes[pos++],
nextByte;
if (value & 0x80) {
// if the high order bit of the first byte is a 1, the next byte
// is also part of this integer.
nextByte = bytes[pos++];
// remove the high order bit from both bytes before combining them
value = ((value & 0x7F) << 7) | (nextByte & 0x7F);
if (nextByte & 0x80) {
// if the high order byte of the 2nd byte is a 1, then
// there is a 3rd byte
nextByte = bytes[pos++];
// remove the high order bit from the 3rd byte before
// adding it to the value
value = (value << 7) | (nextByte & 0x7F);
if (nextByte & 0x80) {
// 4th byte is also part of the integer
nextByte = bytes[pos++];
// use all 8 bits of the 4th byte
value = (value << 8) | nextByte;
}
}
}
return value;
},
/**
* Returns undefined. Used for reading the undefined type
* @private
*/
readUndefined: Ext.emptyFn,
/**
* Returns undefined. Used for reading the unsupported type
* @private
*/
readUnsupported: Ext.emptyFn,
/**
* Reads a UTF-8 string from the byte array
* @private
* @param {Number} byteLength The number of bytes to read
* @return {String}
*/
readUtf8: function(byteLength) {
var end = pos + byteLength, // the string's end position
chars = [],
charCount = 0,
maxCharCount = 65535,
charArrayCount = 1,
result = [],
i = 0,
charArrays, byteCount, charCode;
charArrays = [chars];
// UTF-8 characters may be encoded using 1-4 bytes. The number of
// bytes that a character consumes is determined by reading the
// leading byte. Values 0-127 in the leading byte indicate a single-
// byte ASCII-compatible character. Values 192-223 (bytes with "110"
// in the high-order position) indicate a 2-byte character, values
// 224-239 (bytes with "1110" in the high-order position) indicate a
// 3-byte character, and values 240-247 (bytes with "11110" in the
// high-order position) indicate a 4-byte character. The remaining
// bits of the leading byte hold bits of the encoded character, with
// leading zeros if necessary.
//
// The continuation bytes all have "10" in the high-order position,
// which means only the 6 least significant bits of continuation
// bytes are available to hold the bits of the encoded character.
//
// The following table illustrates the binary format of UTF-8
// characters:
//
// Bits Byte 1 Byte 2 Byte 3 Byte 4
// -----------------------------------------------------
// 7 0xxxxxxx
// 11 110xxxxx 10xxxxxx
// 16 1110xxxx 10xxxxxx 10xxxxxx
// 21 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
while (pos < end) {
// read a byte from the byte array - if the byte's value is less
// than 128 we are dealing with a single byte character
charCode = bytes[pos++];
if (charCode > 127) {
// if the byte's value is greater than 127 we are dealing
// with a multi-byte character.
if (charCode > 239) {
// a leading-byte value greater than 239 means this is a
// 4-byte character
byteCount = 4;
// Use only the 3 least-significant bits of the leading
// byte of a 4-byte character. This is achieved by
// applying the following bit mask:
// (charCode & 0x07)
// which is equivalent to:
// 11110xxx (the byte)
// AND 00000111 (the mask)
charCode = (charCode & 0x07);
} else if (charCode > 223) {
// a leading-byte value greater than 223 but less than
// 240 means this is a 3-byte character
byteCount = 3;
// Use only the 4 least-significant bits of the leading
// byte of a 3-byte character. This is achieved by
// applying the following bit mask:
// (charCode & 0x0F)
// which is equivalent to:
// 1110xxxx (the byte)
// AND 00001111 (the mask)
charCode = (charCode & 0x0F);
} else {
// a leading-byte value less than 224 but (implicitly)
// greater than 191 means this is a 2-byte character
byteCount = 2;
// Use only the 5 least-significant bits of the first
// byte of a 2-byte character. This is achieved by
// applying the following bit mask:
// (charCode & 0x1F)
// which is equivalent to:
// 110xxxxx (the byte)
// AND 00011111 (the mask)
charCode = (charCode & 0x1F);
}
while (--byteCount) {
// get one continuation byte. then strip off the leading
// "10" by applying the following bit mask:
// (b & 0x3F)
// which is equialent to:
// 10xxxxxx (the byte)
// AND 00111111 (the mask)
// That leaves 6 remaining bits on the continuation byte
// which are concatenated onto the character's bits
charCode = ((charCode << 6) | (bytes[pos++] & 0x3F));
}
}
chars.push(charCode);
if (++charCount === maxCharCount) {
charArrays.push(chars = []);
charCount = 0;
charArrayCount ++;
}
}
// At this point we end up with an array of char arrays, each char
// array being no longer than 65,535 characters, the fastest way to
// turn these char arrays into strings is to pass them as the
// arguments to fromCharCode (fortunately all currently supported
// browsers can handle at least 65,535 function arguments).
for (; i < charArrayCount; i++) {
// create a result array containing the strings converted from
// the individual character arrays.
result.push(String.fromCharCode.apply(String, charArrays[i]));
}
return result.join('');
},
/**
* Reads an AMF "value-type" from the byte array. Automatically detects
* the data type by reading the "type marker" from the first byte after
* the pointer.
* @private
*/
readValue: function() {
var me = this,
marker = bytes[pos++];
// With the introduction of AMF3, a special type marker was added to
// AMF0 to signal a switch to AMF3 serialization. This allows a packet
// to start out in AMF 0 and switch to AMF 3 on the first complex type
// to take advantage of the more the efficient encoding of AMF 3.
if (marker === 17) {
// change the version to AMF3 when we see a 17 marker
me.version = 3;
marker = bytes[pos++];
}
return me[me.typeMap[me.version][marker]]();
},
/**
* Converters used in converting specific typed Flex classes to JavaScript usable form.
* @private
*/
converters: {
'flex.messaging.io.ArrayCollection': function(obj) {
return obj.source || []; // array collections have a source var that contains the actual data
}
}
};
});