home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / AIMP2 / aimp_2.61.583.exe / $TEMP / YandexPackSetup.msi / fil6F356421A3A2A755263AF2559DD98F7E < prev    next >
Text File  |  2010-07-12  |  13KB  |  411 lines
  1. XB.types = {};
  2.  
  3. XB.types.empty = null;
  4.  
  5. XB.types.XML = function XML_constructor() {
  6.     var arg0 = arguments[0];
  7.     if (arguments.length == 1 && arg0 instanceof XB._Ci.nsIDOMDocument) {
  8.         this._isADocument = true;
  9.         this._rootNode = arg0.documentElement;
  10.     }
  11.     else {
  12.         this._initAsList();
  13.         this.append.apply(this, arguments);
  14.     }
  15. };
  16.  
  17. XB.types.XML.prototype = {
  18.     append: function XML_append() {
  19.         if (this._isADocument) {
  20.             let oldRoot = this._rootNode;
  21.             this._initAsList();
  22.             this.append(oldRoot);
  23.         }
  24.         
  25.         for (let argIndex = 0, argsLen = arguments.length; argIndex < argsLen; argIndex++) {
  26.             let arg = arguments[argIndex];
  27.             
  28.             if (arg instanceof Array) {
  29.                 this.append.apply(this, arg);
  30.                 continue;
  31.             }
  32.             
  33.             if (arg instanceof XB._Ci.nsIDOMNode) {
  34.                 this._appendAnyNode(arg);
  35.                 continue;
  36.             }
  37.             
  38.             let isThisType = (arg instanceof this.constructor);
  39.             if (arg instanceof XB._Ci.nsIDOMNodeList || isThisType) {
  40.                 for (let nodeIndex = 0, nodesLen = arg.length; nodeIndex < nodesLen; nodeIndex++) {
  41.                     this._appendAnyNode(arg.item(nodeIndex));
  42.                 }
  43.                 if (isThisType) {
  44.                     let argAttrs = arg.attributes;
  45.                     for (let i = 0, len = argAttrs; i < len; i++) {
  46.                         this._appendAnyNode(argAttrs.item(i));
  47.                     }
  48.                 }
  49.                 continue;
  50.             }
  51.             
  52.             throw new TypeError(XB._base.consts.ERR_DOM_NODES_EXPECTED);
  53.         }
  54.     },
  55.     
  56.     addAttribute: function XML_addAttribute(ns, name, value) {
  57.         if (this.disposed)
  58.             throw new Error(XB._base.consts.ERR_DISPOSED_XML);
  59.         this._rootNode.setAttributeNS(ns, name, value);
  60.     },
  61.     
  62.     toString: function XML_toString() {
  63.         let role = this._isADocument? "document": "nodes";
  64.         if (this.disposed)
  65.             return "[XBXML " + role + " (disposed)]";
  66.         return "[XBXML "+ role + " length: " + this.length + ", content:\n" +
  67.         XB._base.application.core.Lib.sysutils.trimSpaces(this.serialize().substr(0, 800)) + "...\n]";
  68.     },
  69.     
  70.     appendChild: function XML_appendChild(node) {
  71.         this._rootNode.appendChild(node);
  72.     },
  73.     
  74.     item: function XML_Item(at) {
  75.         if (!this._isADocument)
  76.             return this._rootNode.childNodes[at];
  77.         if (at > 0)
  78.             throw new RangeError("Document has only one root node");
  79.         return this._rootNode;
  80.     },
  81.     
  82.     get attributes() {
  83.         if (this.disposed)
  84.             throw new Error(XB._base.consts.ERR_DISPOSED_XML);
  85.         return this._rootNode.attributes;
  86.     },
  87.     
  88.     get childNodes() {
  89.         if (this._isADocument)
  90.             return this._rootNode;
  91.         return this._rootNode.childNodes;
  92.     },
  93.     
  94.     get length() {
  95.         if (this.disposed)
  96.             return 0;
  97.         if (this._isADocument)
  98.             return 1;
  99.         return this._rootNode.childNodes.length;
  100.     },
  101.     
  102.     get disposed() {
  103.         return !this._rootNode;
  104.     },
  105.     
  106.     dispose: function XML_Dispose() {
  107.         if (this._isADocument) {
  108.             this._isADocument = false;
  109.         }
  110.         else {
  111.             if (this._frag)
  112.                 this._frag.removeChild(this._rootNode);
  113.             this._frag = null;
  114.         }
  115.         
  116.         if (this.disposed)
  117.             XB._base.logger.warn("Attemp to dispose an already disposed XML object.");
  118.         else {
  119.             if (XB._base.logger.level <= XB._base.application.core.Log4Moz.Level.Trace)
  120.                 XB._base.logger.trace("Disposing XML:\n" + this.serialize().substr(0, 400) + "\n...");
  121.             this._rootNode = null;
  122.         }
  123.     },
  124.     
  125.     serialize: function XML_Serialize() {
  126.         var result = "";
  127.         for (let nodeIndex = 0, len = this.length; nodeIndex < len; nodeIndex++) {
  128.             result += XB._base.runtime.serializeXML(this.item(nodeIndex));
  129.         }
  130.         return result;
  131.     },
  132.     
  133.     get textContent() {
  134.         return this._rootNode.textContent;
  135.     },
  136.     
  137.     equalsTo: function XML_EqualsTo(other) {
  138.         if ( !(other instanceof this.constructor) )
  139.             throw new TypeError("XML type expected");
  140.         if (other === this)
  141.             return true;
  142.         if ( (this._isADocument ^ other._isADocument) )
  143.             return false;
  144.         
  145.         if (this.disposed || other.disposed)
  146.             return false;
  147.         return this._rootNode.isEqualNode(other._rootNode);
  148.     },
  149.     
  150.     query: function XML_Query(expr) {
  151.         if (XB._base.logger.level <= XB._base.application.core.Log4Moz.Level.Trace) {
  152.             XB._base.logger.trace("Query from:\n" + this.serialize().substr(0, 400) + "\n...");
  153.         }
  154.         var queryResult = XB._base.runtime.queryXMLDoc(expr, this._isADocument? this._rootNode.ownerDocument: this._rootNode);
  155.         return XB.types.XML.handleQueryResult(queryResult);
  156.     },
  157.     
  158.     transform: function XML_Transform(stylesheet) {
  159.         var newFragment = XB._base.runtime.transformXML(this._rootNode, stylesheet);
  160.         var newXML = new XB.types.XML(newFragment);
  161.         return newXML;
  162.     },
  163.     
  164.     clone: function XML_Clone() {
  165.         return new this.constructor(this);
  166.     },
  167.     
  168.     get owner() {
  169.         return this._owner;
  170.     },
  171.     
  172.     set owner(owner) {
  173.         this._owner = owner;
  174.     },
  175.     
  176.     _isADocument: false,
  177.     _frag: null,
  178.     _rootNode: null,
  179.     _owner: null,
  180.     
  181.     _initAsList: function XML_initAsList() {
  182.         this._frag = XB._base.runtime.tempXMLDoc.createDocumentFragment();
  183.         this._rootNode = this._frag.appendChild(XB._base.runtime.tempXMLDoc.createElement("xml"));
  184.         if (!this._rootNode)
  185.             throw new Error("Couldn't create root node");
  186.         this._isADocument = false;
  187.     },
  188.     
  189.     _appendAnyNode: function XML_appendAnyNode(node) {
  190.         var newNode = null;
  191.         if (node.ownerDocument == this._rootNode.ownerDocument) {
  192.             newNode = node.cloneNode(true);
  193.         } else {
  194.             try {
  195.                 newNode = this._rootNode.ownerDocument.importNode(node, true);
  196.             }
  197.             catch(e) {
  198.                 XB._base.logger.debug("Native importNode failed.");
  199.                 var newNode = this._importNodeEx(this._rootNode.ownerDocument, node, true);
  200.             }
  201.         }
  202.         
  203.         if (newNode.nodeType == newNode.ATTRIBUTE_NODE)
  204.             this._rootNode.setAttributeNode(newNode);
  205.         else
  206.             this._rootNode.appendChild(newNode);
  207.     },
  208.     
  209.     _importNodeEx: function XML_importNodeEx(document, node, deep) {
  210.         var clone = null;
  211.         switch(node.nodeType) {
  212.             case node.ELEMENT_NODE:
  213.                 clone = document.createElementNS(node.namespaceURI, node.nodeName);
  214.                 if (node.localName == XB._base.consts.STR_VAL_REF_ELEM_NAME &&
  215.                     node.namespaceURI == XB._base.consts.STR_UI_NS) {
  216.                     clone.setUserData(XB._base.consts.STR_VAL_REF_ID_KEY_NAME,
  217.                                       node.getUserData(XB._base.consts.STR_VAL_REF_ID_KEY_NAME), this._userDataHandler);
  218.                 }
  219.                 var attributes = node.attributes;
  220.                 for (let i = 0, len = attributes.length; i < len; i++) {
  221.                     let source = attributes[i];
  222.                     let target = document.createAttribute(source.nodeName);
  223.                     target.nodeValue = source.nodeValue;
  224.                     clone.setAttributeNode(target);
  225.                 }
  226.                 if (deep) {
  227.                     let child = node.firstChild;
  228.                     while (child) {
  229.                         clone.appendChild(this._importNodeEx(document, child, deep));
  230.                         child = child.nextSibling;
  231.                     }
  232.                 }
  233.                 break;
  234.             case node.TEXT_NODE:
  235.                 clone = document.createTextNode(node.nodeValue);
  236.                 break;
  237.             case node.CDATA_SECTION_NODE:
  238.                 clone = document.createCDATASection(node.nodeValue);
  239.                 break;
  240.             case node.COMMENT_NODE:
  241.                 clone = document.createComment(node.nodeValue);
  242.                 break;
  243.         }
  244.         
  245.         return clone;
  246.     },
  247.     
  248.     _userDataHandler: {
  249.         handle: function XML_UDH_handle(operation, key, data, srcNode, dstNode) {
  250.             try {
  251.                 dstNode.setUserData(key, data, this);
  252.             }
  253.             catch (e) {
  254.                 XB._base.logger.error("Failed setting userData " + misc.formatError(e));
  255.             }
  256.         }
  257.     }
  258. };
  259.  
  260. XB.types.XML.handleQueryResult = function XBXML_handleQueryResult(queryResult) {
  261.     if (queryResult instanceof Array) {
  262.         XB._base.logger.trace("XML query returned an array of nodes " + queryResult.length);
  263.         if (!queryResult.length)
  264.             return XB.types.empty;
  265.         queryResult = new XB.types.XML(queryResult);
  266.         XB._base.logger.trace("Constructed a new XML " + queryResult.length);
  267.     }
  268.     
  269.     return queryResult;
  270. };
  271.  
  272. XB.types.Exception = function XBException_constructor(srcNodeUid, eType, msg) {
  273.     this._type = eType || this._type;
  274.     this._msg = msg;
  275.     this._srcNodeUid = srcNodeUid;
  276. };
  277.  
  278. XB.types.Exception.types = {
  279.     E_GENERIC: "Exception",
  280.     E_SYNTAX: "Syntax",
  281.     E_TYPE: "Type",
  282.     E_RUNTIME: "Runtime",
  283.     
  284.     E_RETHROW: "Rethrow",
  285.     E_LASTVALUE: "LastValue"
  286. };
  287.  
  288. XB.types.Exception.prototype = {
  289.     get type() {
  290.         return this._type;
  291.     },
  292.     
  293.     get srcNodeUid() {
  294.         return this._srcNodeUid;
  295.     },
  296.     
  297.     get message() {
  298.         return this._msg;
  299.     },
  300.     
  301.     equalsTo: function XBException_equalsTo(other) {
  302.         return sysutils.objectsAreEqual(this, other);
  303.     },
  304.     
  305.     toString: function XBException_toString() {
  306.         return this._type + "@" + this._srcNodeUid + ": " + this._msg;
  307.     },
  308.     
  309.     _type: XB.types.Exception.types.E_GENERIC,
  310.     _srcNodeUid: undefined
  311. };
  312.  
  313. XB.types.RequestData = function RequestData_constructor(url, method, update, expire, format, validStatusRange, validXpath) {
  314.     XB._base.runtime.ensureValueTypeIs(url, "String");
  315.     var uri = XB._Cc["@mozilla.org/network/io-service;1"].getService(XB._Ci.nsIIOService).newURI(url, null, null);
  316.     if (uri.scheme !== "http" && uri.scheme !== "https")
  317.         throw new Error("Invalid URL scheme '" + uri.scheme + "'");
  318.     this._url = url;
  319.     
  320.     XB._base.runtime.ensureValueTypeIs(method, "String");
  321.     this._method = method;
  322.     
  323.     XB._base.runtime.ensureValueTypeIs(update, "Number");
  324.     if (update < 1)
  325.         throw new RangeError("Invalid update interval " + update);
  326.     this._updateInterval = update;
  327.     
  328.     XB._base.runtime.ensureValueTypeIs(expire, "Number");
  329.     if (expire < 0)
  330.         throw new RangeError("Invalid expiration time " + expire);
  331.     this._expirationInterval = expire;
  332.     
  333.     XB._base.runtime.ensureValueTypeIs(format, "Number");
  334.     if (format < XB.types.RequestData.Format.FMT_TEXT || format > XB.types.RequestData.Format.FMT_JSON)
  335.         throw new RangeError("Unknown format type");
  336.     this._format = format;
  337.     
  338.     if (validStatusRange && sysutils.isNumber(validStatusRange.start) && sysutils.isNumber(validStatusRange.end) &&
  339.         validStatusRange.start >= 100 && validStatusRange.end <= 599 && validStatusRange.start <= validStatusRange.end) {
  340.         this._statusMin = validStatusRange.start;
  341.         this._statusMax = validStatusRange.end;
  342.     }
  343.     else
  344.         throw new TypeError("Invalid status range parameter");
  345.     
  346.     if (validXpath) {
  347.         XB._base.runtime.ensureValueTypeIs(validXpath, "String");
  348.         this._checkXpathExpr = validXpath;
  349.     }
  350. };
  351.  
  352. XB.types.RequestData.Format = {
  353.     FMT_TEXT: 0,
  354.     FMT_XML: 1,
  355.     FMT_JSON: 2
  356. };
  357.  
  358. XB.types.RequestData.prototype = {
  359.     constructor: XB.types.RequestData,
  360.     
  361.     get url() {
  362.         return this._url;
  363.     },
  364.     
  365.     get method() {
  366.         return this._method;
  367.     },
  368.     
  369.     get updateInterval() {
  370.         return this._updateInterval;
  371.     },
  372.     
  373.     get expirationInterval() {
  374.         return this._expirationInterval;
  375.     },
  376.     
  377.     get format() {
  378.         return this._format;
  379.     },
  380.     
  381.     get statusRange() {
  382.         return {start: this._statusMin, end: this._statusMax};
  383.     },
  384.     
  385.     get xpathExpression() {
  386.         return this._checkXpathExpr;
  387.     },
  388.     
  389.     get hash() {
  390.         return [this._url, this._method, this.updateInterval, this.expirationInterval, this._format,
  391.                 this._statusMin, this._statusMax, this._checkXpathExpr].join("#");
  392.     },
  393.     
  394.     equalsTo: function ReqData_equalsTo(other) {
  395.         if ( !(other instanceof this.constructor) )
  396.             throw new TypeError("RequestData required");
  397.         return this._fields.every(function(field) { return this[field] == other[field]; }, this);
  398.     },
  399.     
  400.     _url: undefined,
  401.     _method: "GET",
  402.     _updateInterval: 0,
  403.     _expirationInterval: 0,
  404.     _format: XB.types.RequestData.Format.FMT_TEXT,
  405.     _statusMin: 0,
  406.     _statusMax: 0,
  407.     _checkXpathExpr: undefined,
  408.     
  409.     _fields: ["_url", "_method", "_updateInterval", "_expirationInterval", "_format", "_statusMin", "_statusMax", "_checkXpathExpr"]
  410. };
  411.