home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / rpc / xml / SchemaLoader.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  6.7 KB  |  189 lines
  1. package mx.rpc.xml
  2. {
  3.    import mx.rpc.AsyncToken;
  4.    import mx.rpc.events.ResultEvent;
  5.    import mx.rpc.events.SchemaLoadEvent;
  6.    import mx.rpc.http.HTTPService;
  7.    
  8.    public class SchemaLoader extends XMLLoader
  9.    {
  10.       private static const LOAD_INCLUDE:String = "include";
  11.       
  12.       private static const LOAD_IMPORT:String = "import";
  13.       
  14.       private var topLevelSchema:Schema;
  15.       
  16.       private var _schemaManager:SchemaManager;
  17.       
  18.       private var locationMap:Object;
  19.       
  20.       public function SchemaLoader(param1:HTTPService = null)
  21.       {
  22.          super(param1);
  23.          locationMap = {};
  24.       }
  25.       
  26.       override protected function resultHandler(param1:ResultEvent) : void
  27.       {
  28.          var _loc5_:Schema = null;
  29.          var _loc6_:Array = null;
  30.          var _loc7_:Namespace = null;
  31.          var _loc8_:XMLList = null;
  32.          var _loc9_:Schema = null;
  33.          var _loc10_:Namespace = null;
  34.          var _loc11_:SchemaLoadEvent = null;
  35.          super.resultHandler(param1);
  36.          var _loc2_:XML = XML(param1.result);
  37.          var _loc3_:AsyncToken = param1.token;
  38.          var _loc4_:String = _loc3_ == null ? null : _loc3_.location;
  39.          if(_loc3_.parent != null)
  40.          {
  41.             _loc5_ = _loc3_.parent as Schema;
  42.             if(_loc3_.loadType == LOAD_INCLUDE)
  43.             {
  44.                _loc6_ = _loc2_.namespaceDeclarations();
  45.                for each(_loc7_ in _loc6_)
  46.                {
  47.                   _loc5_.xml.addNamespace(_loc7_);
  48.                }
  49.                _loc8_ = _loc2_.children();
  50.                _loc5_.addInclude(_loc8_);
  51.                locationMap[_loc4_] = _loc8_;
  52.                schemaIncludes(_loc5_,_loc4_);
  53.                schemaImports(_loc5_,_loc4_);
  54.             }
  55.             else
  56.             {
  57.                _loc9_ = new Schema(_loc2_);
  58.                locationMap[_loc4_] = _loc9_;
  59.                _loc10_ = _loc3_.importNamespace as Namespace;
  60.                _loc5_.addImport(_loc10_,_loc9_);
  61.                schemaIncludes(_loc9_,_loc4_);
  62.                schemaImports(_loc9_,_loc4_);
  63.             }
  64.          }
  65.          else
  66.          {
  67.             topLevelSchema = new Schema(_loc2_);
  68.             locationMap[_loc4_] = topLevelSchema;
  69.             schemaIncludes(topLevelSchema,_loc4_);
  70.             schemaImports(topLevelSchema,_loc4_);
  71.          }
  72.          if(loadsOutstanding <= 0)
  73.          {
  74.             _loc11_ = SchemaLoadEvent.createEvent(topLevelSchema,_loc4_);
  75.             dispatchEvent(_loc11_);
  76.          }
  77.       }
  78.       
  79.       override public function load(param1:String) : void
  80.       {
  81.          param1 = getQualifiedLocation(param1);
  82.          loadSchema(param1);
  83.       }
  84.       
  85.       private function loadSchema(param1:String, param2:Schema = null, param3:Namespace = null, param4:String = null) : AsyncToken
  86.       {
  87.          var _loc5_:AsyncToken = internalLoad(param1);
  88.          if(_loc5_ != null)
  89.          {
  90.             _loc5_.parent = param2;
  91.             _loc5_.importNamespace = param3;
  92.             _loc5_.loadType = param4;
  93.          }
  94.          return _loc5_;
  95.       }
  96.       
  97.       public function schemaIncludes(param1:Schema, param2:String) : void
  98.       {
  99.          var schemaINCXML:XML = null;
  100.          var location:String = null;
  101.          var existing:XMLList = null;
  102.          var schemaQName:QName = null;
  103.          var schemaXML:XML = null;
  104.          var nsSchema:Namespace = null;
  105.          var includeQName:QName = null;
  106.          var schema:Schema = param1;
  107.          var parentLocation:String = param2;
  108.          var schemaINCList:XMLList = schema.xml.elements(schema.schemaConstants.includeQName);
  109.          for each(schemaINCXML in schemaINCList)
  110.          {
  111.             location = schemaINCXML.@schemaLocation;
  112.             location = getQualifiedLocation(location,parentLocation);
  113.             existing = locationMap[location] as XMLList;
  114.             schemaQName = schemaINCXML.name();
  115.             schemaXML = schema.xml;
  116.             nsSchema = new Namespace(schema.schemaConstants.xsdURI);
  117.             includeQName = schema.schemaConstants.includeQName;
  118.             delete schemaXML[includeQName].(@schemaLocation == location)[0];
  119.             schema.xml = schemaXML;
  120.             if(existing == null)
  121.             {
  122.                loadSchema(location,schema,schema.targetNamespace,LOAD_INCLUDE);
  123.             }
  124.             else
  125.             {
  126.                schema.addInclude(existing);
  127.             }
  128.          }
  129.       }
  130.       
  131.       public function schemaImports(param1:Schema, param2:String, param3:SchemaManager = null) : void
  132.       {
  133.          var importNode:XML = null;
  134.          var location:String = null;
  135.          var importURI:String = null;
  136.          var importNS:Namespace = null;
  137.          var nsSchema:Namespace = null;
  138.          var importedSchemas:Array = null;
  139.          var importedSchema:Schema = null;
  140.          var existing:Schema = null;
  141.          var schema:Schema = param1;
  142.          var parentLocation:String = param2;
  143.          var schemaManager:SchemaManager = param3;
  144.          var importQName:QName = schema.schemaConstants.importQName;
  145.          var schemaXML:XML = schema.xml;
  146.          var imports:XMLList = schemaXML.elements(importQName);
  147.          for each(importNode in imports)
  148.          {
  149.             location = importNode.attribute("schemaLocation").toString();
  150.             importURI = importNode.attribute("namespace").toString();
  151.             importNS = new Namespace(importURI);
  152.             nsSchema = new Namespace(schema.schemaConstants.xsdURI);
  153.             if(location == "")
  154.             {
  155.                if(schemaManager != null)
  156.                {
  157.                   importedSchemas = schemaManager.getResourcesForURI(importURI);
  158.                   if(importedSchemas != null)
  159.                   {
  160.                      for each(importedSchema in importedSchemas)
  161.                      {
  162.                         schema.addImport(importNS,importedSchema);
  163.                      }
  164.                      delete schemaXML[importQName].(@namespace == importURI)[0];
  165.                      schema.xml = schemaXML;
  166.                   }
  167.                }
  168.             }
  169.             else
  170.             {
  171.                delete schemaXML[importQName].(@namespace == importURI)[0];
  172.                schema.xml = schemaXML;
  173.                location = getQualifiedLocation(location,parentLocation);
  174.                existing = locationMap[location];
  175.                if(existing == null)
  176.                {
  177.                   loadSchema(location,schema,importNS,LOAD_IMPORT);
  178.                }
  179.                else
  180.                {
  181.                   schema.addImport(importNS,existing);
  182.                }
  183.             }
  184.          }
  185.       }
  186.    }
  187. }
  188.  
  189.