Another note: the interesting thing about this class isn’t how the methods are replaced, but because (contrary to posts I had read regarding the matter -> http://gskinner.com/blog/archives/2006/07/as3_dictionary.html) I couldn’t create duplicate function entries with the same method (in a weakly referenced Dictionary).

My main point was that changing the Dictionary’s reference (weak or strong) changes the output of the code I posted on your blog. For example, changing the code I had posted above to instantiate my Queue class with a ’strong’ referenced Dictionary, the output is as follows:

object [Queue]
-> function Function() {} 3,5
-> function Function() {} 4,5
8
9
object [Queue]
done

As you can see calling toString() on the class traces the contents (in whatever order it decides) and then executes the functions in that same order. Instantiating the class with a weakly referenced Dictionary results in the following:

object [Queue]
-> function Function() {} 4,5
-> function Function() {} 3,5
object [Queue]
done

Here you can see that immediately after pushing the functions into the Queue, the functions can be listed, but after the TimerEvent.TIMER (which is set to 1 millisecond) has triggered, the functions that were once listed are no longer there!

I may be missing the point, but I never explicitly removed the functions from the queue, yet they disappeared. When the class is instantiated with a strong referenced Dictionary the functions last and are executed. I don’t know what else to attribute this behavior to besides the GC. Maybe you can help me understand this more clearly.

On a last note, my class is supposed to handle requests from containing classes or extending classes (or the main timeline) that would like to call functions (such as a resize) before those functions are necessarily ready, these functions are most definitely static properties (like a setter function) and declaring dynamic functions aren’t so much an option. One way around this would be to repeat the given function within itself as an alternative dynamic function to execute if the given function can’t operate, passing the dynamic function into the queue, but that seems like it might be complicating the matter… Thanks for pounding this out with me!

I was looking at the code you posted to my site. I wanted to make a few notes that may help out.

First, the order of the trace has to do with the for…in loop that you use in the toString() method. This loop doesn’t necessarily output in the order you added the functions.

Second, this isn’t happening as a result of weak references. As you mentioned on your blog post, you cannot use the same function twice as a key without overwriting the previous value. In a Dictionary, the key object acts the same as an index for an array. If you had

var a:Array = new Array();
a[0] = “foo”;
a[1] = “bar”;
a[1] = “woot”;
trace(a); // foo,woot

so it stands to reason that you shouldn’t be able to do this with functions as keys either.

Since this class essentially runs a list of functions one after the other, you may want to try using dynamic Functions instead. Something like this:

var func:Function = new Function ():void {
blah (1, 5);
blah (2, 5);
blah (4, 5);
blah2(3, 5);
}
func();

I hope that was helpful.

function startQueue(event:TimerEvent):void
{
queue.start();
trace(queue);
trace("done");
}

Adam, I’ve added additional text to the above post to answer your question.