add extjs 6.0.1 sources

[extjs.git] / extjs / packages / amf / src / data / amf / XmlDecoder.js

// @tag enterprise\r
/**\r
 * @class Ext.data.amf.XmlDecoder\r
 * This class parses an XML-based AMFX message and returns the deserialized\r
 * objects. You should not need to use this class directly. It's mostly used by\r
 * the AMFX Direct implementation.\r
 * To decode a message, first construct a Decoder:\r
 *\r
 *      decoder = Ext.create('Ext.data.amf.XmlDecoder');\r
 *\r
 * Then ask it to read in the message :\r
 *\r
 *     resp = decoder.readAmfxMessage(str);\r
 *\r
 * For more information on working with AMF data please refer to the\r
 * [AMF Guide](#/guide/amf).\r
 */\r
Ext.define('Ext.data.amf.XmlDecoder', {\r
\r
    alias: 'data.amf.xmldecoder',\r
\r
    statics: {\r
\r
        /**\r
         * Parses an xml string and returns an xml document\r
         * @private\r
         * @param {String} xml\r
         */\r
        readXml: function(xml) {\r
            var doc;\r
\r
            if (window.DOMParser) {\r
                doc = (new DOMParser()).parseFromString(xml, "text/xml");\r
            } else {\r
                doc = new ActiveXObject("Microsoft.XMLDOM");\r
                doc.loadXML(xml);\r
            }\r
\r
            return doc;\r
        },\r
\r
        /**\r
         * parses a node containing a byte array in hexadecimal format, returning the reconstructed array.\r
         * @param {HTMLElement/XMLElement} node the node\r
         * @return {Array} a byte array\r
         */\r
        readByteArray: function(node) {\r
            var bytes = [],\r
                c, i, str;\r
            str = node.firstChild.nodeValue;\r
            for (i = 0; i < str.length; i = i + 2) {\r
                c = str.substr(i, 2);\r
                bytes.push(parseInt(c, 16));\r
            }\r
            return bytes;\r
        },\r
\r
        /**\r
         * Deserializes an AMF3 binary object from a byte array\r
         * @param {Array} bytes the byte array containing one AMF3-encoded value\r
         * @return {Object} the decoded value\r
         */\r
        readAMF3Value: function(bytes) {\r
            var packet;\r
            packet = Ext.create('Ext.data.amf.Packet');\r
            return packet.decodeValue(bytes);\r
        },\r
\r
        /**\r
         * Accepts Flex-style UID and decodes the number in the first four bytes (8 hex digits) of data.\r
         * @param {String} messageId the message ID\r
         * @return {Number} the transaction ID\r
         */\r
        decodeTidFromFlexUID: function(messageId) {\r
            var str;\r
            str = messageId.substr(0,8);\r
            return parseInt(str, 16);\r
        }\r
\r
    },\r
\r
    /**\r
     * Creates new encoder.\r
     * @param {Object} config Configuration options\r
     */\r
    constructor: function(config) {\r
        this.initConfig(config);\r
        this.clear();\r
    },\r
\r
    /**\r
     * Clears the accumulated data and reference tables\r
     */\r
    clear: function() {\r
        // reset reference counters\r
        this.objectReferences=[];\r
        this.traitsReferences=[];\r
        this.stringReferences=[];\r
    },\r
\r
    /**\r
     * Reads and returns a decoded AMFX packet.\r
     * @param {String} xml the xml of the message\r
     * @return {Object} the response object containing the message\r
     */\r
    readAmfxMessage: function(xml) {\r
        var doc, amfx, body,\r
            i, resp={};\r
        this.clear(); // reset counters\r
        doc = Ext.data.amf.XmlDecoder.readXml(xml);\r
        amfx = doc.getElementsByTagName('amfx')[0];\r
        //<debug>\r
        if (!amfx) {\r
            Ext.warn.log("No AMFX tag in message");\r
        }\r
        if (amfx.getAttribute('ver') != "3") {\r
            Ext.raise("Unsupported AMFX version: " + amfx.getAttribute('ver'));\r
        }\r
        //</debug>\r
        body = amfx.getElementsByTagName('body')[0];\r
        resp.targetURI = body.getAttribute('targetURI');\r
        resp.responseURI = body.getAttribute('responseURI'); // most likely empty string\r
        for (i = 0; i < body.childNodes.length; i++) {\r
            if (body.childNodes.item(i).nodeType != 1) {\r
                // only process element nodes, ignore white space and text nodes\r
                continue;\r
            }\r
            resp.message = this.readValue(body.childNodes.item(i));\r
            break; // no need to keep iterating\r
        }\r
        return resp;\r
    },\r
\r
    /**\r
     * Parses an HTML element returning the appropriate JavaScript value from the AMFX data.\r
     * @param {HTMLElement} node The node to parse\r
     * @return {Object} a JavaScript object or value\r
     */\r
    readValue: function(node) {\r
        var val;\r
        if (typeof node.normalize === 'function') {\r
            node.normalize();\r
        }\r
        // 2DO: handle references!\r
        if (node.tagName == "null") {\r
            return null;\r
        } else if (node.tagName == "true") {\r
            return true;\r
        } else if (node.tagName == "false") {\r
            return false;\r
        } else if (node.tagName == "string") {\r
            return this.readString(node);\r
        } else if (node.tagName == "int") {\r
            return parseInt(node.firstChild.nodeValue);\r
        } else if (node.tagName == "double") {\r
            return parseFloat(node.firstChild.nodeValue);\r
        } else if (node.tagName == "date") {\r
            val = new Date(parseFloat(node.firstChild.nodeValue));\r
            // record in object reference table\r
            this.objectReferences.push(val);\r
            return val;\r
        } else if (node.tagName == "dictionary") {\r
            return this.readDictionary(node);\r
        } else if (node.tagName == "array") {\r
            return this.readArray(node);\r
        } else if (node.tagName == "ref") {\r
            return this.readObjectRef(node);\r
        } else if (node.tagName == "object") {\r
            return this.readObject(node);\r
        } else if (node.tagName == "xml") {\r
            // the CDATA content of the node is a parseable XML document. parse it.\r
            return Ext.data.amf.XmlDecoder.readXml(node.firstChild.nodeValue);\r
        } else if (node.tagName == "bytearray") {\r
            // a byte array is usually an AMF stream. Parse it to a byte array, then pass through the AMF decoder to get the objects inside\r
            return Ext.data.amf.XmlDecoder.readAMF3Value(Ext.data.amf.XmlDecoder.readByteArray(node));\r
        }\r
        //<debug>\r
        Ext.raise("Unknown tag type: " + node.tagName);\r
        //</debug>\r
        return null;\r
    },\r
\r
    /**\r
     * Reads a string or string reference and return the value\r
     * @param {HTMLElement/XMLElement} node the node containing a string object\r
     * @return {String} the parsed string\r
     */\r
    readString: function(node) {\r
        var val;\r
        if (node.getAttributeNode('id')) {\r
            return this.stringReferences[parseInt(node.getAttribute('id'))];\r
        }\r
        val = (node.firstChild ? node.firstChild.nodeValue : "") || "";\r
        this.stringReferences.push(val);\r
        return val;\r
    },\r
\r
    /**\r
     * Parses and returns an ordered list of trait names\r
     * @param {HTMLElement/XMLElement} node the traits node from the XML doc\r
     * @return {Array} an array of ordered trait names or null if it's an externalizable object\r
     */\r
    readTraits: function(node) {\r
        var traits = [], i, rawtraits;\r
        if (node === null) {\r
            return null;\r
        }\r
        if (node.getAttribute('externalizable') == "true") {\r
            // no traits since it's an externalizable or a null object.\r
            return null;\r
        }\r
        if (node.getAttributeNode('id')) {\r
            // return traits reference\r
            return this.traitsReferences[parseInt(node.getAttributeNode('id').value)];\r
        }\r
        /* // empty anonymous objects still seem to get their empty traits in the reference table\r
         if (!node.hasChildNodes()) {\r
         var className = node.parentNode.getElementsByTagName('type');\r
         if (className.length == 0) {\r
         return traits; // special case of an anonymous object with no traits. Does not get reference counted\r
         }\r
         }\r
         */\r
        rawtraits = node.childNodes;\r
        for (i = 0; i < rawtraits.length; i++) {\r
            if (rawtraits.item(i).nodeType != 1) {\r
                // only process element nodes, ignore white space and text nodes\r
                continue;\r
            }\r
            // this will be a string, but let the readValue function handle it nonetheless\r
            traits.push(this.readValue(rawtraits.item(i)));\r
        }\r
\r
        // register traits in ref table:\r
        this.traitsReferences.push(traits);\r
        return traits;\r
    },\r
\r
    /**\r
     * Parses and return an object / array / dictionary / date from reference\r
     * @param {HTMLElement/XMLElement} node the ref node\r
     * @return {Object} the previously instantiated object referred to by the ref node\r
     */\r
    readObjectRef: function(node) {\r
        var id;\r
        id = parseInt(node.getAttribute('id'));\r
        return this.objectReferences[id];\r
    },\r
\r
    /**\r
     * Parses and returns an AMFX object.\r
     * @param {HTMLElement/XMLElement} node the `<object>` node to parse\r
     * @return {Object} the deserialized object\r
     */\r
    readObject: function(node) {\r
        var obj,\r
            traits = [],\r
            traitsNode,\r
            i, j, n,\r
            key, val,\r
            klass = null, className;\r
\r
        className = node.getAttribute('type');\r
        if (className) {\r
            klass = Ext.ClassManager.getByAlias('amfx.' + className); // check if special case for class\r
        }\r
        obj = klass ? new klass() : (className ? {$className: className} : {}); // if there is no klass, mark the classname for easier parsing of returned results\r
\r
        // check if we need special handling for this class\r
        if ((!klass) && this.converters[className]) {\r
            obj = this.converters[className](this,node);\r
            return obj; // we're done\r
        }\r
\r
        traitsNode = node.getElementsByTagName('traits')[0];\r
        traits = this.readTraits(traitsNode);\r
        //<debug>\r
        if (traits === null) {\r
            Ext.raise("No support for externalizable object: " + className);\r
        }\r
        //</debug>\r
        // Register object if ref table, in case there's a cyclical reference coming\r
        this.objectReferences.push(obj);\r
\r
\r
        // Now we expect an item for each trait name we have. We assume it's an ordered list. We'll skip the first (traits) tag\r
        j = 0;\r
        for (i = 0; i < node.childNodes.length; i++) {\r
            n = node.childNodes.item(i);\r
            if (n.nodeType != 1) {\r
                // Ignore text nodes and non-element nodes\r
                continue;\r
            }\r
            if (n.tagName == "traits") {\r
                // ignore the traits node. We've already covered it.\r
                continue;\r
            }\r
            key = traits[j];\r
            val = this.readValue(n);\r
            j = j + 1;\r
            obj[key] = val;\r
            //<debug>\r
            if (j > traits.length) {\r
                Ext.raise("Too many items for object, not enough traits: " + className);\r
            }\r
            //</debug>\r
        }\r
        return obj;\r
    },\r
\r
    /**\r
     * Parses and returns an AMFX array.\r
     * @param {HTMLElement/XMLElement} node the array node\r
     * @return {Array} the deserialized array\r
     */\r
    readArray: function(node) {\r
        var arr=[],\r
            n,i,j,l,name, val, len, childnodes, cn;\r
\r
        // register array in object references table before we parse, in case of circular references\r
        this.objectReferences.push(arr);\r
\r
        len = parseInt(node.getAttributeNode('length').value);\r
        i = 0;\r
        // the length only accounts for the ordinal values. For the rest, we'll read them as ECMA key-value pairs\r
        for (l = 0; l < node.childNodes.length; l++) {\r
            n = node.childNodes.item(l);\r
            if (n.nodeType != 1) {\r
                // Ignore text nodes and non-element nodes\r
                continue;\r
            }\r
            if (n.tagName == "item") {\r
                // parse item node\r
                name = n.getAttributeNode('name').value;\r
                childnodes = n.childNodes;\r
                for (j = 0; j < childnodes.length; j++) {\r
                    cn = childnodes.item(j);\r
                    if (cn.nodeType != 1) {\r
                        // Ignore text nodes and non-element nodes\r
                        continue;\r
                    }\r
                    val = this.readValue(cn);\r
                    break; // out of loop. We've found our value\r
                }\r
                arr[name] = val;\r
            } else {\r
                // ordinal node\r
                arr[i] = this.readValue(n);\r
                i++;\r
                //<debug>\r
                if (i > len) {\r
                    Ext.raise("Array has more items than declared length: " + i + " > " + len);\r
                }\r
                //</debug>\r
            }\r
        }\r
        //<debug>\r
        if (i < len) {\r
            Ext.raise("Array has less items than declared length: " + i + " < " + len);\r
        }\r
        //</debug>\r
        return arr;\r
    },\r
\r
    /**\r
     * Parses and returns an AMFX dictionary.\r
     * @param {HTMLElement/XMLElement} node the `<dictionary>` node\r
     * @return {Object} a javascript object with the dictionary value-pair elements\r
     */\r
    readDictionary: function(node) {\r
        // For now, handle regular objects\r
        var dict = {},\r
            key, val,\r
            i, j, n, len;\r
\r
        len = parseInt(node.getAttribute('length'));\r
        // Register dictionary in the ref table, in case there's a cyclical reference coming\r
        this.objectReferences.push(dict);\r
\r
\r
        // now find pairs of keys and values\r
        key = null;\r
        val = null;\r
        j = 0;\r
        for (i = 0; i < node.childNodes.length; i++) {\r
            n = node.childNodes.item(i);\r
            if (n.nodeType != 1) {\r
                // Ignore text nodes and non-element nodes\r
                continue;\r
            }\r
            if (!key) {\r
                key = this.readValue(n);\r
                continue; // next element is the value\r
            }\r
            val = this.readValue(n);\r
            j = j + 1;\r
            dict[key] = val;\r
            key = null;\r
            val = null;\r
        }\r
        //<debug>\r
        if (j != len) {\r
            Ext.raise("Incorrect number of dictionary values: " + j + " != " + len);\r
        }\r
        //</debug>\r
        return dict;\r
    },\r
\r
\r
    /**\r
     * Converts externalizable flex objects with a source array to a regular array.\r
     * @private\r
     */\r
    convertObjectWithSourceField: function(node) {\r
        var i, n, val;\r
        for (i = 0; i < node.childNodes.length; i++) {\r
            n = node.childNodes.item(i);\r
            if (n.tagName == "bytearray") {\r
                val = this.readValue(n);\r
                this.objectReferences.push(val);\r
                return val;\r
            }\r
        }\r
        return null; // we shouldn't reach here, but just in case\r
    },\r
\r
    /**\r
     * Converters used in converting specific typed Flex classes to JavaScript usable form.\r
     * @private\r
     */\r
\r
    converters: {\r
        'flex.messaging.io.ArrayCollection': function(decoder,node) {\r
            return decoder.convertObjectWithSourceField(node);\r
        },\r
        'mx.collections.ArrayList':  function(decoder,node) {\r
            return decoder.convertObjectWithSourceField(node);\r
        },\r
        'mx.collections.ArrayCollection':  function(decoder,node) {\r
            return decoder.convertObjectWithSourceField(node);\r
        }\r
    }\r
});\r