Custom URLLoader

package net {
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.HTTPStatusEvent;
    import flash.events.IOErrorEvent;
    import flash.events.ProgressEvent;
    import flash.events.SecurityErrorEvent;
    import flash.net.URLRequest;
    import flash.net.URLStream;
    import flash.net.URLVariables;
    import flash.utils.ByteArray;

    /*
     * The native URLLoader has an annoying limitation: it does not offer a way
     * to get the URL back from it!
     *
     * Luckily it is a just a thin wrapper around the URLStream, so I chose to
     * implement my own URLLoader with added conveniences.
     * */

    public class URLLoader extends EventDispatcher{
        private var _urlRequest:URLRequest;
        private var _stream:URLStream;
        private var _dataFormat:String = "text";
        private var _data:* = null;
        private var _bytesLoaded:uint = 0;
        private var _bytesTotal:uint = 0;

        public function get request():URLRequest    { return _urlRequest; }
        public function get url():String            { return _urlRequest.url; }
        public function get fileName():String       {
            var parts:Array = _urlRequest.url.match(/(?:\\|\/)([^\\\/]*)$/);
            return (parts && parts.length > 1) ? parts[1] : _urlRequest.url;
        }
        public function get dataFormat():String     { return _dataFormat;}
        public function get data():*                { return _data; }
        public function get bytesLoaded():uint      { return _bytesLoaded; }
        public function get bytesTotal():uint       { return _bytesTotal; }
        public function get loadProgress():Number   { return (_bytesTotal) ? _bytesLoaded / _bytesTotal : 0; }

        public function URLLoader(request:URLRequest = null){
            super(null); //initiate the eventdispatcher
            _stream = new URLStream();
            _stream.addEventListener(Event.OPEN, onConnectionOpened, false, 0, false);
            _stream.addEventListener(ProgressEvent.PROGRESS, onLoadProgress, false, 0, false);
            _stream.addEventListener(Event.COMPLETE, onLoadComplete, false, 0, false);
            _stream.addEventListener(IOErrorEvent.IO_ERROR, onInputOutputError, false, 0, false);
            _stream.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError, false, 0, false);
            _stream.addEventListener(HTTPStatusEvent.HTTP_STATUS, onHTTPStatus, false, 0, false);
            if (request != null){
                load(request);
            };
        }
        public function load(request:URLRequest):void {
            _urlRequest = request; //tadaa! saving the adress for future reference.
            _stream.load(_urlRequest);
        }
        public function close():void{
            _stream.close();
        }

        private function onLoadProgress(event:ProgressEvent):void {
            _bytesLoaded = event.bytesLoaded;
            _bytesTotal = event.bytesTotal;
            dispatchEvent(event);
        }
        private function onLoadComplete(event:Event):void{
            var bytes:ByteArray = new ByteArray();
            _stream.readBytes(bytes);
            switch (_dataFormat){
                case "binary":
                    _data = bytes;
                    break;
                case "variables":
                    if (bytes.length > 0){
                        _data = new URLVariables(bytes.toString());
                        break;
                    };
                case "text":
                default:
                    _data = bytes.toString();
                    break;
            };
            dispatchEvent(event);
        }
        private function onConnectionOpened(event:Event):void {
            dispatchEvent(event);
        }

        private function onSecurityError(event:SecurityErrorEvent):void {
            dispatchEvent(event);
        }
        private function onHTTPStatus(event:HTTPStatusEvent):void {
            dispatchEvent(event);
        }
        private function onInputOutputError(event:IOErrorEvent):void {
            dispatchEvent(event);
        }
    }
}