home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / rpc / xml / SchemaManager.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  9.6 KB  |  349 lines
  1. package mx.rpc.xml
  2. {
  3.    public class SchemaManager extends QualifiedResourceManager
  4.    {
  5.       private var _namespaces:Object;
  6.       
  7.       private var _schemaMarshaller:SchemaMarshaller;
  8.       
  9.       private var _schemaConstants:SchemaConstants;
  10.       
  11.       private var namespaceCount:uint = 0;
  12.       
  13.       private var schemaStack:Array;
  14.       
  15.       private var initialScope:*;
  16.       
  17.       private var _schemaDatatypes:SchemaDatatypes;
  18.       
  19.       public function SchemaManager()
  20.       {
  21.          super();
  22.          initialScope = [];
  23.          schemaStack = [];
  24.       }
  25.       
  26.       public function addNamespaces(param1:Object) : void
  27.       {
  28.          var _loc2_:String = null;
  29.          var _loc3_:Namespace = null;
  30.          for(_loc2_ in param1)
  31.          {
  32.             _loc3_ = param1[_loc2_] as Namespace;
  33.             namespaces[_loc2_] = _loc3_;
  34.          }
  35.       }
  36.       
  37.       public function getNamedDefinition(param1:QName, ... rest) : XML
  38.       {
  39.          var _loc5_:Schema = null;
  40.          var _loc6_:Object = null;
  41.          var _loc7_:XML = null;
  42.          var _loc3_:Array = currentScope();
  43.          var _loc4_:int = 0;
  44.          while(_loc4_ < _loc3_.length)
  45.          {
  46.             _loc5_ = _loc3_[_loc4_];
  47.             rest.unshift(param1);
  48.             _loc6_ = _loc5_.getNamedDefinition.apply(_loc5_,rest);
  49.             if(_loc6_ != null)
  50.             {
  51.                _loc7_ = _loc6_.definition as XML;
  52.                pushSchemaInScope(_loc6_.schema);
  53.                return _loc7_;
  54.             }
  55.             _loc4_++;
  56.          }
  57.          return null;
  58.       }
  59.       
  60.       public function releaseScope() : *
  61.       {
  62.          return schemaStack.pop();
  63.       }
  64.       
  65.       public function marshall(param1:*, param2:QName = null, param3:XML = null) : String
  66.       {
  67.          return schemaMarshaller.marshall(param1,param2,param3);
  68.       }
  69.       
  70.       public function reset() : void
  71.       {
  72.          namespaceCount = 0;
  73.          schemaStack = [];
  74.          schemaStack.push(initialScope);
  75.       }
  76.       
  77.       public function pushSchemaInScope(param1:Schema) : void
  78.       {
  79.          var _loc2_:Array = null;
  80.          if(param1 != null)
  81.          {
  82.             _loc2_ = [param1];
  83.             _loc2_["current"] = _loc2_[0];
  84.             schemaStack.push(_loc2_);
  85.          }
  86.       }
  87.       
  88.       public function pushNamespaceInScope(param1:*) : Boolean
  89.       {
  90.          var _loc5_:Schema = null;
  91.          var _loc2_:Namespace = new Namespace(param1);
  92.          var _loc3_:Array = currentScope();
  93.          var _loc4_:int = 0;
  94.          while(_loc4_ < _loc3_.length)
  95.          {
  96.             _loc5_ = _loc3_[_loc4_];
  97.             if(_loc5_.targetNamespace.uri == _loc2_.uri)
  98.             {
  99.                pushSchemaInScope(_loc5_);
  100.                return true;
  101.             }
  102.             _loc4_++;
  103.          }
  104.          return false;
  105.       }
  106.       
  107.       public function getQNameForAttribute(param1:String, param2:String = null) : QName
  108.       {
  109.          var _loc3_:QName = null;
  110.          if(param2 == "qualified" || param2 == null && currentSchema.attributeFormDefault == "qualified")
  111.          {
  112.             _loc3_ = new QName(currentSchema.targetNamespace.uri,param1);
  113.          }
  114.          else
  115.          {
  116.             _loc3_ = new QName("",param1);
  117.          }
  118.          return _loc3_;
  119.       }
  120.       
  121.       public function currentScope() : Array
  122.       {
  123.          var _loc1_:Array = schemaStack.pop();
  124.          if(_loc1_ != null)
  125.          {
  126.             schemaStack.push(_loc1_);
  127.          }
  128.          else
  129.          {
  130.             _loc1_ = [];
  131.          }
  132.          return _loc1_;
  133.       }
  134.       
  135.       public function set schemaConstants(param1:SchemaConstants) : void
  136.       {
  137.          _schemaConstants = param1;
  138.       }
  139.       
  140.       public function addSchema(param1:Schema, param2:Boolean = true) : void
  141.       {
  142.          var _loc3_:Array = null;
  143.          addResource(param1.targetNamespace,param1);
  144.          if(param2 == true)
  145.          {
  146.             _loc3_ = schemaStack.pop();
  147.          }
  148.          if(_loc3_ == null)
  149.          {
  150.             _loc3_ = [];
  151.          }
  152.          _loc3_.push(param1);
  153.          if(!_loc3_.hasOwnProperty("current"))
  154.          {
  155.             _loc3_["current"] = _loc3_[0];
  156.          }
  157.          schemaStack.push(_loc3_);
  158.          if(schemaStack.length == 1)
  159.          {
  160.             initialScope = schemaStack[0];
  161.          }
  162.       }
  163.       
  164.       public function getOrCreatePrefix(param1:String) : String
  165.       {
  166.          var _loc2_:String = null;
  167.          var _loc3_:Namespace = null;
  168.          var _loc5_:Namespace = null;
  169.          var _loc7_:Object = null;
  170.          for each(_loc3_ in namespaces)
  171.          {
  172.             if(_loc3_.uri == param1)
  173.             {
  174.                return _loc3_.prefix;
  175.             }
  176.          }
  177.          if(currentSchema != null)
  178.          {
  179.             _loc7_ = currentSchema.namespaces;
  180.             for each(_loc3_ in _loc7_)
  181.             {
  182.                if(_loc3_.uri == param1)
  183.                {
  184.                   return _loc3_.prefix;
  185.                }
  186.             }
  187.          }
  188.          var _loc4_:String = "ns";
  189.          var _loc6_:String = _loc4_ + namespaceCount;
  190.          if(namespaces[_loc6_] != null)
  191.          {
  192.             ++namespaceCount;
  193.             _loc6_ = _loc4_ + namespaceCount;
  194.             _loc5_ = new Namespace(_loc6_,param1);
  195.             namespaces[_loc6_] = _loc5_;
  196.             return _loc6_;
  197.          }
  198.          _loc5_ = new Namespace(_loc6_,param1);
  199.          namespaces[_loc6_] = _loc5_;
  200.          return _loc6_;
  201.       }
  202.       
  203.       public function unmarshall(param1:*, param2:QName = null, param3:XML = null) : *
  204.       {
  205.          return schemaMarshaller.unmarshall(param1,param2,param3);
  206.       }
  207.       
  208.       public function set namespaces(param1:Object) : void
  209.       {
  210.          _namespaces = param1;
  211.       }
  212.       
  213.       public function get schemaDatatypes() : SchemaDatatypes
  214.       {
  215.          if(_schemaDatatypes == null)
  216.          {
  217.             _schemaDatatypes = SchemaDatatypes.getConstants(schemaConstants.xsdURI);
  218.          }
  219.          return _schemaDatatypes;
  220.       }
  221.       
  222.       public function get namespaces() : Object
  223.       {
  224.          if(_namespaces == null)
  225.          {
  226.             _namespaces = {};
  227.          }
  228.          return _namespaces;
  229.       }
  230.       
  231.       public function getQNameForElement(param1:String, param2:String = null) : QName
  232.       {
  233.          var _loc3_:QName = null;
  234.          if(param2 == "qualified" || (param2 == null || param2 == "") && currentSchema.elementFormDefault == "qualified")
  235.          {
  236.             _loc3_ = new QName(currentSchema.targetNamespace.uri,param1);
  237.          }
  238.          else
  239.          {
  240.             _loc3_ = new QName("",param1);
  241.          }
  242.          return _loc3_;
  243.       }
  244.       
  245.       public function get currentSchema() : Schema
  246.       {
  247.          var _loc1_:Schema = null;
  248.          var _loc2_:Array = currentScope();
  249.          if(_loc2_.hasOwnProperty("current"))
  250.          {
  251.             _loc1_ = _loc2_["current"];
  252.          }
  253.          return _loc1_;
  254.       }
  255.       
  256.       public function get schemaMarshaller() : SchemaMarshaller
  257.       {
  258.          if(_schemaMarshaller == null)
  259.          {
  260.             _schemaMarshaller = new SchemaMarshaller(schemaConstants,schemaDatatypes);
  261.          }
  262.          return _schemaMarshaller;
  263.       }
  264.       
  265.       public function get schemaConstants() : SchemaConstants
  266.       {
  267.          if(_schemaConstants == null)
  268.          {
  269.             _schemaConstants = SchemaConstants.getConstants();
  270.          }
  271.          return _schemaConstants;
  272.       }
  273.       
  274.       public function getQNameForPrefixedName(param1:String, param2:XML = null, param3:Boolean = false) : QName
  275.       {
  276.          var _loc4_:QName = null;
  277.          var _loc5_:String = null;
  278.          var _loc6_:String = null;
  279.          var _loc8_:Namespace = null;
  280.          var _loc9_:Array = null;
  281.          var _loc10_:Namespace = null;
  282.          var _loc11_:Namespace = null;
  283.          var _loc7_:int = int(param1.indexOf(":"));
  284.          if(_loc7_ > 0)
  285.          {
  286.             _loc5_ = param1.substr(0,_loc7_);
  287.             _loc6_ = param1.substr(_loc7_ + 1);
  288.          }
  289.          else
  290.          {
  291.             _loc6_ = param1;
  292.          }
  293.          if(_loc5_ == null && param3 == true)
  294.          {
  295.             _loc8_ = currentSchema.targetNamespace;
  296.          }
  297.          if(_loc5_ == null)
  298.          {
  299.             _loc5_ = "";
  300.          }
  301.          if(_loc8_ == null)
  302.          {
  303.             if(param2 != null)
  304.             {
  305.                _loc9_ = param2.inScopeNamespaces();
  306.                for each(_loc10_ in _loc9_)
  307.                {
  308.                   if(_loc10_.prefix == _loc5_)
  309.                   {
  310.                      _loc8_ = _loc10_;
  311.                      break;
  312.                   }
  313.                }
  314.             }
  315.          }
  316.          if(_loc8_ == null)
  317.          {
  318.             _loc8_ = namespaces[_loc5_];
  319.          }
  320.          if(_loc8_ == null)
  321.          {
  322.             _loc8_ = currentSchema.namespaces[_loc5_];
  323.          }
  324.          if(_loc8_ == null)
  325.          {
  326.             _loc11_ = param2 != null ? param2.namespace() : null;
  327.             if(_loc11_ != null && _loc11_.prefix == "")
  328.             {
  329.                _loc8_ = _loc11_;
  330.             }
  331.             else
  332.             {
  333.                _loc8_ = currentSchema.targetNamespace;
  334.             }
  335.          }
  336.          if(_loc8_ != null)
  337.          {
  338.             _loc4_ = new QName(_loc8_.uri,_loc6_);
  339.          }
  340.          else
  341.          {
  342.             _loc4_ = new QName("",_loc6_);
  343.          }
  344.          return _loc4_;
  345.       }
  346.    }
  347. }
  348.  
  349.