home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / rpc / xml / XMLEncoder.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  44.1 KB  |  1,298 lines
  1. package mx.rpc.xml
  2. {
  3.    import flash.utils.ByteArray;
  4.    import flash.utils.Dictionary;
  5.    import mx.collections.IList;
  6.    import mx.utils.ObjectProxy;
  7.    import mx.utils.ObjectUtil;
  8.    import mx.utils.object_proxy;
  9.    
  10.    public class XMLEncoder extends SchemaProcessor implements IXMLEncoder
  11.    {
  12.       private var _xmlSpecialCharsFilter:Function;
  13.       
  14.       private var _strictNillability:Boolean = false;
  15.       
  16.       public function XMLEncoder()
  17.       {
  18.          _xmlSpecialCharsFilter = escapeXML;
  19.          super();
  20.       }
  21.       
  22.       protected function deriveXSIType(param1:XML, param2:QName, param3:*) : void
  23.       {
  24.       }
  25.       
  26.       public function appendValue(param1:XMLList, param2:*) : void
  27.       {
  28.          param1[param1.length()] = param2;
  29.       }
  30.       
  31.       public function getAttribute(param1:*, param2:*) : *
  32.       {
  33.          return getValue(param1,param2);
  34.       }
  35.       
  36.       public function set strictNillability(param1:Boolean) : void
  37.       {
  38.          _strictNillability = param1;
  39.       }
  40.       
  41.       public function encodeComplexType(param1:XML, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  42.       {
  43.          var _loc8_:XML = null;
  44.          var _loc6_:XMLList = param1.elements();
  45.          var _loc7_:XMLList = new XMLList();
  46.          for each(_loc8_ in _loc6_)
  47.          {
  48.             if(_loc8_.name() == constants.sequenceQName)
  49.             {
  50.                encodeSequence(_loc8_,_loc7_,param3,param4);
  51.             }
  52.             else if(_loc8_.name() == constants.simpleContentQName)
  53.             {
  54.                encodeSimpleContent(_loc8_,param2,param3,param4,param5);
  55.             }
  56.             else if(_loc8_.name() == constants.complexContentQName)
  57.             {
  58.                encodeComplexContent(_loc8_,param2,param3,param4);
  59.             }
  60.             else if(_loc8_.name() == constants.groupQName)
  61.             {
  62.                encodeGroupReference(_loc8_,_loc7_,param3,param4);
  63.             }
  64.             else if(_loc8_.name() == constants.allQName)
  65.             {
  66.                encodeAll(_loc8_,_loc7_,param3,param4);
  67.             }
  68.             else if(_loc8_.name() == constants.choiceQName)
  69.             {
  70.                encodeChoice(_loc8_,_loc7_,param3,param4);
  71.             }
  72.             else if(_loc8_.name() == constants.attributeQName)
  73.             {
  74.                encodeAttribute(_loc8_,param2,param3,param4,param5);
  75.             }
  76.             else if(_loc8_.name() == constants.attributeGroupQName)
  77.             {
  78.                encodeAttributeGroup(_loc8_,param2,param3,param4,param5);
  79.             }
  80.             else if(_loc8_.name() == constants.anyAttributeQName)
  81.             {
  82.                encodeAnyAttribute(_loc8_,param2,param3,param4,param5);
  83.             }
  84.          }
  85.          setValue(param2,_loc7_);
  86.       }
  87.       
  88.       public function encode(param1:*, param2:QName = null, param3:QName = null, param4:XML = null) : XMLList
  89.       {
  90.          var _loc6_:XML = null;
  91.          var _loc7_:XML = null;
  92.          var _loc8_:Boolean = false;
  93.          var _loc5_:XMLList = new XMLList();
  94.          if(param2 == null)
  95.          {
  96.             param2 = new QName("","root");
  97.          }
  98.          if(param3 != null)
  99.          {
  100.             _loc6_ = encodeXSINil(null,param2,param1);
  101.             if(_loc6_ == null)
  102.             {
  103.                _loc6_ = createElement(param2);
  104.                if(param1 == null)
  105.                {
  106.                   setValue(_loc6_,null);
  107.                }
  108.                else
  109.                {
  110.                   encodeType(param3,_loc6_,param2,param1);
  111.                }
  112.             }
  113.          }
  114.          else
  115.          {
  116.             _loc7_ = param4;
  117.             _loc8_ = false;
  118.             if(_loc7_ == null)
  119.             {
  120.                _loc7_ = schemaManager.getNamedDefinition(param2,constants.elementTypeQName);
  121.                if(_loc7_ != null)
  122.                {
  123.                   _loc8_ = true;
  124.                }
  125.             }
  126.             _loc6_ = encodeElementTopLevel(_loc7_,param2,param1);
  127.             if(_loc8_)
  128.             {
  129.                schemaManager.releaseScope();
  130.             }
  131.          }
  132.          if(_loc6_ != null)
  133.          {
  134.             _loc5_ += _loc6_;
  135.          }
  136.          return _loc5_;
  137.       }
  138.       
  139.       public function encodeXSINil(param1:XML, param2:QName, param3:*, param4:Boolean = true) : XML
  140.       {
  141.          var _loc6_:XML = null;
  142.          var _loc5_:Boolean = true;
  143.          if(strictNillability)
  144.          {
  145.             if(param1 != null)
  146.             {
  147.                _loc5_ = param1.@nillable.toString() == "true" ? true : false;
  148.             }
  149.             else
  150.             {
  151.                _loc5_ = false;
  152.             }
  153.          }
  154.          var _loc7_:String = getAttributeFromNode("fixed",param1);
  155.          if(!(strictNillability && _loc5_) && _loc7_ != null)
  156.          {
  157.             _loc6_ = createElement(param2);
  158.             setValue(_loc6_,schemaManager.marshall(_loc7_,schemaManager.schemaDatatypes.stringQName));
  159.             return _loc6_;
  160.          }
  161.          if(param3 != null)
  162.          {
  163.             return null;
  164.          }
  165.          var _loc8_:String = getAttributeFromNode("default",param1);
  166.          if(param3 == null && _loc8_ != null)
  167.          {
  168.             _loc6_ = createElement(param2);
  169.             setValue(_loc6_,schemaManager.marshall(_loc8_,schemaManager.schemaDatatypes.stringQName));
  170.             return _loc6_;
  171.          }
  172.          if(_loc5_ && param3 === null && param4 == true)
  173.          {
  174.             _loc6_ = createElement(param2);
  175.             setValue(_loc6_,null);
  176.             return _loc6_;
  177.          }
  178.          return null;
  179.       }
  180.       
  181.       public function resolveNamedProperty(param1:*, param2:*) : *
  182.       {
  183.          var value:* = undefined;
  184.          var parent:* = param1;
  185.          var name:* = param2;
  186.          var fallbackName:String = null;
  187.          if(!isSimpleValue(parent))
  188.          {
  189.             try
  190.             {
  191.                value = parent[name];
  192.                if(value === undefined)
  193.                {
  194.                   fallbackName = "_" + name.toString();
  195.                }
  196.             }
  197.             catch(e:Error)
  198.             {
  199.                fallbackName = "_" + name.toString();
  200.             }
  201.             if(fallbackName != null && Boolean(parent.hasOwnProperty(fallbackName)))
  202.             {
  203.                value = parent[fallbackName];
  204.             }
  205.          }
  206.          return value;
  207.       }
  208.       
  209.       public function containsNodeByName(param1:XMLList, param2:QName, param3:Boolean = false) : Boolean
  210.       {
  211.          var _loc5_:XML = null;
  212.          var _loc4_:String = schemaManager.currentSchema.targetNamespace.uri;
  213.          for each(_loc5_ in param1)
  214.          {
  215.             if(param3 || param2.uri != "" && param2.uri != null)
  216.             {
  217.                if(_loc5_.name().uri == "" && _loc4_ == param2.uri)
  218.                {
  219.                   if(_loc5_.name().localName == param2.localName)
  220.                   {
  221.                      return true;
  222.                   }
  223.                }
  224.                else if(_loc5_.name() == param2)
  225.                {
  226.                   return true;
  227.                }
  228.             }
  229.             else if(_loc5_.name().localName == param2.localName)
  230.             {
  231.                return true;
  232.             }
  233.          }
  234.          return false;
  235.       }
  236.       
  237.       public function encodeComplexExtension(param1:XML, param2:XML, param3:QName, param4:*) : void
  238.       {
  239.          var _loc10_:XML = null;
  240.          var _loc11_:XML = null;
  241.          var _loc5_:String = getAttributeFromNode("base",param1);
  242.          if(_loc5_ == null)
  243.          {
  244.             throw new Error("A complexContent extension must declare a base type.");
  245.          }
  246.          var _loc6_:QName = schemaManager.getQNameForPrefixedName(_loc5_,param1);
  247.          var _loc7_:XML = schemaManager.getNamedDefinition(_loc6_,constants.complexTypeQName);
  248.          if(_loc7_ == null)
  249.          {
  250.             throw new Error("Cannot find base type definition \'" + _loc6_ + "\'");
  251.          }
  252.          encodeComplexType(_loc7_,param2,param3,param4);
  253.          schemaManager.releaseScope();
  254.          var _loc8_:XMLList = param1.elements();
  255.          var _loc9_:XMLList = new XMLList();
  256.          for each(_loc10_ in _loc8_)
  257.          {
  258.             if(_loc10_.name() == constants.sequenceQName)
  259.             {
  260.                encodeSequence(_loc10_,_loc9_,param3,param4);
  261.             }
  262.             else if(_loc10_.name() == constants.groupQName)
  263.             {
  264.                encodeGroupReference(_loc10_,_loc9_,param3,param4);
  265.             }
  266.             else if(_loc10_.name() == constants.allQName)
  267.             {
  268.                encodeAll(_loc10_,_loc9_,param3,param4);
  269.             }
  270.             else if(_loc10_.name() == constants.choiceQName)
  271.             {
  272.                encodeChoice(_loc10_,_loc9_,param3,param4);
  273.             }
  274.             else if(_loc10_.name() == constants.attributeQName)
  275.             {
  276.                encodeAttribute(_loc10_,param2,param3,param4);
  277.             }
  278.             else if(_loc10_.name() == constants.attributeGroupQName)
  279.             {
  280.                encodeAttributeGroup(_loc10_,param2,param3,param4);
  281.             }
  282.             else if(_loc10_.name() == constants.anyAttributeQName)
  283.             {
  284.                encodeAnyAttribute(_loc10_,param2,param3,param4);
  285.             }
  286.          }
  287.          for each(_loc11_ in _loc9_)
  288.          {
  289.             delete param2[_loc11_.name()];
  290.             delete param2[new QName("",_loc11_.name().localName)];
  291.             delete param2[new QName(null,_loc11_.name().localName)];
  292.          }
  293.          setValue(param2,_loc9_);
  294.       }
  295.       
  296.       public function encodeSimpleList(param1:XML, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  297.       {
  298.          var _loc7_:QName = null;
  299.          var _loc8_:XML = null;
  300.          var _loc11_:* = undefined;
  301.          var _loc12_:* = undefined;
  302.          var _loc6_:String = param1.@itemType;
  303.          if(_loc6_ != "")
  304.          {
  305.             _loc7_ = schemaManager.getQNameForPrefixedName(_loc6_,param1);
  306.          }
  307.          else
  308.          {
  309.             _loc8_ = getSingleElementFromNode(param1,constants.simpleTypeQName);
  310.          }
  311.          var _loc9_:String = "";
  312.          if(!TypeIterator.isIterable(param4))
  313.          {
  314.             param4 = [param4];
  315.          }
  316.          var _loc10_:TypeIterator = new TypeIterator(param4);
  317.          while(_loc10_.hasNext())
  318.          {
  319.             _loc11_ = _loc10_.next();
  320.             _loc12_ = <temp/>;
  321.             if(_loc11_ != null)
  322.             {
  323.                if(_loc7_ != null)
  324.                {
  325.                   encodeType(_loc7_,_loc12_,param3,_loc11_,param5);
  326.                }
  327.                else
  328.                {
  329.                   encodeSimpleType(_loc8_,_loc12_,param3,_loc11_,param5);
  330.                }
  331.                _loc9_ = _loc9_.concat(_loc12_.toString());
  332.                if(_loc10_.hasNext())
  333.                {
  334.                   _loc9_ = _loc9_.concat(" ");
  335.                }
  336.             }
  337.          }
  338.          setValue(param2,_loc9_);
  339.       }
  340.       
  341.       public function hasAttribute(param1:*, param2:*) : Boolean
  342.       {
  343.          return getAttribute(param1,param2) !== undefined;
  344.       }
  345.       
  346.       public function encodeAll(param1:XML, param2:XMLList, param3:QName, param4:*, param5:Boolean = true) : Boolean
  347.       {
  348.          return encodeSequence(param1,param2,param3,param4,param5);
  349.       }
  350.       
  351.       public function encodeAttribute(param1:XML, param2:XML, param3:QName, param4:* = undefined, param5:XML = null) : void
  352.       {
  353.          var _loc6_:QName = null;
  354.          var _loc9_:QName = null;
  355.          var _loc10_:String = null;
  356.          var _loc11_:* = undefined;
  357.          var _loc12_:Boolean = false;
  358.          var _loc13_:String = null;
  359.          var _loc14_:XML = null;
  360.          var _loc15_:String = null;
  361.          var _loc16_:QName = null;
  362.          if(param1.attribute("ref").length() == 1)
  363.          {
  364.             _loc6_ = schemaManager.getQNameForPrefixedName(param1.@ref,param1,true);
  365.             param1 = schemaManager.getNamedDefinition(_loc6_,constants.attributeQName);
  366.             if(param1 == null)
  367.             {
  368.                throw new Error("Cannot resolve attribute definition for \'" + _loc6_ + "\'");
  369.             }
  370.          }
  371.          var _loc7_:String = param1.@name.toString();
  372.          var _loc8_:String = param1.attribute("use").toString();
  373.          if(_loc8_ != "prohibited")
  374.          {
  375.             _loc9_ = schemaManager.getQNameForAttribute(_loc7_,getAttributeFromNode("form",param1));
  376.             _loc10_ = getAttributeFromNode("fixed",param1);
  377.             if(_loc10_ != null)
  378.             {
  379.                param4 = _loc10_;
  380.             }
  381.             else
  382.             {
  383.                param4 = getValue(param4,_loc9_);
  384.                if(param4 === undefined)
  385.                {
  386.                   _loc13_ = getAttributeFromNode("default",param1);
  387.                   if(_loc13_ != null)
  388.                   {
  389.                      param4 = _loc13_;
  390.                   }
  391.                }
  392.             }
  393.             if(param4 !== undefined)
  394.             {
  395.                _loc11_ = <temp/>;
  396.                _loc15_ = getAttributeFromNode("type",param1);
  397.                if(_loc15_ != null)
  398.                {
  399.                   _loc16_ = schemaManager.getQNameForPrefixedName(param1.@type,param1);
  400.                }
  401.                else
  402.                {
  403.                   _loc16_ = schemaManager.schemaDatatypes.anySimpleTypeQName;
  404.                }
  405.                if(_loc16_ != null)
  406.                {
  407.                   if(isBuiltInType(_loc16_))
  408.                   {
  409.                      _loc11_.appendChild(schemaManager.marshall(param4,_loc16_,param5));
  410.                   }
  411.                   else
  412.                   {
  413.                      _loc14_ = schemaManager.getNamedDefinition(_loc16_,constants.simpleTypeQName);
  414.                      if(_loc14_ == null)
  415.                      {
  416.                         throw new Error("Cannot find simpleType " + _loc16_ + " for attribute " + _loc9_);
  417.                      }
  418.                      encodeSimpleType(_loc14_,_loc11_,_loc9_,param4,param5);
  419.                      schemaManager.releaseScope();
  420.                   }
  421.                }
  422.                else
  423.                {
  424.                   _loc14_ = getSingleElementFromNode(param1,constants.simpleTypeQName);
  425.                   if(_loc14_ != null)
  426.                   {
  427.                      encodeSimpleType(_loc14_,_loc11_,_loc9_,param4,param5);
  428.                   }
  429.                   else if(param4 != null)
  430.                   {
  431.                      _loc11_.appendChild(param4.toString());
  432.                   }
  433.                }
  434.             }
  435.             if(_loc11_ !== undefined)
  436.             {
  437.                setAttribute(param2,_loc9_,_loc11_);
  438.             }
  439.          }
  440.          if(_loc6_ != null)
  441.          {
  442.             schemaManager.releaseScope();
  443.          }
  444.       }
  445.       
  446.       public function setValue(param1:*, param2:*) : void
  447.       {
  448.          var _loc3_:XML = null;
  449.          if(param2 !== undefined)
  450.          {
  451.             if(param1 is XML)
  452.             {
  453.                _loc3_ = param1 as XML;
  454.             }
  455.             else if(param1 is XMLList && param1.length() > 0)
  456.             {
  457.                _loc3_ = param1[param1.length() - 1];
  458.             }
  459.             if(_loc3_ != null)
  460.             {
  461.                if(param2 === null)
  462.                {
  463.                   _loc3_[schemaManager.schemaConstants.nilQName] = "true";
  464.                   _loc3_.addNamespace(constants.xsiNamespace);
  465.                }
  466.                else if(param2 is XML || param2 is XMLList)
  467.                {
  468.                   _loc3_.appendChild(param2);
  469.                }
  470.                else if(param2 !== undefined)
  471.                {
  472.                   _loc3_.appendChild(xmlSpecialCharsFilter(Object(param2)));
  473.                }
  474.             }
  475.          }
  476.       }
  477.       
  478.       public function getProperties(param1:*) : Array
  479.       {
  480.          var _loc2_:Object = ObjectUtil.getClassInfo(param1 as Object,null,{"includeReadOnly":false});
  481.          return _loc2_.properties;
  482.       }
  483.       
  484.       public function encodeComplexRestriction(param1:XML, param2:XML, param3:QName, param4:*) : void
  485.       {
  486.          var _loc9_:XML = null;
  487.          var _loc5_:String = getAttributeFromNode("base",param1);
  488.          if(_loc5_ == null)
  489.          {
  490.             throw new Error("A complexContent restriction must declare a base type.");
  491.          }
  492.          var _loc6_:QName = schemaManager.getQNameForPrefixedName(_loc5_,param1);
  493.          var _loc7_:XMLList = param1.elements();
  494.          var _loc8_:XMLList = param2.elements();
  495.          for each(_loc9_ in _loc7_)
  496.          {
  497.             if(_loc9_.name() == constants.sequenceQName)
  498.             {
  499.                encodeSequence(_loc9_,_loc8_,param3,param4);
  500.             }
  501.             else if(_loc9_.name() == constants.groupQName)
  502.             {
  503.                encodeGroupReference(_loc9_,_loc8_,param3,param4);
  504.             }
  505.             else if(_loc9_.name() == constants.allQName)
  506.             {
  507.                encodeAll(_loc9_,_loc8_,param3,param4);
  508.             }
  509.             else if(_loc9_.name() == constants.choiceQName)
  510.             {
  511.                encodeChoice(_loc9_,_loc8_,param3,param4);
  512.             }
  513.             else if(_loc9_.name() == constants.attributeQName)
  514.             {
  515.                encodeAttribute(_loc9_,param2,param3,param4,param1);
  516.             }
  517.             else if(_loc9_.name() == constants.attributeGroupQName)
  518.             {
  519.                encodeAttributeGroup(_loc9_,param2,param3,param4,param1);
  520.             }
  521.             else if(_loc9_.name() == constants.anyAttributeQName)
  522.             {
  523.                encodeAnyAttribute(_loc9_,param2,param3,param4,param1);
  524.             }
  525.          }
  526.          param2.setChildren(_loc8_);
  527.       }
  528.       
  529.       public function get xmlSpecialCharsFilter() : Function
  530.       {
  531.          return _xmlSpecialCharsFilter;
  532.       }
  533.       
  534.       public function encodeAnyElement(param1:XML, param2:XMLList, param3:QName, param4:*, param5:Boolean = true, param6:Dictionary = null) : Boolean
  535.       {
  536.          var _loc9_:XML = null;
  537.          var _loc10_:* = undefined;
  538.          var _loc11_:* = undefined;
  539.          var _loc12_:XMLList = null;
  540.          var _loc13_:Object = null;
  541.          var _loc14_:* = undefined;
  542.          var _loc15_:QName = null;
  543.          var _loc16_:XML = null;
  544.          var _loc17_:XMLList = null;
  545.          var _loc7_:uint = getMaxOccurs(param1);
  546.          var _loc8_:uint = getMinOccurs(param1);
  547.          if(isSimpleValue(param4))
  548.          {
  549.             _loc9_ = createElement(param3);
  550.             setValue(_loc9_,param4);
  551.             appendValue(param2,_loc9_);
  552.          }
  553.          else if(param4 is XML || param4 is XMLList)
  554.          {
  555.             appendValue(param2,param4);
  556.          }
  557.          else
  558.          {
  559.             if(param6 == null)
  560.             {
  561.                param6 = new Dictionary(true);
  562.             }
  563.             if(!(param4 is QName))
  564.             {
  565.                if(param6[param4] != null)
  566.                {
  567.                   throw new Error("Cannot encode complex structure. Cyclic references detected.");
  568.                }
  569.                param6[param4] = true;
  570.             }
  571.             if(param4 is Array || param4 is IList)
  572.             {
  573.                if(param4 is IList)
  574.                {
  575.                   param4 = IList(param4).toArray();
  576.                }
  577.                for each(_loc10_ in param4 as Array)
  578.                {
  579.                   _loc11_ = createElement(param3);
  580.                   if(_loc10_ == null)
  581.                   {
  582.                      setValue(_loc11_,null);
  583.                   }
  584.                   else if(_loc10_ != null)
  585.                   {
  586.                      _loc12_ = new XMLList();
  587.                      encodeAnyElement(param1,_loc12_,param3,_loc10_,param5,param6);
  588.                      if(isSimpleValue(_loc10_))
  589.                      {
  590.                         _loc11_ = _loc12_[0];
  591.                      }
  592.                      else
  593.                      {
  594.                         setValue(_loc11_,_loc12_);
  595.                      }
  596.                   }
  597.                   appendValue(param2,_loc11_);
  598.                }
  599.             }
  600.             else
  601.             {
  602.                for each(_loc13_ in getProperties(param4))
  603.                {
  604.                   _loc14_ = getValue(param4,_loc13_);
  605.                   _loc15_ = new QName(param3.uri,_loc13_);
  606.                   if(!containsNodeByName(param2,_loc15_))
  607.                   {
  608.                      _loc16_ = encodeXSINil(param1,_loc15_,_loc14_);
  609.                      if(_loc16_ != null)
  610.                      {
  611.                         appendValue(param2,_loc16_);
  612.                      }
  613.                      else if(_loc14_ != null)
  614.                      {
  615.                         _loc17_ = new XMLList();
  616.                         encodeAnyElement(param1,_loc17_,_loc15_,_loc14_,param5,param6);
  617.                         appendValue(param2,_loc17_);
  618.                      }
  619.                   }
  620.                }
  621.             }
  622.             delete param6[param4];
  623.          }
  624.          return true;
  625.       }
  626.       
  627.       public function getSimpleValue(param1:*, param2:*) : *
  628.       {
  629.          var _loc3_:* = getValue(param1,param2);
  630.          if(_loc3_ === undefined)
  631.          {
  632.             _loc3_ = getValue(param1,"_value");
  633.          }
  634.          return _loc3_;
  635.       }
  636.       
  637.       public function getValue(param1:*, param2:*) : *
  638.       {
  639.          var _loc3_:* = undefined;
  640.          var _loc4_:XMLList = null;
  641.          if(param1 is XML || param1 is XMLList)
  642.          {
  643.             _loc4_ = param1[param2];
  644.             if(_loc4_.length() > 0)
  645.             {
  646.                _loc3_ = _loc4_;
  647.             }
  648.          }
  649.          else if(TypeIterator.isIterable(param1))
  650.          {
  651.             if(Boolean(param1.hasOwnProperty(param2)) && param1[param2] !== undefined)
  652.             {
  653.                _loc3_ = resolveNamedProperty(param1,param2);
  654.             }
  655.             else
  656.             {
  657.                _loc3_ = param1;
  658.             }
  659.          }
  660.          else if(!isSimpleValue(param1))
  661.          {
  662.             if(param2 is QName)
  663.             {
  664.                param2 = QName(param2).localName;
  665.             }
  666.             _loc3_ = resolveNamedProperty(param1,param2);
  667.          }
  668.          else
  669.          {
  670.             _loc3_ = param1;
  671.          }
  672.          return _loc3_;
  673.       }
  674.       
  675.       public function encodeGroupReference(param1:XML, param2:XMLList, param3:QName, param4:*, param5:Boolean = true) : Boolean
  676.       {
  677.          var _loc6_:QName = null;
  678.          var _loc9_:XML = null;
  679.          if(param1.attribute("ref").length() == 1)
  680.          {
  681.             _loc6_ = schemaManager.getQNameForPrefixedName(param1.@ref,param1,true);
  682.             param1 = schemaManager.getNamedDefinition(_loc6_,constants.groupQName);
  683.             if(param1 == null)
  684.             {
  685.                throw new Error("Cannot resolve group definition for \'" + _loc6_ + "\'");
  686.             }
  687.             var _loc7_:XMLList = param1.elements();
  688.             var _loc8_:Boolean = false;
  689.             for each(_loc9_ in _loc7_)
  690.             {
  691.                if(_loc9_.name() == constants.sequenceQName)
  692.                {
  693.                   _loc8_ = encodeSequence(_loc9_,param2,param3,param4,param5);
  694.                }
  695.                else if(_loc9_.name() == constants.allQName)
  696.                {
  697.                   _loc8_ = encodeAll(_loc9_,param2,param3,param4,param5);
  698.                }
  699.                else if(_loc9_.name() == constants.choiceQName)
  700.                {
  701.                   _loc8_ = encodeChoice(_loc9_,param2,param3,param4,param5);
  702.                }
  703.             }
  704.             schemaManager.releaseScope();
  705.             return _loc8_;
  706.          }
  707.          throw new Error("A group reference element must have the ref attribute");
  708.       }
  709.       
  710.       public function encodeSimpleRestriction(param1:XML, param2:XML, param3:QName, param4:*) : void
  711.       {
  712.          var _loc6_:String = null;
  713.          var _loc7_:QName = null;
  714.          var _loc5_:XML = getSingleElementFromNode(param1,constants.simpleTypeQName);
  715.          if(_loc5_ != null)
  716.          {
  717.             encodeSimpleType(_loc5_,param2,param3,param4,param1);
  718.          }
  719.          else
  720.          {
  721.             _loc6_ = getAttributeFromNode("base",param1);
  722.             _loc7_ = schemaManager.getQNameForPrefixedName(_loc6_,param1);
  723.             encodeType(_loc7_,param2,param3,param4,param1);
  724.          }
  725.       }
  726.       
  727.       public function encodeAnyAttribute(param1:XML, param2:XML, param3:QName, param4:* = undefined, param5:XML = null) : void
  728.       {
  729.          var _loc6_:Object = null;
  730.          var _loc7_:* = undefined;
  731.          if(param4 !== undefined)
  732.          {
  733.             if(!isSimpleValue(param4) && !(param4 is Array))
  734.             {
  735.                for(_loc6_ in getProperties(param4))
  736.                {
  737.                   if(!hasAttribute(param4,_loc6_) && !hasValue(param4,_loc6_))
  738.                   {
  739.                      _loc7_ = getAttribute(param4,_loc6_);
  740.                      if(_loc7_ != null)
  741.                      {
  742.                         setAttribute(param2,_loc6_,_loc7_);
  743.                      }
  744.                   }
  745.                }
  746.             }
  747.          }
  748.       }
  749.       
  750.       public function encodeSimpleUnion(param1:XML, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  751.       {
  752.          var _loc8_:QName = null;
  753.          var _loc9_:* = undefined;
  754.          var _loc11_:String = null;
  755.          var _loc12_:QName = null;
  756.          var _loc6_:String = getAttributeFromNode("memberTypes",param1);
  757.          var _loc7_:Array = _loc6_.split(" ");
  758.          var _loc10_:int = 0;
  759.          while(_loc10_ < _loc7_.length)
  760.          {
  761.             _loc11_ = _loc7_[_loc10_];
  762.             _loc12_ = schemaManager.getQNameForPrefixedName(_loc11_,param1);
  763.             if(!isBuiltInType(_loc12_))
  764.             {
  765.                _loc9_ = getValue(param4,_loc12_);
  766.                if(_loc9_ !== undefined)
  767.                {
  768.                   _loc8_ = _loc12_;
  769.                   break;
  770.                }
  771.             }
  772.             _loc10_++;
  773.          }
  774.          if(!_loc8_)
  775.          {
  776.             _loc8_ = schemaManager.schemaDatatypes.stringQName;
  777.          }
  778.          setValue(param2,schemaManager.marshall(param4,_loc8_,param5));
  779.       }
  780.       
  781.       public function encodeSimpleType(param1:XML, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  782.       {
  783.          var _loc6_:XML = getSingleElementFromNode(param1,constants.restrictionQName,constants.listQName,constants.unionQName);
  784.          if(_loc6_.name() == constants.restrictionQName)
  785.          {
  786.             encodeSimpleRestriction(_loc6_,param2,param3,param4);
  787.          }
  788.          else if(_loc6_.name() == constants.listQName)
  789.          {
  790.             encodeSimpleList(_loc6_,param2,param3,param4,param5);
  791.          }
  792.          else if(_loc6_.name() == constants.listQName)
  793.          {
  794.             encodeSimpleUnion(_loc6_,param2,param3,param4,param5);
  795.          }
  796.       }
  797.       
  798.       public function get strictNillability() : Boolean
  799.       {
  800.          return _strictNillability;
  801.       }
  802.       
  803.       public function encodeElementTopLevel(param1:XML, param2:QName, param3:*) : XML
  804.       {
  805.          var _loc6_:QName = null;
  806.          var _loc7_:XML = null;
  807.          var _loc4_:XML = encodeXSINil(param1,param2,param3);
  808.          if(_loc4_ != null)
  809.          {
  810.             return _loc4_;
  811.          }
  812.          if(param3 == null)
  813.          {
  814.             return null;
  815.          }
  816.          _loc4_ = createElement(param2);
  817.          var _loc5_:String = getAttributeFromNode("type",param1);
  818.          if(_loc5_ != null)
  819.          {
  820.             _loc6_ = schemaManager.getQNameForPrefixedName(_loc5_,param1);
  821.             encodeType(_loc6_,_loc4_,param2,param3);
  822.          }
  823.          else if(param1 != null && Boolean(param1.hasComplexContent()))
  824.          {
  825.             _loc7_ = getSingleElementFromNode(param1,constants.complexTypeQName,constants.simpleTypeQName);
  826.             if(_loc7_.name() == constants.complexTypeQName)
  827.             {
  828.                encodeComplexType(_loc7_,_loc4_,param2,param3);
  829.             }
  830.             else if(_loc7_.name() == constants.simpleTypeQName)
  831.             {
  832.                encodeSimpleType(_loc7_,_loc4_,param2,param3);
  833.             }
  834.          }
  835.          else
  836.          {
  837.             encodeType(constants.anyTypeQName,_loc4_,param2,param3);
  838.          }
  839.          return _loc4_;
  840.       }
  841.       
  842.       private function escapeXML(param1:Object) : String
  843.       {
  844.          var _loc2_:String = param1.toString();
  845.          return _loc2_.replace(/&/g,"&").replace(/</g,"<");
  846.       }
  847.       
  848.       public function encodeChoice(param1:XML, param2:XMLList, param3:QName, param4:*, param5:Boolean = true) : Boolean
  849.       {
  850.          var _loc10_:uint = 0;
  851.          var _loc11_:uint = 0;
  852.          var _loc12_:XML = null;
  853.          var _loc6_:uint = getMaxOccurs(param1);
  854.          var _loc7_:uint = getMinOccurs(param1);
  855.          if(_loc6_ == 0)
  856.          {
  857.             return false;
  858.          }
  859.          if(param4 == null && _loc7_ == 0)
  860.          {
  861.             return true;
  862.          }
  863.          var _loc8_:XMLList = param1.elements();
  864.          var _loc9_:Boolean = true;
  865.          if(_loc8_.length() > 0)
  866.          {
  867.             _loc9_ = false;
  868.          }
  869.          for each(_loc12_ in _loc8_)
  870.          {
  871.             if(_loc12_.name() == constants.elementTypeQName)
  872.             {
  873.                _loc9_ = encodeGroupElement(_loc12_,param2,param3,param4,false) || _loc9_;
  874.             }
  875.             else if(_loc12_.name() == constants.sequenceQName)
  876.             {
  877.                _loc9_ = encodeSequence(_loc12_,param2,param3,param4,false) || _loc9_;
  878.             }
  879.             else if(_loc12_.name() == constants.groupQName)
  880.             {
  881.                _loc9_ = encodeGroupReference(_loc12_,param2,param3,param4,false) || _loc9_;
  882.             }
  883.             else if(_loc12_.name() == constants.choiceQName)
  884.             {
  885.                _loc9_ = encodeChoice(_loc12_,param2,param3,param4,false) || _loc9_;
  886.             }
  887.             else if(_loc12_.name() == constants.anyQName)
  888.             {
  889.                _loc9_ = encodeAnyElement(_loc12_,param2,param3,param4,false) || _loc9_;
  890.             }
  891.          }
  892.          return _loc9_;
  893.       }
  894.       
  895.       public function setAttribute(param1:XML, param2:*, param3:*) : void
  896.       {
  897.          if(param3 != null)
  898.          {
  899.             param1[param2] = param3.toString();
  900.          }
  901.       }
  902.       
  903.       public function isSimpleValue(param1:*) : Boolean
  904.       {
  905.          if(param1 is String || param1 is Number || param1 is Boolean || param1 is Date || param1 is int || param1 is uint || param1 is ByteArray)
  906.          {
  907.             return true;
  908.          }
  909.          return false;
  910.       }
  911.       
  912.       public function encodeComplexContent(param1:XML, param2:XML, param3:QName, param4:*) : void
  913.       {
  914.          var _loc5_:XML = getSingleElementFromNode(param1,constants.extensionQName,constants.restrictionQName);
  915.          if(_loc5_.name() == constants.extensionQName)
  916.          {
  917.             encodeComplexExtension(_loc5_,param2,param3,param4);
  918.          }
  919.          else if(_loc5_.name() == constants.restrictionQName)
  920.          {
  921.             encodeComplexRestriction(_loc5_,param2,param3,param4);
  922.          }
  923.       }
  924.       
  925.       public function createElement(param1:*) : XML
  926.       {
  927.          var _loc2_:XML = null;
  928.          var _loc3_:QName = null;
  929.          var _loc4_:String = null;
  930.          var _loc5_:Namespace = null;
  931.          if(param1 is QName)
  932.          {
  933.             _loc3_ = param1 as QName;
  934.          }
  935.          else
  936.          {
  937.             _loc3_ = new QName("",param1.toString());
  938.          }
  939.          _loc2_ = new XML("<" + _loc3_.localName + "/>");
  940.          if(_loc3_.uri != null && _loc3_.uri.length > 0)
  941.          {
  942.             _loc4_ = schemaManager.getOrCreatePrefix(_loc3_.uri);
  943.             _loc5_ = new Namespace(_loc4_,_loc3_.uri);
  944.             _loc2_.setNamespace(_loc5_);
  945.          }
  946.          return _loc2_;
  947.       }
  948.       
  949.       protected function setXSIType(param1:XML, param2:QName) : void
  950.       {
  951.          var _loc3_:String = param2.uri;
  952.          var _loc4_:String = schemaManager.getOrCreatePrefix(_loc3_);
  953.          var _loc5_:Namespace = new Namespace(_loc4_,_loc3_);
  954.          param1.addNamespace(_loc5_);
  955.          param1[constants.getXSIToken(constants.typeAttrQName)] = _loc4_ + ":" + param2.localName;
  956.       }
  957.       
  958.       public function encodeGroupElement(param1:XML, param2:XMLList, param3:QName, param4:*, param5:Boolean = true) : Boolean
  959.       {
  960.          var _loc8_:QName = null;
  961.          var _loc12_:XML = null;
  962.          var _loc13_:uint = 0;
  963.          var _loc14_:TypeIterator = null;
  964.          var _loc15_:uint = 0;
  965.          var _loc16_:* = undefined;
  966.          var _loc6_:uint = getMaxOccurs(param1);
  967.          var _loc7_:uint = getMinOccurs(param1);
  968.          if(_loc6_ == 0)
  969.          {
  970.             return true;
  971.          }
  972.          param5 &&= _loc7_ > 0;
  973.          if(param1.attribute("ref").length() == 1)
  974.          {
  975.             _loc8_ = schemaManager.getQNameForPrefixedName(param1.@ref,param1,true);
  976.             param1 = schemaManager.getNamedDefinition(_loc8_,constants.elementTypeQName);
  977.             if(param1 == null)
  978.             {
  979.                throw new Error("Cannot resolve element definition for ref \'" + _loc8_ + "\'");
  980.             }
  981.          }
  982.          var _loc9_:String = param1.@name.toString();
  983.          var _loc10_:QName = schemaManager.getQNameForElement(_loc9_,getAttributeFromNode("form",param1));
  984.          var _loc11_:* = getValue(param4,_loc10_);
  985.          if(_loc11_ == null)
  986.          {
  987.             _loc12_ = encodeElementTopLevel(param1,_loc10_,_loc11_);
  988.             if(_loc12_ != null)
  989.             {
  990.                appendValue(param2,_loc12_);
  991.             }
  992.             if(_loc8_ != null)
  993.             {
  994.                schemaManager.releaseScope();
  995.             }
  996.             if(param5 && _loc12_ == null)
  997.             {
  998.                return false;
  999.             }
  1000.             return true;
  1001.          }
  1002.          if(_loc6_ == 1)
  1003.          {
  1004.             _loc12_ = encodeElementTopLevel(param1,_loc10_,_loc11_);
  1005.             if(_loc12_ != null)
  1006.             {
  1007.                appendValue(param2,_loc12_);
  1008.             }
  1009.          }
  1010.          else if(_loc6_ > 1)
  1011.          {
  1012.             _loc13_ = getValueOccurence(_loc11_);
  1013.             if(_loc13_ < _loc7_)
  1014.             {
  1015.                throw new Error("Value supplied for element \'" + _loc10_ + "\' occurs " + _loc13_ + " times which falls short of minOccurs " + _loc7_ + ".");
  1016.             }
  1017.             if(_loc13_ > _loc6_)
  1018.             {
  1019.                throw new Error("Value supplied for element of type \'" + _loc10_ + "\' occurs " + _loc13_ + " times which exceeds maxOccurs " + _loc6_ + ".");
  1020.             }
  1021.             if(!TypeIterator.isIterable(_loc11_))
  1022.             {
  1023.                _loc11_ = [_loc11_];
  1024.             }
  1025.             _loc14_ = new TypeIterator(_loc11_);
  1026.             _loc15_ = 0;
  1027.             while(_loc15_ < _loc6_ && _loc15_ < _loc13_)
  1028.             {
  1029.                if(_loc14_.hasNext())
  1030.                {
  1031.                   _loc16_ = _loc14_.next();
  1032.                }
  1033.                else if(_loc15_ > _loc7_)
  1034.                {
  1035.                   break;
  1036.                }
  1037.                _loc12_ = encodeElementTopLevel(param1,_loc10_,_loc16_);
  1038.                if(_loc12_ == null)
  1039.                {
  1040.                   _loc12_ = createElement(_loc10_);
  1041.                   setValue(_loc12_,null);
  1042.                }
  1043.                appendValue(param2,_loc12_);
  1044.                _loc15_++;
  1045.             }
  1046.          }
  1047.          if(_loc8_ != null)
  1048.          {
  1049.             schemaManager.releaseScope();
  1050.          }
  1051.          return true;
  1052.       }
  1053.       
  1054.       public function set xmlSpecialCharsFilter(param1:Function) : void
  1055.       {
  1056.          if(param1 != null)
  1057.          {
  1058.             _xmlSpecialCharsFilter = param1;
  1059.          }
  1060.          else
  1061.          {
  1062.             _xmlSpecialCharsFilter = escapeXML;
  1063.          }
  1064.       }
  1065.       
  1066.       public function encodeType(param1:QName, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  1067.       {
  1068.          var _loc8_:XMLList = null;
  1069.          var _loc9_:QName = null;
  1070.          var _loc6_:QName = getXSIType(param4);
  1071.          if(_loc6_ != null)
  1072.          {
  1073.             param1 = _loc6_;
  1074.          }
  1075.          var _loc7_:XML = schemaManager.getNamedDefinition(param1,constants.complexTypeQName,constants.simpleTypeQName);
  1076.          if(isBuiltInType(param1))
  1077.          {
  1078.             if(param1 == constants.anyTypeQName && !isSimpleValue(param4))
  1079.             {
  1080.                _loc8_ = new XMLList();
  1081.                encodeAnyElement(_loc7_,_loc8_,param3,param4);
  1082.                setValue(param2,_loc8_);
  1083.             }
  1084.             else
  1085.             {
  1086.                setValue(param2,schemaManager.marshall(param4,param1,param5));
  1087.             }
  1088.             deriveXSIType(param2,param1,param4);
  1089.          }
  1090.          else
  1091.          {
  1092.             if(_loc7_ == null)
  1093.             {
  1094.                throw new Error("Cannot find definition for type \'" + param1 + "\'");
  1095.             }
  1096.             _loc9_ = _loc7_.name() as QName;
  1097.             if(_loc9_ == constants.complexTypeQName)
  1098.             {
  1099.                encodeComplexType(_loc7_,param2,param3,param4,param5);
  1100.             }
  1101.             else
  1102.             {
  1103.                if(_loc9_ != constants.simpleTypeQName)
  1104.                {
  1105.                   throw new Error("Invalid type definition " + _loc9_);
  1106.                }
  1107.                encodeSimpleType(_loc7_,param2,param3,param4,param5);
  1108.             }
  1109.          }
  1110.          if(_loc7_ != null)
  1111.          {
  1112.             schemaManager.releaseScope();
  1113.          }
  1114.       }
  1115.       
  1116.       public function encodeSimpleContent(param1:XML, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  1117.       {
  1118.          var _loc7_:String = null;
  1119.          var _loc8_:QName = null;
  1120.          var _loc9_:* = undefined;
  1121.          var _loc10_:XML = null;
  1122.          var _loc11_:XMLList = null;
  1123.          var _loc12_:XML = null;
  1124.          var _loc6_:XML = getSingleElementFromNode(param1,constants.extensionQName,constants.restrictionQName);
  1125.          if(_loc6_ != null)
  1126.          {
  1127.             _loc7_ = getAttributeFromNode("base",_loc6_);
  1128.             if(_loc7_ == null)
  1129.             {
  1130.                throw new Error("A simpleContent extension or restriction must declare a base type.");
  1131.             }
  1132.             _loc8_ = schemaManager.getQNameForPrefixedName(_loc7_,_loc6_);
  1133.             if(!isBuiltInType(_loc8_))
  1134.             {
  1135.                _loc10_ = schemaManager.getNamedDefinition(_loc8_,constants.complexTypeQName,constants.simpleTypeQName);
  1136.                if(_loc10_ == null)
  1137.                {
  1138.                   throw new Error("Cannot find base type definition \'" + _loc8_ + "\'");
  1139.                }
  1140.                schemaManager.releaseScope();
  1141.             }
  1142.             if(_loc6_.name() == constants.extensionQName)
  1143.             {
  1144.                if(isBuiltInType(_loc8_))
  1145.                {
  1146.                   _loc9_ = getSimpleValue(param4,param3);
  1147.                   setValue(param2,schemaManager.marshall(_loc9_,_loc8_,param5));
  1148.                }
  1149.                else
  1150.                {
  1151.                   encodeType(_loc8_,param2,param4,param5);
  1152.                }
  1153.                _loc11_ = _loc6_.elements();
  1154.                for each(_loc12_ in _loc11_)
  1155.                {
  1156.                   if(_loc12_.name() == constants.attributeQName)
  1157.                   {
  1158.                      encodeAttribute(_loc12_,param2,param3,param4,param5);
  1159.                   }
  1160.                   else if(_loc12_.name() == constants.attributeGroupQName)
  1161.                   {
  1162.                      encodeAttributeGroup(_loc12_,param2,param3,param4,param5);
  1163.                   }
  1164.                   else if(_loc12_.name() == constants.anyAttributeQName)
  1165.                   {
  1166.                      encodeAnyAttribute(_loc12_,param2,param3,param4,param5);
  1167.                   }
  1168.                }
  1169.             }
  1170.             else if(_loc6_.name() == constants.restrictionQName)
  1171.             {
  1172.                _loc9_ = getSimpleValue(param4,param3);
  1173.                encodeSimpleRestriction(_loc6_,param2,param3,_loc9_);
  1174.             }
  1175.          }
  1176.       }
  1177.       
  1178.       protected function getXSIType(param1:*) : QName
  1179.       {
  1180.          var _loc2_:QName = null;
  1181.          if(param1 != null)
  1182.          {
  1183.             if(param1 is ObjectProxy && param1.object_proxy::type != null)
  1184.             {
  1185.                _loc2_ = param1.object_proxy::type;
  1186.             }
  1187.             else if(param1 is IXMLSchemaInstance && IXMLSchemaInstance(param1).xsiType != null)
  1188.             {
  1189.                _loc2_ = IXMLSchemaInstance(param1).xsiType;
  1190.             }
  1191.          }
  1192.          return _loc2_;
  1193.       }
  1194.       
  1195.       public function hasValue(param1:*, param2:*) : Boolean
  1196.       {
  1197.          return getValue(param1,param2) !== undefined;
  1198.       }
  1199.       
  1200.       public function encodeAttributeGroup(param1:XML, param2:XML, param3:QName, param4:* = undefined, param5:XML = null) : void
  1201.       {
  1202.          var _loc6_:QName = null;
  1203.          var _loc8_:XML = null;
  1204.          var _loc9_:XMLList = null;
  1205.          var _loc10_:XML = null;
  1206.          var _loc11_:XML = null;
  1207.          if(param1.attribute("ref").length() == 1)
  1208.          {
  1209.             _loc6_ = schemaManager.getQNameForPrefixedName(param1.@ref,param1,true);
  1210.             param1 = schemaManager.getNamedDefinition(_loc6_,constants.attributeGroupQName);
  1211.             if(param1 == null)
  1212.             {
  1213.                throw new Error("Cannot resolve attributeGroup definition for \'" + _loc6_ + "\'");
  1214.             }
  1215.          }
  1216.          var _loc7_:XMLList = param1.elements(constants.attributeQName);
  1217.          for each(_loc8_ in _loc7_)
  1218.          {
  1219.             encodeAttribute(_loc8_,param2,param3,param4,param5);
  1220.          }
  1221.          _loc9_ = param1.elements(constants.attributeGroupQName);
  1222.          for each(_loc10_ in _loc9_)
  1223.          {
  1224.             encodeAttributeGroup(_loc10_,param2,param3,param4,param5);
  1225.          }
  1226.          _loc11_ = getSingleElementFromNode(param1,constants.anyAttributeQName);
  1227.          if(_loc11_ != null)
  1228.          {
  1229.             encodeAnyAttribute(_loc11_,param2,param3,param4,param5);
  1230.          }
  1231.          if(_loc6_ != null)
  1232.          {
  1233.             schemaManager.releaseScope();
  1234.          }
  1235.       }
  1236.       
  1237.       public function encodeSequence(param1:XML, param2:XMLList, param3:QName, param4:*, param5:Boolean = true) : Boolean
  1238.       {
  1239.          var _loc11_:XML = null;
  1240.          var _loc6_:uint = getMaxOccurs(param1);
  1241.          var _loc7_:uint = getMinOccurs(param1);
  1242.          if(_loc6_ == 0)
  1243.          {
  1244.             return true;
  1245.          }
  1246.          if(param4 == null && _loc7_ == 0)
  1247.          {
  1248.             return true;
  1249.          }
  1250.          var _loc8_:XMLList = param1.elements();
  1251.          var _loc9_:Boolean = param5 && _loc7_ > 0;
  1252.          var _loc10_:Boolean = true;
  1253.          for each(_loc11_ in _loc8_)
  1254.          {
  1255.             _loc10_ = false;
  1256.             if(_loc11_.name() == constants.elementTypeQName)
  1257.             {
  1258.                if(!encodeGroupElement(_loc11_,param2,param3,param4,param5))
  1259.                {
  1260.                   break;
  1261.                }
  1262.             }
  1263.             else if(_loc11_.name() == constants.groupQName)
  1264.             {
  1265.                if(!encodeGroupReference(_loc11_,param2,param3,param4,param5))
  1266.                {
  1267.                   break;
  1268.                }
  1269.             }
  1270.             else if(_loc11_.name() == constants.choiceQName)
  1271.             {
  1272.                if(!encodeChoice(_loc11_,param2,param3,param4,param5))
  1273.                {
  1274.                   break;
  1275.                }
  1276.             }
  1277.             else if(_loc11_.name() == constants.sequenceQName)
  1278.             {
  1279.                if(!encodeSequence(_loc11_,param2,param3,param4,param5))
  1280.                {
  1281.                   break;
  1282.                }
  1283.             }
  1284.             else if(_loc11_.name() == constants.anyQName)
  1285.             {
  1286.                if(!encodeAnyElement(_loc11_,param2,param3,param4,param5))
  1287.                {
  1288.                   break;
  1289.                }
  1290.             }
  1291.             _loc10_ = true;
  1292.          }
  1293.          return _loc10_ || !param5;
  1294.       }
  1295.    }
  1296. }
  1297.  
  1298.