AS3 SoundManager Class

package
{
    import flash.events.Event;
    import flash.media.Sound;
    import flash.media.SoundChannel;
    import flash.media.SoundTransform;

    /**
     * ...
     * @author RTLShadow
     */
    public class SoundManager
    {
        private static var soundNames:Array = [];
        private static var soundList:Array = [];

        private static var _soundMuted:Boolean = false;
        private static var _musicMuted:Boolean = false;
        private static var _soundVol:Number = 1;
        private static var _musicVol:Number = 1;

        public static const SOUND:int = 0;
        public static const MUSIC:int = 1;
        public static const OTHER:int = 2;

        /**
         * Adds a sound to the list of sounds that you can play.
         * @param   s   The Sound object to add to the list.
         * @param   name    The name of the sound, you cannot have duplicates in the same list.
         * @param   type    The type to classify the sound under. Defaults are SOUND(0), MUSIC(1), and OTHER(2). Used to classify what sounds to mute.
         */
        public static function addSound( s:Sound, name:String, type:int ):void
        {
            if ( soundList[ name ] == undefined )
            {
                var st:SoundTransform = new SoundTransform(( type == SOUND ) ? _soundVol : (( type == MUSIC ) ? _musicVol : 1 ) );
                soundList[ name ] = { sound: s, // sound object
                        transform: st, // SoundTransform
                        channel: s.play(), // SoundChannel
                        type: type, // the type of sound (i.e. SOUND, MUSIC, OTHER)
                        isPlaying: false }; // if the sound is currently playing

                soundNames.push( name );
                soundList[ name ].channel.stop();
            }
            else
            {
                throw( new Error( "The name '" + name + "' already exists for a sound name." ) )
            }
        }

        /**
         * Play a sound from the current list. The sound must have been added through the 'addSound()' function before playing it.
         * @param   name        The name of the sound to play.
         * @param   loops   The amount to loop the sound, the default is 0. -1 to repeat infinitely.
         */
        public static function playSound( name:String, loops:int = 0 ):void
        {
            if ( soundList[ name ] != undefined )
            {
                soundList[ name ].channel = soundList[ name ].sound.play( 0, // position
                    ( loops == -1 ) ? int.MAX_VALUE : loops, // loop amount
                    soundList[ name ].transform ); // transform to apply

                soundList[ name ].isPlaying = true;
                soundList[ name ].channel.addEventListener( Event.SOUND_COMPLETE, soundComplete );
            }
            else
            {
                throw( new Error( "Sound '" + name + "' does not exist." ) );
            }
        }

        private static function soundComplete( e:Event ):void
        {
            // TODO Find a better way to do this entire function
            for ( var i:int = soundList.length - 1; i >= 0; --i )
            {
                if ( soundList[ i ].channel == e.target )
                {
                    soundList[ i ].isPlaying = false;
                    break;
                }
            }
        }

        /**
         * Stop the sound being played.
         * @param   name    The name of the sound to stop.
         */
        public static function stopSound( name:String ):void
        {
            if ( soundList[ name ].sound != undefined )
            {
                soundList[ name ].channel.stop();
            }
            else
            {
                throw( new Error( "Sound '" + name + "' does not exist." ) );
            }
        }

        public static function isPlaying( name:String ):Boolean
        {
            return soundList[ name ].isPlaying;
        }

        /**
         * Get the SoundTransform object of a specific sound.
         * @param   name
         * @return  The current SoundTransform of the sound.
         */
        public static function getTransform( name:String ):SoundTransform
        {
            return soundList[ name ].transform;
        }

        /**
         * Set the SoundTransform of a sound.
         * @param   name            The name of the sound to set a new SoundTransform.
         * @param   sTransform  SoundTransform object to set as the new soundTransform.
         */
        public static function setTransform( name:String, sTransform:SoundTransform ):void
        {
            soundList[ name ].transform = sTransform;
            soundList[ name ].channel.soundTransform = sTransform;
        }

        /**
         * See if all sounds of type 'SOUND' are muted.
         */
        static public function get soundMuted():Boolean
        {
            return _soundMuted;
        }

        /**
         * Mute all sounds of type 'SOUND'.
         */
        static public function set soundMuted( m:Boolean ):void
        {
            _soundMuted = m;
            var s:String = "";
            var currTransform:SoundTransform;
            for each ( s in soundNames )
            {
                if ( soundList[ s ].type == SOUND )
                {
                    currTransform = getTransform( s );
                    if ( m )
                        currTransform.volume = 0;
                    else
                        currTransform.volume = _soundVol;
                    setTransform( s, currTransform );
                }
            }
        }

        /**
         * See if all sounds of type 'MUSIC' are muted.
         */
        static public function get musicMuted():Boolean
        {
            return _musicMuted;
        }

        /**
         * Mute all sounds of type 'MUSIC'.
         */
        static public function set musicMuted( m:Boolean ):void
        {
            _musicMuted = m;
            _soundMuted = m;
            var s:String = "";
            var currTransform:SoundTransform;
            for each ( s in soundNames )
            {
                if ( soundList[ s ].type == MUSIC )
                {
                    currTransform = getTransform( s );
                    if ( m )
                        currTransform.volume = 0;
                    else
                        currTransform.volume = _musicVol;
                    setTransform( s, currTransform );
                }
            }
        }

        static public function get soundVol():Number
        {
            return _soundVol;
        }

        static public function set soundVol( s:Number ):void
        {
            _soundVol = s;
            var str:String = "";
            var currTransform:SoundTransform;
            for each ( str in soundNames )
            {
                if ( soundList[ str ].type == SOUND )
                {
                    currTransform = getTransform( str );
                    currTransform.volume = _soundVol;
                    setTransform( str, currTransform );
                }
            }
        }

        static public function get musicVol():Number
        {
            return _musicVol;
        }

        static public function set musicVol( m:Number ):void
        {
            _musicVol = m;
            var str:String = "";
            var currTransform:SoundTransform;
            for each ( str in soundNames )
            {
                if ( soundList[ str ].type == MUSIC )
                {
                    currTransform = getTransform( str );
                    currTransform.volume = _musicVol;
                    setTransform( str, currTransform );
                }
            }
        }
    }

}