home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / rpc / xml / SchemaMarshaller.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  42.0 KB  |  1,207 lines
  1. package mx.rpc.xml
  2. {
  3.    import flash.utils.ByteArray;
  4.    import mx.utils.Base64Decoder;
  5.    import mx.utils.Base64Encoder;
  6.    import mx.utils.HexDecoder;
  7.    import mx.utils.HexEncoder;
  8.    
  9.    public class SchemaMarshaller
  10.    {
  11.       public static var byteArrayAsBase64Binary:Boolean = true;
  12.       
  13.       public static var whitespaceReplacePattern:RegExp = /[\t\r\n]/g;
  14.       
  15.       public static var whitespaceCollapsePattern:RegExp = /[ \t\r\n]+/g;
  16.       
  17.       public static var whitespaceTrimPattern:RegExp = /^[ ]+|[ ]+$/g;
  18.       
  19.       public static const FLOAT_MAX_VALUE:Number = (Math.pow(2,24) - 1) * Math.pow(2,104);
  20.       
  21.       public static const FLOAT_MIN_VALUE:Number = Math.pow(2,-149);
  22.       
  23.       public static const LONG_MAX_VALUE:Number = 9223372036854776000;
  24.       
  25.       public static const LONG_MIN_VALUE:Number = -9223372036854776000;
  26.       
  27.       public static const SHORT_MAX_VALUE:Number = 32767;
  28.       
  29.       public static const SHORT_MIN_VALUE:Number = -32768;
  30.       
  31.       public static const BYTE_MAX_VALUE:Number = 127;
  32.       
  33.       public static const BYTE_MIN_VALUE:Number = -128;
  34.       
  35.       public static const ULONG_MAX_VALUE:Number = 18446744073709552000;
  36.       
  37.       public static const USHORT_MAX_VALUE:Number = 65535;
  38.       
  39.       public static const UBYTE_MAX_VALUE:Number = 255;
  40.       
  41.       private var unmarshallers:Object;
  42.       
  43.       private var constants:SchemaConstants;
  44.       
  45.       private var datatypes:SchemaDatatypes;
  46.       
  47.       private var marshallers:Object;
  48.       
  49.       private var _validating:Boolean;
  50.       
  51.       public function SchemaMarshaller(param1:SchemaConstants, param2:SchemaDatatypes)
  52.       {
  53.          super();
  54.          this.constants = param1;
  55.          this.datatypes = param2;
  56.          registerMarshallers();
  57.       }
  58.       
  59.       public static function guessSimpleType(param1:*) : *
  60.       {
  61.          var _loc2_:String = "string";
  62.          if(param1 is uint)
  63.          {
  64.             _loc2_ = "unsignedInt";
  65.          }
  66.          else if(param1 is int)
  67.          {
  68.             _loc2_ = "int";
  69.          }
  70.          else if(param1 is Number)
  71.          {
  72.             _loc2_ = "double";
  73.          }
  74.          else if(param1 is Boolean)
  75.          {
  76.             _loc2_ = "boolean";
  77.          }
  78.          else if(param1 is String)
  79.          {
  80.             _loc2_ = "string";
  81.          }
  82.          else if(param1 is ByteArray)
  83.          {
  84.             if(byteArrayAsBase64Binary)
  85.             {
  86.                _loc2_ = "base64Binary";
  87.             }
  88.             else
  89.             {
  90.                _loc2_ = "hexBinary";
  91.             }
  92.          }
  93.          else if(param1 is Date)
  94.          {
  95.             _loc2_ = "dateTime";
  96.          }
  97.          return _loc2_;
  98.       }
  99.       
  100.       private static function whitespaceCollapse(param1:*) : String
  101.       {
  102.          if(param1 == null)
  103.          {
  104.             return null;
  105.          }
  106.          var _loc2_:String = param1.toString();
  107.          _loc2_ = _loc2_.replace(whitespaceCollapsePattern," ");
  108.          return _loc2_.replace(whitespaceTrimPattern,"");
  109.       }
  110.       
  111.       private static function specialNumber(param1:Number) : String
  112.       {
  113.          if(param1 == Number.NEGATIVE_INFINITY)
  114.          {
  115.             return "-INF";
  116.          }
  117.          if(param1 == Number.POSITIVE_INFINITY)
  118.          {
  119.             return "INF";
  120.          }
  121.          if(isNaN(param1))
  122.          {
  123.             return "NaN";
  124.          }
  125.          return null;
  126.       }
  127.       
  128.       private static function whitespaceReplace(param1:*) : String
  129.       {
  130.          if(param1 == null)
  131.          {
  132.             return null;
  133.          }
  134.          var _loc2_:String = param1.toString();
  135.          return _loc2_.replace(whitespaceReplacePattern," ");
  136.       }
  137.       
  138.       public function unmarshallBoolean(param1:*, param2:QName = null, param3:XML = null) : Boolean
  139.       {
  140.          if(param1 == null)
  141.          {
  142.             return false;
  143.          }
  144.          var _loc4_:String = whitespaceCollapse(param1).toLowerCase();
  145.          if(_loc4_ == "true" || _loc4_ == "1")
  146.          {
  147.             return true;
  148.          }
  149.          return false;
  150.       }
  151.       
  152.       public function marshallDuration(param1:*, param2:QName = null, param3:XML = null) : String
  153.       {
  154.          return whitespaceCollapse(param1);
  155.       }
  156.       
  157.       private function registerMarshallers() : void
  158.       {
  159.          marshallers = {};
  160.          marshallers[datatypes.booleanQName.localName] = marshallBoolean;
  161.          marshallers[datatypes.anyTypeQName.localName] = marshallAny;
  162.          marshallers[datatypes.anySimpleTypeQName.localName] = marshallAny;
  163.          marshallers[datatypes.anyAtomicTypeQName.localName] = marshallAny;
  164.          marshallers[datatypes.stringQName.localName] = marshallString;
  165.          marshallers[datatypes.booleanQName.localName] = marshallBoolean;
  166.          marshallers[datatypes.decimalQName.localName] = marshallDecimal;
  167.          marshallers[datatypes.precisionDecimal.localName] = marshallDecimal;
  168.          marshallers[datatypes.floatQName.localName] = marshallFloat;
  169.          marshallers[datatypes.doubleQName.localName] = marshallDouble;
  170.          marshallers[datatypes.durationQName.localName] = marshallDuration;
  171.          marshallers[datatypes.dateTimeQName.localName] = marshallDatetime;
  172.          marshallers[datatypes.timeQName.localName] = marshallDatetime;
  173.          marshallers[datatypes.dateQName.localName] = marshallDatetime;
  174.          marshallers[datatypes.gYearMonthQName.localName] = marshallGregorian;
  175.          marshallers[datatypes.gYearQName.localName] = marshallGregorian;
  176.          marshallers[datatypes.gMonthDayQName.localName] = marshallGregorian;
  177.          marshallers[datatypes.gDayQName.localName] = marshallGregorian;
  178.          marshallers[datatypes.gMonthQName.localName] = marshallGregorian;
  179.          marshallers[datatypes.hexBinaryQName.localName] = marshallHexBinary;
  180.          marshallers[datatypes.base64BinaryQName.localName] = marshallBase64Binary;
  181.          marshallers[datatypes.anyURIQName.localName] = marshallString;
  182.          marshallers[datatypes.QNameQName.localName] = marshallString;
  183.          marshallers[datatypes.NOTATIONQName.localName] = marshallString;
  184.          marshallers[datatypes.normalizedStringQName.localName] = marshallString;
  185.          marshallers[datatypes.tokenQName.localName] = marshallString;
  186.          marshallers[datatypes.languageQName.localName] = marshallString;
  187.          marshallers[datatypes.NMTOKENQName.localName] = marshallString;
  188.          marshallers[datatypes.NMTOKENSQName.localName] = marshallString;
  189.          marshallers[datatypes.NameQName.localName] = marshallString;
  190.          marshallers[datatypes.NCNameQName.localName] = marshallString;
  191.          marshallers[datatypes.IDQName.localName] = marshallString;
  192.          marshallers[datatypes.IDREF.localName] = marshallString;
  193.          marshallers[datatypes.IDREFS.localName] = marshallString;
  194.          marshallers[datatypes.ENTITY.localName] = marshallString;
  195.          marshallers[datatypes.ENTITIES.localName] = marshallString;
  196.          marshallers[datatypes.integerQName.localName] = marshallInteger;
  197.          marshallers[datatypes.nonPositiveIntegerQName.localName] = marshallInteger;
  198.          marshallers[datatypes.negativeIntegerQName.localName] = marshallInteger;
  199.          marshallers[datatypes.longQName.localName] = marshallInteger;
  200.          marshallers[datatypes.intQName.localName] = marshallInteger;
  201.          marshallers[datatypes.shortQName.localName] = marshallInteger;
  202.          marshallers[datatypes.byteQName.localName] = marshallInteger;
  203.          marshallers[datatypes.nonNegativeIntegerQName.localName] = marshallInteger;
  204.          marshallers[datatypes.unsignedLongQName.localName] = marshallInteger;
  205.          marshallers[datatypes.unsignedIntQName.localName] = marshallInteger;
  206.          marshallers[datatypes.unsignedShortQName.localName] = marshallInteger;
  207.          marshallers[datatypes.unsignedByteQName.localName] = marshallInteger;
  208.          marshallers[datatypes.positiveIntegerQName.localName] = marshallInteger;
  209.          marshallers[datatypes.yearMonthDurationQName.localName] = marshallDatetime;
  210.          marshallers[datatypes.dayTimeDurationQName.localName] = marshallDatetime;
  211.          if(datatypes.timeInstantQName != null)
  212.          {
  213.             marshallers[datatypes.timeInstantQName.localName] = marshallDatetime;
  214.          }
  215.          unmarshallers = {};
  216.          unmarshallers[datatypes.booleanQName.localName] = unmarshallBoolean;
  217.          unmarshallers[datatypes.anyTypeQName.localName] = unmarshallAny;
  218.          unmarshallers[datatypes.anySimpleTypeQName.localName] = unmarshallAny;
  219.          unmarshallers[datatypes.anyAtomicTypeQName.localName] = unmarshallAny;
  220.          unmarshallers[datatypes.stringQName.localName] = unmarshallString;
  221.          unmarshallers[datatypes.booleanQName.localName] = unmarshallBoolean;
  222.          unmarshallers[datatypes.decimalQName.localName] = unmarshallDecimal;
  223.          unmarshallers[datatypes.precisionDecimal.localName] = unmarshallDecimal;
  224.          unmarshallers[datatypes.floatQName.localName] = unmarshallFloat;
  225.          unmarshallers[datatypes.doubleQName.localName] = unmarshallDouble;
  226.          unmarshallers[datatypes.durationQName.localName] = unmarshallDuration;
  227.          unmarshallers[datatypes.dateTimeQName.localName] = unmarshallDatetime;
  228.          unmarshallers[datatypes.timeQName.localName] = unmarshallDatetime;
  229.          unmarshallers[datatypes.dateQName.localName] = unmarshallDate;
  230.          unmarshallers[datatypes.gYearMonthQName.localName] = unmarshallGregorian;
  231.          unmarshallers[datatypes.gYearQName.localName] = unmarshallGregorian;
  232.          unmarshallers[datatypes.gMonthDayQName.localName] = unmarshallGregorian;
  233.          unmarshallers[datatypes.gDayQName.localName] = unmarshallGregorian;
  234.          unmarshallers[datatypes.gMonthQName.localName] = unmarshallGregorian;
  235.          unmarshallers[datatypes.hexBinaryQName.localName] = unmarshallHexBinary;
  236.          unmarshallers[datatypes.base64BinaryQName.localName] = unmarshallBase64Binary;
  237.          unmarshallers[datatypes.anyURIQName.localName] = unmarshallString;
  238.          unmarshallers[datatypes.QNameQName.localName] = unmarshallString;
  239.          unmarshallers[datatypes.NOTATIONQName.localName] = unmarshallString;
  240.          unmarshallers[datatypes.normalizedStringQName.localName] = unmarshallString;
  241.          unmarshallers[datatypes.tokenQName.localName] = unmarshallString;
  242.          unmarshallers[datatypes.languageQName.localName] = unmarshallString;
  243.          unmarshallers[datatypes.NMTOKENQName.localName] = unmarshallString;
  244.          unmarshallers[datatypes.NMTOKENSQName.localName] = unmarshallString;
  245.          unmarshallers[datatypes.NameQName.localName] = unmarshallString;
  246.          unmarshallers[datatypes.NCNameQName.localName] = unmarshallString;
  247.          unmarshallers[datatypes.IDQName.localName] = unmarshallString;
  248.          unmarshallers[datatypes.IDREF.localName] = unmarshallString;
  249.          unmarshallers[datatypes.IDREFS.localName] = unmarshallString;
  250.          unmarshallers[datatypes.ENTITY.localName] = unmarshallString;
  251.          unmarshallers[datatypes.ENTITIES.localName] = unmarshallString;
  252.          unmarshallers[datatypes.integerQName.localName] = unmarshallInteger;
  253.          unmarshallers[datatypes.nonPositiveIntegerQName.localName] = unmarshallInteger;
  254.          unmarshallers[datatypes.negativeIntegerQName.localName] = unmarshallInteger;
  255.          unmarshallers[datatypes.longQName.localName] = unmarshallInteger;
  256.          unmarshallers[datatypes.intQName.localName] = unmarshallInteger;
  257.          unmarshallers[datatypes.shortQName.localName] = unmarshallInteger;
  258.          unmarshallers[datatypes.byteQName.localName] = unmarshallInteger;
  259.          unmarshallers[datatypes.nonNegativeIntegerQName.localName] = unmarshallInteger;
  260.          unmarshallers[datatypes.unsignedLongQName.localName] = unmarshallInteger;
  261.          unmarshallers[datatypes.unsignedIntQName.localName] = unmarshallInteger;
  262.          unmarshallers[datatypes.unsignedShortQName.localName] = unmarshallInteger;
  263.          unmarshallers[datatypes.unsignedByteQName.localName] = unmarshallInteger;
  264.          unmarshallers[datatypes.positiveIntegerQName.localName] = unmarshallInteger;
  265.          unmarshallers[datatypes.yearMonthDurationQName.localName] = unmarshallDatetime;
  266.          unmarshallers[datatypes.dayTimeDurationQName.localName] = unmarshallDatetime;
  267.          if(datatypes.timeInstantQName != null)
  268.          {
  269.             unmarshallers[datatypes.timeInstantQName.localName] = unmarshallDatetime;
  270.          }
  271.       }
  272.       
  273.       public function unmarshallAny(param1:*, param2:QName = null, param3:XML = null) : *
  274.       {
  275.          var _loc4_:* = undefined;
  276.          var _loc5_:Function = null;
  277.          var _loc7_:String = null;
  278.          if(param1 === undefined)
  279.          {
  280.             return undefined;
  281.          }
  282.          if(param1 == null)
  283.          {
  284.             return null;
  285.          }
  286.          var _loc6_:String = whitespaceCollapse(param1);
  287.          if(_loc6_ == "")
  288.          {
  289.             _loc5_ = unmarshallers[datatypes.stringQName.localName];
  290.          }
  291.          else if(isNaN(Number(_loc6_)) || _loc6_.charAt(0) == "0" || _loc6_.charAt(0) == "-" && _loc6_.charAt(1) == "0" || _loc6_.charAt(_loc6_.length - 1) == "E")
  292.          {
  293.             _loc7_ = _loc6_.toLowerCase();
  294.             if(_loc7_ == "true" || _loc7_ == "false")
  295.             {
  296.                _loc5_ = unmarshallers[datatypes.booleanQName.localName];
  297.             }
  298.             else
  299.             {
  300.                _loc5_ = unmarshallers[datatypes.stringQName.localName];
  301.             }
  302.          }
  303.          else
  304.          {
  305.             _loc5_ = unmarshallers[datatypes.doubleQName.localName];
  306.          }
  307.          return _loc5_(param1,param2,param3);
  308.       }
  309.       
  310.       public function marshallDouble(param1:*, param2:QName = null, param3:XML = null) : String
  311.       {
  312.          var _loc4_:String = null;
  313.          var _loc5_:Number = Number(param1);
  314.          _loc4_ = specialNumber(_loc5_);
  315.          if(_loc4_ == null)
  316.          {
  317.             _loc4_ = _loc5_.toString();
  318.          }
  319.          return _loc4_;
  320.       }
  321.       
  322.       public function unmarshallDatetime(param1:*, param2:QName = null, param3:XML = null) : Object
  323.       {
  324.          var _loc4_:Date = null;
  325.          var _loc6_:String = null;
  326.          var _loc7_:String = null;
  327.          var _loc8_:Boolean = false;
  328.          var _loc9_:Boolean = false;
  329.          var _loc10_:int = 0;
  330.          var _loc17_:int = 0;
  331.          var _loc18_:Number = NaN;
  332.          var _loc20_:int = 0;
  333.          var _loc21_:int = 0;
  334.          var _loc22_:uint = 0;
  335.          var _loc23_:uint = 0;
  336.          var _loc24_:uint = 0;
  337.          var _loc25_:Date = null;
  338.          if(param1 == null)
  339.          {
  340.             return null;
  341.          }
  342.          var _loc5_:String = whitespaceCollapse(param1);
  343.          var _loc11_:int = int(_loc5_.indexOf("T"));
  344.          if(_loc11_ != -1)
  345.          {
  346.             _loc6_ = _loc5_.substring(0,_loc11_);
  347.             _loc7_ = _loc5_.substring(_loc11_ + 1);
  348.          }
  349.          else
  350.          {
  351.             _loc7_ = _loc5_;
  352.          }
  353.          var _loc12_:int = int(_loc7_.substring(0,2));
  354.          var _loc13_:int = int(_loc7_.substring(3,5));
  355.          var _loc14_:int = int(_loc7_.indexOf(".",6));
  356.          var _loc15_:int = int(_loc7_.substring(6,8));
  357.          var _loc16_:int = int(_loc7_.indexOf("Z",8));
  358.          if(_loc16_ == -1)
  359.          {
  360.             _loc16_ = int(_loc7_.indexOf("+",8));
  361.             if(_loc16_ != -1)
  362.             {
  363.                _loc17_ = 1;
  364.             }
  365.             else
  366.             {
  367.                _loc16_ = int(_loc7_.indexOf("-",8));
  368.                if(_loc16_ != -1)
  369.                {
  370.                   _loc17_ = -1;
  371.                }
  372.             }
  373.             if(_loc16_ != -1)
  374.             {
  375.                _loc10_ = _loc16_ + 1;
  376.                _loc20_ = int(_loc7_.substring(_loc10_,_loc10_ + 2));
  377.                _loc10_ += 3;
  378.                _loc21_ = int(_loc7_.substring(_loc10_,_loc10_ + 2));
  379.                _loc18_ = _loc20_ * 3600000 + _loc21_ * 60000;
  380.                _loc8_ = true;
  381.                _loc9_ = true;
  382.             }
  383.          }
  384.          else
  385.          {
  386.             _loc8_ = true;
  387.          }
  388.          var _loc19_:int = 0;
  389.          if(_loc14_ != -1)
  390.          {
  391.             if(_loc8_)
  392.             {
  393.                _loc19_ = int(_loc7_.substring(_loc14_ + 1,_loc16_));
  394.             }
  395.             else
  396.             {
  397.                _loc19_ = int(_loc7_.substring(_loc14_ + 1));
  398.             }
  399.          }
  400.          if(_loc6_ != null)
  401.          {
  402.             _loc10_ = int(_loc6_.indexOf("-",1));
  403.             _loc22_ = uint(_loc6_.substring(0,_loc10_++));
  404.             _loc23_ = uint(_loc6_.substring(_loc10_,_loc10_ + 2));
  405.             _loc10_ += 3;
  406.             _loc24_ = uint(_loc6_.substring(_loc10_,_loc10_ + 2));
  407.             if(_loc8_)
  408.             {
  409.                _loc4_ = new Date(Date.UTC(_loc22_,_loc23_ - 1,_loc24_));
  410.             }
  411.             else
  412.             {
  413.                _loc4_ = new Date(_loc22_,_loc23_ - 1,_loc24_);
  414.             }
  415.          }
  416.          else if(_loc8_)
  417.          {
  418.             _loc25_ = new Date();
  419.             _loc4_ = new Date(Date.UTC(_loc25_.fullYearUTC,_loc25_.monthUTC,_loc25_.dateUTC));
  420.          }
  421.          else
  422.          {
  423.             _loc4_ = new Date();
  424.          }
  425.          if(_loc8_)
  426.          {
  427.             _loc4_.setUTCHours(_loc12_,_loc13_,_loc15_,_loc19_);
  428.             if(_loc9_)
  429.             {
  430.                if(_loc17_ > 0)
  431.                {
  432.                   _loc4_.time -= _loc18_;
  433.                }
  434.                else
  435.                {
  436.                   _loc4_.time += _loc18_;
  437.                }
  438.             }
  439.          }
  440.          else
  441.          {
  442.             _loc4_.setHours(_loc12_,_loc13_,_loc15_,_loc19_);
  443.          }
  444.          return _loc4_;
  445.       }
  446.       
  447.       public function marshall(param1:*, param2:QName = null, param3:XML = null) : *
  448.       {
  449.          var _loc5_:* = undefined;
  450.          if(param2 == null)
  451.          {
  452.             param2 = datatypes.anyTypeQName;
  453.          }
  454.          var _loc4_:Function = marshallers[param2.localName];
  455.          if(_loc4_ != null)
  456.          {
  457.             return _loc4_(param1,param2,param3);
  458.          }
  459.          throw new TypeError("Cannot marshall type \'" + param2 + "\' to simple content.");
  460.       }
  461.       
  462.       public function marshallInteger(param1:*, param2:QName = null, param3:XML = null) : String
  463.       {
  464.          var _loc4_:String = null;
  465.          var _loc5_:Number = NaN;
  466.          if(param1 is Number)
  467.          {
  468.             _loc5_ = param1 as Number;
  469.          }
  470.          else
  471.          {
  472.             _loc5_ = Number(whitespaceCollapse(param1));
  473.          }
  474.          var _loc6_:Number = -Number.MAX_VALUE;
  475.          var _loc7_:Number = Number.MAX_VALUE;
  476.          if(param2 == datatypes.longQName)
  477.          {
  478.             _loc6_ = LONG_MIN_VALUE;
  479.             _loc7_ = LONG_MAX_VALUE;
  480.          }
  481.          else if(param2 == datatypes.intQName)
  482.          {
  483.             _loc6_ = int.MIN_VALUE;
  484.             _loc7_ = int.MAX_VALUE;
  485.          }
  486.          else if(param2 == datatypes.shortQName)
  487.          {
  488.             _loc6_ = SHORT_MIN_VALUE;
  489.             _loc7_ = SHORT_MAX_VALUE;
  490.          }
  491.          else if(param2 == datatypes.byteQName)
  492.          {
  493.             _loc6_ = BYTE_MIN_VALUE;
  494.             _loc7_ = BYTE_MAX_VALUE;
  495.          }
  496.          else if(param2 == datatypes.unsignedLongQName)
  497.          {
  498.             _loc6_ = 0;
  499.             _loc7_ = ULONG_MAX_VALUE;
  500.          }
  501.          else if(param2 == datatypes.unsignedIntQName)
  502.          {
  503.             _loc6_ = 0;
  504.             _loc7_ = uint.MAX_VALUE;
  505.          }
  506.          else if(param2 == datatypes.unsignedShortQName)
  507.          {
  508.             _loc6_ = 0;
  509.             _loc7_ = USHORT_MAX_VALUE;
  510.          }
  511.          else if(param2 == datatypes.unsignedByteQName)
  512.          {
  513.             _loc6_ = 0;
  514.             _loc7_ = UBYTE_MAX_VALUE;
  515.          }
  516.          else if(param2 == datatypes.positiveIntegerQName)
  517.          {
  518.             _loc6_ = 1;
  519.             _loc7_ = Number.MAX_VALUE;
  520.          }
  521.          else if(param2 == datatypes.nonNegativeIntegerQName)
  522.          {
  523.             _loc6_ = 0;
  524.             _loc7_ = Number.MAX_VALUE;
  525.          }
  526.          else if(param2 == datatypes.negativeIntegerQName)
  527.          {
  528.             _loc6_ = -Number.MAX_VALUE;
  529.             _loc7_ = -1;
  530.          }
  531.          else if(param2 == datatypes.nonPositiveIntegerQName)
  532.          {
  533.             _loc6_ = -Number.MAX_VALUE;
  534.             _loc7_ = 0;
  535.          }
  536.          else if(param2 == datatypes.integerQName)
  537.          {
  538.             _loc6_ = -Number.MAX_VALUE;
  539.             _loc7_ = Number.MAX_VALUE;
  540.          }
  541.          var _loc8_:Number = Math.floor(_loc5_);
  542.          if(_loc8_ >= _loc6_)
  543.          {
  544.             if(_loc8_ > _loc7_)
  545.             {
  546.                if(validating)
  547.                {
  548.                   throw new RangeError("The value \'" + param1 + "\' is too large for " + param2.localName);
  549.                }
  550.                return whitespaceCollapse(param1);
  551.             }
  552.             return _loc8_.toString();
  553.          }
  554.          if(validating)
  555.          {
  556.             throw new RangeError("The value \'" + param1 + "\' is too small for " + param2.localName);
  557.          }
  558.          return whitespaceCollapse(param1);
  559.       }
  560.       
  561.       public function get validating() : Boolean
  562.       {
  563.          return _validating;
  564.       }
  565.       
  566.       public function marshallHexBinary(param1:*, param2:QName = null, param3:XML = null) : String
  567.       {
  568.          var _loc5_:String = null;
  569.          var _loc6_:HexEncoder = null;
  570.          var _loc4_:ByteArray = param1 as ByteArray;
  571.          if(_loc4_ != null)
  572.          {
  573.             _loc6_ = new HexEncoder();
  574.             _loc6_.encode(_loc4_);
  575.             return _loc6_.drain();
  576.          }
  577.          throw new Error("Cannot marshall value as hex binary.");
  578.       }
  579.       
  580.       public function unmarshallGregorian(param1:*, param2:QName = null, param3:XML = null) : *
  581.       {
  582.          var _loc4_:String;
  583.          var _loc5_:* = _loc4_ = whitespaceCollapse(param1);
  584.          if(param2 == datatypes.gYearQName)
  585.          {
  586.             _loc5_ = uint(_loc4_.substring(0,4));
  587.          }
  588.          else if(param2 == datatypes.gMonthQName)
  589.          {
  590.             _loc5_ = uint(_loc4_.substring(2,4));
  591.          }
  592.          else if(param2 == datatypes.gDayQName)
  593.          {
  594.             _loc5_ = uint(_loc4_.substring(3,5));
  595.          }
  596.          return _loc5_;
  597.       }
  598.       
  599.       public function unmarshallDouble(param1:*, param2:QName = null, param3:XML = null) : Number
  600.       {
  601.          var _loc4_:Number = NaN;
  602.          var _loc5_:String = null;
  603.          if(param1 != null)
  604.          {
  605.             _loc5_ = whitespaceCollapse(param1);
  606.             if(_loc5_ == "INF")
  607.             {
  608.                _loc4_ = Number.POSITIVE_INFINITY;
  609.             }
  610.             else if(_loc5_ == "-INF")
  611.             {
  612.                _loc4_ = Number.NEGATIVE_INFINITY;
  613.             }
  614.             else
  615.             {
  616.                _loc4_ = Number(_loc5_);
  617.             }
  618.          }
  619.          return _loc4_;
  620.       }
  621.       
  622.       public function unmarshallDuration(param1:*, param2:QName = null, param3:XML = null) : *
  623.       {
  624.          return whitespaceCollapse(param1);
  625.       }
  626.       
  627.       public function unmarshallHexBinary(param1:*, param2:QName = null, param3:XML = null) : ByteArray
  628.       {
  629.          var _loc4_:String = null;
  630.          var _loc5_:HexDecoder = null;
  631.          if(param1 != null)
  632.          {
  633.             _loc4_ = whitespaceCollapse(param1);
  634.             _loc5_ = new HexDecoder();
  635.             _loc5_.decode(_loc4_);
  636.             return _loc5_.drain();
  637.          }
  638.          return null;
  639.       }
  640.       
  641.       public function marshallBase64Binary(param1:*, param2:QName = null, param3:XML = null) : String
  642.       {
  643.          var _loc5_:String = null;
  644.          var _loc6_:Base64Encoder = null;
  645.          var _loc4_:ByteArray = param1 as ByteArray;
  646.          if(_loc4_ != null)
  647.          {
  648.             _loc6_ = new Base64Encoder();
  649.             _loc6_.insertNewLines = false;
  650.             _loc6_.encodeBytes(_loc4_);
  651.             return _loc6_.drain();
  652.          }
  653.          return null;
  654.       }
  655.       
  656.       public function unmarshallString(param1:*, param2:QName = null, param3:XML = null) : String
  657.       {
  658.          var _loc4_:String = null;
  659.          if(param1 != null)
  660.          {
  661.             _loc4_ = param1.toString();
  662.          }
  663.          return _loc4_;
  664.       }
  665.       
  666.       public function marshallDecimal(param1:*, param2:QName = null, param3:XML = null) : String
  667.       {
  668.          var _loc4_:String = null;
  669.          var _loc5_:Number = NaN;
  670.          var _loc6_:String = null;
  671.          if(param1 is Number)
  672.          {
  673.             _loc5_ = param1 as Number;
  674.          }
  675.          else
  676.          {
  677.             _loc6_ = whitespaceCollapse(param1);
  678.             _loc5_ = Number(_loc6_);
  679.          }
  680.          _loc4_ = specialNumber(_loc5_);
  681.          if(_loc4_ != null)
  682.          {
  683.             if(validating)
  684.             {
  685.                throw new Error("Invalid decimal value \'" + param1 + "\'.");
  686.             }
  687.             _loc4_ = whitespaceCollapse(param1);
  688.          }
  689.          else
  690.          {
  691.             _loc4_ = _loc5_.toString();
  692.          }
  693.          return _loc4_;
  694.       }
  695.       
  696.       public function set validating(param1:Boolean) : void
  697.       {
  698.          _validating = param1;
  699.       }
  700.       
  701.       public function unmarshall(param1:*, param2:QName = null, param3:XML = null) : *
  702.       {
  703.          var _loc4_:String = null;
  704.          var _loc6_:XML = null;
  705.          var _loc7_:String = null;
  706.          var _loc8_:XMLList = null;
  707.          if(param1 is XML)
  708.          {
  709.             _loc6_ = param1 as XML;
  710.             if(_loc6_.nodeKind() == "element")
  711.             {
  712.                _loc7_ = _loc6_.attribute(constants.nilQName).toString();
  713.                if(_loc7_ == "true")
  714.                {
  715.                   _loc4_ = null;
  716.                }
  717.                else
  718.                {
  719.                   _loc4_ = _loc6_.text().toString();
  720.                }
  721.             }
  722.             else
  723.             {
  724.                _loc4_ = _loc6_.toString();
  725.             }
  726.          }
  727.          else if(param1 is XMLList)
  728.          {
  729.             _loc8_ = param1 as XMLList;
  730.             _loc4_ = _loc8_.text().toString();
  731.          }
  732.          else if(param1 != null)
  733.          {
  734.             _loc4_ = param1.toString();
  735.          }
  736.          if(param2 == null)
  737.          {
  738.             param2 = datatypes.anyTypeQName;
  739.          }
  740.          var _loc5_:Function = unmarshallers[param2.localName];
  741.          if(_loc5_ != null)
  742.          {
  743.             return _loc5_(_loc4_,param2,param3);
  744.          }
  745.          throw new TypeError("Cannot unmarshall type \'" + param2 + "\' from XML.");
  746.       }
  747.       
  748.       public function marshallDatetime(param1:*, param2:QName = null, param3:XML = null) : String
  749.       {
  750.          var _loc4_:String = null;
  751.          var _loc5_:Date = null;
  752.          var _loc6_:Number = NaN;
  753.          if(param1 is Number)
  754.          {
  755.             _loc5_ = new Date();
  756.             _loc5_.time = param1 as Number;
  757.             param1 = _loc5_;
  758.          }
  759.          if(param1 is Date)
  760.          {
  761.             _loc5_ = param1 as Date;
  762.             _loc4_ = "";
  763.             if(param2 == datatypes.dateTimeQName || param2 == datatypes.dateQName)
  764.             {
  765.                _loc4_ = _loc4_.concat(_loc5_.getUTCFullYear(),"-");
  766.                _loc6_ = _loc5_.getUTCMonth() + 1;
  767.                if(_loc6_ < 10)
  768.                {
  769.                   _loc4_ = _loc4_.concat("0");
  770.                }
  771.                _loc4_ = _loc4_.concat(_loc6_,"-");
  772.                _loc6_ = Number(_loc5_.getUTCDate());
  773.                if(_loc6_ < 10)
  774.                {
  775.                   _loc4_ = _loc4_.concat("0");
  776.                }
  777.                _loc4_ = _loc4_.concat(_loc6_);
  778.             }
  779.             if(param2 == datatypes.dateTimeQName)
  780.             {
  781.                _loc4_ = _loc4_.concat("T");
  782.             }
  783.             if(param2 == datatypes.dateTimeQName || param2 == datatypes.timeQName)
  784.             {
  785.                _loc6_ = Number(_loc5_.getUTCHours());
  786.                if(_loc6_ < 10)
  787.                {
  788.                   _loc4_ = _loc4_.concat("0");
  789.                }
  790.                _loc4_ = _loc4_.concat(_loc6_,":");
  791.                _loc6_ = Number(_loc5_.getUTCMinutes());
  792.                if(_loc6_ < 10)
  793.                {
  794.                   _loc4_ = _loc4_.concat("0");
  795.                }
  796.                _loc4_ = _loc4_.concat(_loc6_,":");
  797.                _loc6_ = Number(_loc5_.getUTCSeconds());
  798.                if(_loc6_ < 10)
  799.                {
  800.                   _loc4_ = _loc4_.concat("0");
  801.                }
  802.                _loc4_ = _loc4_.concat(_loc6_);
  803.                _loc6_ = Number(_loc5_.getUTCMilliseconds());
  804.                if(_loc6_ > 0)
  805.                {
  806.                   _loc4_ = _loc4_.concat(".");
  807.                   if(_loc6_ < 10)
  808.                   {
  809.                      _loc4_ = _loc4_.concat("00");
  810.                   }
  811.                   else if(_loc6_ < 100)
  812.                   {
  813.                      _loc4_ = _loc4_.concat("0");
  814.                   }
  815.                   _loc4_ = _loc4_.concat(_loc6_);
  816.                }
  817.             }
  818.             _loc4_ = _loc4_.concat("Z");
  819.          }
  820.          else if(param1 is String)
  821.          {
  822.             _loc4_ = param1 as String;
  823.          }
  824.          return _loc4_;
  825.       }
  826.       
  827.       public function unmarshallDecimal(param1:*, param2:QName = null, param3:XML = null) : Number
  828.       {
  829.          return unmarshallDouble(param1,param2);
  830.       }
  831.       
  832.       public function marshallFloat(param1:*, param2:QName = null, param3:XML = null) : String
  833.       {
  834.          var _loc4_:String = null;
  835.          var _loc5_:Number = NaN;
  836.          var _loc6_:String = null;
  837.          if(param1 is Number)
  838.          {
  839.             _loc5_ = param1 as Number;
  840.          }
  841.          else
  842.          {
  843.             _loc6_ = whitespaceCollapse(param1);
  844.             _loc5_ = Number(_loc6_);
  845.          }
  846.          _loc4_ = specialNumber(_loc5_);
  847.          if(_loc4_ == null)
  848.          {
  849.             if(validating)
  850.             {
  851.                if(_loc5_ > 0)
  852.                {
  853.                   if(_loc5_ > FLOAT_MAX_VALUE)
  854.                   {
  855.                      throw new RangeError("The value \'" + param1 + "\' is too large for a single-precision floating point value.");
  856.                   }
  857.                   if(_loc5_ < FLOAT_MIN_VALUE)
  858.                   {
  859.                      throw new RangeError("The value \'" + param1 + "\' is too small for a single-precision floating point value.");
  860.                   }
  861.                }
  862.                else
  863.                {
  864.                   if(-_loc5_ > FLOAT_MAX_VALUE)
  865.                   {
  866.                      throw new RangeError("The absolute value of \'" + param1 + "\' is too large for a single-precision floating point value.");
  867.                   }
  868.                   if(-_loc5_ < FLOAT_MIN_VALUE)
  869.                   {
  870.                      throw new RangeError("The absolute value of \'" + param1 + "\' is too small for a single-precision floating point value.");
  871.                   }
  872.                }
  873.             }
  874.             _loc4_ = _loc5_.toString();
  875.          }
  876.          return _loc4_;
  877.       }
  878.       
  879.       public function unmarshallInteger(param1:*, param2:QName = null, param3:XML = null) : Number
  880.       {
  881.          return parseInt(param1);
  882.       }
  883.       
  884.       public function unmarshallDate(param1:*, param2:QName = null, param3:XML = null) : Object
  885.       {
  886.          var _loc4_:Date = null;
  887.          var _loc5_:int = 0;
  888.          var _loc7_:uint = 0;
  889.          var _loc8_:uint = 0;
  890.          var _loc9_:uint = 0;
  891.          var _loc10_:String = null;
  892.          var _loc11_:int = 0;
  893.          var _loc12_:int = 0;
  894.          var _loc13_:Number = NaN;
  895.          if(param1 == null)
  896.          {
  897.             return null;
  898.          }
  899.          var _loc6_:String = whitespaceCollapse(param1);
  900.          if(_loc6_ != null)
  901.          {
  902.             _loc5_ = int(_loc6_.indexOf("-",1));
  903.             _loc7_ = uint(_loc6_.substring(0,_loc5_++));
  904.             _loc8_ = uint(_loc6_.substring(_loc5_,_loc5_ + 2));
  905.             _loc5_ += 3;
  906.             _loc9_ = uint(_loc6_.substring(_loc5_,_loc5_ + 2));
  907.             _loc5_ += 2;
  908.             if(_loc6_.charAt(_loc5_) == "Z")
  909.             {
  910.                _loc4_ = new Date(Date.UTC(_loc7_,_loc8_ - 1,_loc9_));
  911.             }
  912.             else if(_loc6_.length > 10)
  913.             {
  914.                _loc4_ = new Date(Date.UTC(_loc7_,_loc8_ - 1,_loc9_));
  915.                _loc10_ = _loc6_.charAt(_loc5_++);
  916.                _loc11_ = int(_loc6_.substring(_loc5_,_loc5_ + 2));
  917.                _loc5_ += 3;
  918.                _loc12_ = int(_loc6_.substring(_loc5_,_loc5_ + 2));
  919.                _loc13_ = _loc11_ * 3600000 + _loc12_ * 60000;
  920.                if(_loc10_ == "+")
  921.                {
  922.                   _loc4_.time -= _loc13_;
  923.                }
  924.                else
  925.                {
  926.                   _loc4_.time += _loc13_;
  927.                }
  928.             }
  929.             else
  930.             {
  931.                _loc4_ = new Date(_loc7_,_loc8_ - 1,_loc9_);
  932.             }
  933.          }
  934.          return _loc4_;
  935.       }
  936.       
  937.       public function unmarshallBase64Binary(param1:*, param2:QName = null, param3:XML = null) : ByteArray
  938.       {
  939.          if(param1 == null)
  940.          {
  941.             return null;
  942.          }
  943.          var _loc4_:String = whitespaceCollapse(param1);
  944.          var _loc5_:Base64Decoder = new Base64Decoder();
  945.          _loc5_.decode(_loc4_);
  946.          return _loc5_.drain();
  947.       }
  948.       
  949.       public function marshallGregorian(param1:*, param2:QName = null, param3:XML = null) : String
  950.       {
  951.          var _loc4_:Date = null;
  952.          var _loc5_:Number = NaN;
  953.          var _loc7_:int = 0;
  954.          var _loc8_:String = null;
  955.          var _loc9_:String = null;
  956.          var _loc10_:String = null;
  957.          if(param1 is Date)
  958.          {
  959.             _loc4_ = param1 as Date;
  960.          }
  961.          else if(param1 is Number)
  962.          {
  963.             _loc5_ = param1 as Number;
  964.          }
  965.          else
  966.          {
  967.             param1 = whitespaceCollapse(param1);
  968.          }
  969.          var _loc6_:String = "";
  970.          if(param2 == datatypes.gYearMonthQName || param2 == datatypes.gYearQName)
  971.          {
  972.             if(param1 is Date)
  973.             {
  974.                _loc5_ = Number(_loc4_.getUTCFullYear());
  975.             }
  976.             else if(param1 is String)
  977.             {
  978.                _loc8_ = param1 as String;
  979.                _loc7_ = int(_loc8_.indexOf("-",1));
  980.                if(_loc7_ > 0)
  981.                {
  982.                   _loc8_ = _loc8_.substring(0,_loc7_);
  983.                }
  984.                _loc5_ = parseInt(_loc8_);
  985.             }
  986.             if(isNaN(_loc5_) || _loc5_ == 0)
  987.             {
  988.                if(validating)
  989.                {
  990.                   throw new Error("Invalid year supplied for type " + param2.localName + " in value " + param1);
  991.                }
  992.                return whitespaceCollapse(param1);
  993.             }
  994.             _loc8_ = _loc5_.toFixed(0);
  995.             if(_loc8_.indexOf("-") == 0)
  996.             {
  997.                while(_loc8_.length < 5)
  998.                {
  999.                   _loc8_ = _loc8_.substring(0,1) + "0" + _loc8_.substring(1);
  1000.                }
  1001.             }
  1002.             else
  1003.             {
  1004.                while(_loc8_.length < 4)
  1005.                {
  1006.                   _loc8_ = "0" + _loc8_;
  1007.                }
  1008.             }
  1009.             _loc6_ = _loc6_.concat(_loc8_);
  1010.             if(param2 != datatypes.gYearQName)
  1011.             {
  1012.                _loc6_ = _loc6_.concat("-");
  1013.             }
  1014.          }
  1015.          if(param2 == datatypes.gYearMonthQName || param2 == datatypes.gMonthDayQName || param2 == datatypes.gMonthQName)
  1016.          {
  1017.             if(param2 != datatypes.gYearMonthQName)
  1018.             {
  1019.                _loc6_ = _loc6_.concat("--");
  1020.             }
  1021.             if(param1 is Date)
  1022.             {
  1023.                _loc5_ = _loc4_.getUTCMonth() + 1;
  1024.             }
  1025.             else
  1026.             {
  1027.                _loc9_ = param1.toString();
  1028.                if(param2 == datatypes.gMonthDayQName)
  1029.                {
  1030.                   _loc7_ = int(_loc9_.indexOf("--",0));
  1031.                   if(_loc7_ != 0)
  1032.                   {
  1033.                      if(validating)
  1034.                      {
  1035.                         throw new Error("Invalid month supplied for " + param2.localName + " in value " + param1 + ". The format must be \'--MM-DD\'.");
  1036.                      }
  1037.                      return whitespaceCollapse(param1);
  1038.                   }
  1039.                   _loc9_ = _loc9_.substring(2,4);
  1040.                }
  1041.                else if(param2 == datatypes.gYearMonthQName)
  1042.                {
  1043.                   _loc7_ = int(_loc9_.indexOf("-",1));
  1044.                   if(_loc7_ <= 0)
  1045.                   {
  1046.                      if(validating)
  1047.                      {
  1048.                         throw new Error("Invalid month supplied for " + param2.localName + " in value " + param1 + ". The format must be \'--CCYY-MM\'.");
  1049.                      }
  1050.                      return whitespaceCollapse(param1);
  1051.                   }
  1052.                   _loc9_ = _loc9_.substring(_loc7_ + 1,_loc7_ + 3);
  1053.                }
  1054.                else
  1055.                {
  1056.                   _loc7_ = int(_loc9_.indexOf("--",0));
  1057.                   if(_loc7_ > 0)
  1058.                   {
  1059.                      _loc9_ = _loc9_.substring(2,4);
  1060.                   }
  1061.                }
  1062.                _loc5_ = parseInt(_loc9_);
  1063.             }
  1064.             if(isNaN(_loc5_) || _loc5_ <= 0 || _loc5_ > 12)
  1065.             {
  1066.                if(validating)
  1067.                {
  1068.                   throw new Error("Invalid month supplied for type " + param2.localName + " in value " + param1);
  1069.                }
  1070.                return whitespaceCollapse(param1);
  1071.             }
  1072.             _loc5_ = int(_loc5_);
  1073.             if(_loc5_ < 10)
  1074.             {
  1075.                _loc6_ = _loc6_.concat("0");
  1076.             }
  1077.             _loc6_ = _loc6_.concat(_loc5_);
  1078.             if(param2 == datatypes.gMonthDayQName)
  1079.             {
  1080.                _loc6_ = _loc6_.concat("-");
  1081.             }
  1082.          }
  1083.          if(param2 == datatypes.gMonthDayQName || param2 == datatypes.gDayQName)
  1084.          {
  1085.             if(param2 == datatypes.gDayQName)
  1086.             {
  1087.                _loc6_ = _loc6_.concat("---");
  1088.             }
  1089.             if(param1 is Date)
  1090.             {
  1091.                _loc5_ = Number(_loc4_.getUTCDate());
  1092.             }
  1093.             else if(param1 is String)
  1094.             {
  1095.                _loc10_ = param1 as String;
  1096.                if(param2 == datatypes.gMonthDayQName)
  1097.                {
  1098.                   _loc7_ = int(_loc10_.indexOf("--",0));
  1099.                   if(_loc7_ != 0)
  1100.                   {
  1101.                      if(validating)
  1102.                      {
  1103.                         throw new Error("Invalid day supplied for gMonthDay in value " + param1 + ". The format must be \'--MM-DD\'.");
  1104.                      }
  1105.                      return whitespaceCollapse(param1);
  1106.                   }
  1107.                   _loc10_ = _loc10_.substring(5,7);
  1108.                }
  1109.                else
  1110.                {
  1111.                   _loc7_ = int(_loc10_.indexOf("---",0));
  1112.                   if(_loc7_ == 0)
  1113.                   {
  1114.                      _loc10_ = _loc10_.substring(3,5);
  1115.                   }
  1116.                }
  1117.                _loc5_ = parseInt(_loc10_);
  1118.             }
  1119.             if(isNaN(_loc5_) || _loc5_ <= 0 || _loc5_ > 31)
  1120.             {
  1121.                if(validating)
  1122.                {
  1123.                   throw new Error("Invalid day supplied for type " + param2.localName + " in value " + param1);
  1124.                }
  1125.                return whitespaceCollapse(param1);
  1126.             }
  1127.             _loc5_ = int(_loc5_);
  1128.             if(_loc5_ < 10)
  1129.             {
  1130.                _loc6_ = _loc6_.concat("0");
  1131.             }
  1132.             _loc6_ = _loc6_.concat(_loc5_);
  1133.          }
  1134.          return _loc6_;
  1135.       }
  1136.       
  1137.       public function marshallBoolean(param1:*, param2:QName = null, param3:XML = null) : String
  1138.       {
  1139.          var _loc4_:String = null;
  1140.          var _loc5_:String = null;
  1141.          if(param1 != null)
  1142.          {
  1143.             if(param1 is Boolean)
  1144.             {
  1145.                _loc4_ = param1 as Boolean ? "true" : "false";
  1146.             }
  1147.             else if(param1 is Number)
  1148.             {
  1149.                _loc4_ = param1 == 1 ? "true" : "false";
  1150.             }
  1151.             else if(param1 is Object)
  1152.             {
  1153.                _loc5_ = Object(param1).toString();
  1154.                if(!(_loc5_ == "true" || _loc5_ == "false" || _loc5_ == "1" || _loc5_ == "0"))
  1155.                {
  1156.                   throw new Error("String \'" + param1 + "\' is not a Boolean.");
  1157.                }
  1158.                _loc4_ = _loc5_;
  1159.             }
  1160.          }
  1161.          return _loc4_;
  1162.       }
  1163.       
  1164.       public function unmarshallFloat(param1:*, param2:QName = null, param3:XML = null) : Number
  1165.       {
  1166.          return unmarshallDouble(param1,param2,param3);
  1167.       }
  1168.       
  1169.       public function marshallAny(param1:*, param2:QName = null, param3:XML = null) : *
  1170.       {
  1171.          if(param1 === undefined)
  1172.          {
  1173.             return undefined;
  1174.          }
  1175.          if(param1 == null)
  1176.          {
  1177.             return null;
  1178.          }
  1179.          var _loc4_:String = guessSimpleType(param1);
  1180.          if(param2 != null)
  1181.          {
  1182.             param2 = new QName(param2.uri,_loc4_);
  1183.          }
  1184.          else
  1185.          {
  1186.             param2 = new QName(constants.xsdURI,_loc4_);
  1187.          }
  1188.          var _loc5_:Function = marshallers[param2.localName];
  1189.          if(_loc5_ != null)
  1190.          {
  1191.             return _loc5_(param1,param2);
  1192.          }
  1193.          throw new TypeError("Cannot marshall type \'" + param2 + "\' to simple content.");
  1194.       }
  1195.       
  1196.       public function marshallString(param1:*, param2:QName = null, param3:XML = null) : String
  1197.       {
  1198.          if(param1 != null && param1 is Object)
  1199.          {
  1200.             return Object(param1).toString();
  1201.          }
  1202.          return null;
  1203.       }
  1204.    }
  1205. }
  1206.  
  1207.