ConfigLoader Class for Flex 3

package com.util
{
   import flash.events.Event;
   import flash.events.EventDispatcher;
   import flash.events.IEventDispatcher;
   import flash.events.IOErrorEvent;
   import flash.events.SecurityErrorEvent;
   import flash.net.URLLoader;
   import flash.net.URLLoaderDataFormat;
   import flash.net.URLRequest;

   [Event(name="complete",type="ConfigLoaderEvent")]
   [Event(name="fault",type="ConfigLoaderEvent")]
   
   public class ConfigLoader extends EventDispatcher
   {            
      private var _configXMLPath:String;
      private var _configLoaded:Boolean = false;
      private var _configXML:XML;
      
      //our favorite constructor...       
      public function ConfigLoader(configXMLPath:String, target:IEventDispatcher=null)
      {
         super(target);
         _configXMLPath = configXMLPath;
      }
   
      //here lies the meat and potatoes of this class       
      public function load () : void
      {         
         var loader:URLLoader = new URLLoader();
         loader.dataFormat = URLLoaderDataFormat.TEXT;
         loader.addEventListener(Event.COMPLETE,loadConfigXML_complete_handler);
         loader.addEventListener(IOErrorEvent.IO_ERROR,loadConfigXML_ioError_handler);
         loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,loadConfigXML_securityError_handler);
         
         //clear the config in case it has been loaded before          
         _configXML = null;
         //set that the config hasn't been loaded          
         _configLoaded = false
         
         try
         {
            trace("loading config: " + _configXMLPath);
            loader.load( new URLRequest(_configXMLPath) );
         }
         catch ( e:Error )
         {
            //trace out the error, but it will be caught below             
            trace("an error occurred loading the config file");
         }
      }
      
      public function loadConfigXML_ioError_handler ( e:IOErrorEvent ) : void
      {
         //woops, something went wrong with the transfer, create and dispatch an event letting everyone know
               
         var cle:ConfigLoaderEvent = new ConfigLoaderEvent(ConfigLoaderEvent.FAULT);
         cle.message = "I/O Error";
         dispatchEvent(cle);
      }
      
      public function loadConfigXML_securityError_handler ( e:SecurityErrorEvent ) : void
      {
         //looks like someone is trying to access something they aren't supposed to be able to see.          
         var cle:ConfigLoaderEvent = new ConfigLoaderEvent(ConfigLoaderEvent.FAULT);
         cle.message = "Security Error";
         dispatchEvent(cle);
      }
   
      private function loadConfigXML_complete_handler ( e:Event ) : void
      {
         try
         {
            //convert the text to xml             
            _configXML = new XML( e.target.data );
            
            //set the flag that the config has been loaded.             
            _configLoaded = true;
            
            //create and dispatch the complete event for a job well done.             
            var completeEvent:ConfigLoaderEvent = new ConfigLoaderEvent(ConfigLoaderEvent.COMPLETE);
            completeEvent.data = _configXML;
            dispatchEvent(completeEvent);
            trace('configLoader complete');
         }
         catch ( e:TypeError )
         {
            var faultEvent:ConfigLoaderEvent = new ConfigLoaderEvent(ConfigLoaderEvent.FAULT);
            faultEvent.message = "Could not convert config to xml, document may be malformed.";
            dispatchEvent(faultEvent);
         }
      }
      
      
      public function get configXML () : XML
      {
         return _configXML;
      }
      
      public function set configXMLPath ( value:String ) : void
      {
         _configXMLPath = value;
      }

      public function get configXMLPath () : String
      {
         return _configXMLPath;
      }
      
      public function set configLoaded ( value:Boolean ) : void
      {
         _configLoaded = value;
      }
      
      
      public function get configLoaded () : Boolean
      {
         return _configLoaded;
      }
   }
}

package com.util
{
   import flash.events.Event;

   public class ConfigLoaderEvent extends Event
   {
      
      public static const COMPLETE:String = 'Complete';
      public static const FAULT:String = 'Fault';
      
      private var _data:XML;
      private var _message:String;
      
      public function ConfigLoaderEvent(type:String, bubbles:Boolean=false, cancelable:Boolean=false)
      {
         super(type, bubbles, cancelable);
      }
      
      public function set data ( value:XML ) : void
      {
         _data = value;
      }
            
      public function get data () : XML
      {
         return _data;
      }
      
      public function set message ( value:String ) : void
      {
         _message = value;
      }
      
      
      public function get message () : String
      {
         return _message;
      }


   }
}

import com.util.ConfigLoader;
   import com.util.ConfigLoaderEvent;
   
   [Bindable]
   public var configXML:XML;   
   
   //a variable to keep track if we are loaded or not    
   public var configLoaded:Boolean = false;
   
   //create the configloader and tell it where the config.xml file is relative to src.    
   public var configLoader:ConfigLoader = new ConfigLoader("config.xml");
   
   
   // I use the initialize event on application to set up these event handlers    
   //and load the configuration file because it does not    
   //require any UIComponents to function.    
   public function application_initialization_handler ( e:Event ) : void
   {
      //configLoader will broadcast an event on load complete or fault...       
      configLoader.addEventListener(ConfigLoaderEvent.COMPLETE,configLoader_complete_handler);
      configLoader.addEventListener(ConfigLoaderEvent.FAULT,configLoader_fault_handler);
      
      //call load() to actually load in the file and parse it.       
      configLoader.load();
   }
   
   public function configLoader_complete_handler ( e:ConfigLoaderEvent ) : void
   {
      configXML = e.data;   
      useConfig(configXML);      
   }
   
   public function configLoader_fault_handler ( e:ConfigLoaderEvent ) : void
   {
      Alert.show(e.message);
   }
   
   public function useConfig( configXML ) : void
   {
      // so here you can now use the configXML to pull out whatever values you need.       
         
   }