In AS3, where do you draw the line between Dictionary and ArrayCollection?

Question

Basically I have been using a Dictionary object in my program that basically took ints as its keys and stored RTMFP peer IDs in the appropriate locations. Each int was unique and represented one user.

Now I'm needing to expand on this where users are identified by a combination of the int and a Boolean value, kind of like this:

private var m_iUID:int;
private var m_blnIsCurrent:Boolean;

Only the combination between those two really uniquely identifies the user. That being said I was just about to use a new class made out of this for the Dictionary keys; but then it occurred to me that instead of doing it this way, I could just add the peer ID to the class definition and turn the Dictionary object into an ArrayCollection:

private var m_iUID:int;
private var m_blnIsCurrent:Boolean;
public var m_strNearID:String;

So now I'm wondering which is really better in this scenario. And that question has led to a bigger question: where do you really draw the line between these two collection types in general? They're suddenly starting to not seem all that different after all, except where you're trying to avoid messing with class definitions. I guess I'm really asking for advice about both the specific scenario and the general question. Thanks!

Answer 1

ArrayCollection is just a wrapper for an Array, and is only available in Flex.

In AS3 you really have 3 fundamental hash table types: Array, Object, and Dictionary. You choose which one to use based on the type of key you want to use: an integer, a string, or an object reference. Arrays will convert any key to an int, Object will convert any key to a string. Dictionary works like Object for string keys (and will convert primitives to a string) but what it is really good at is using object references as keys.

It you want to use a single int as the unique key, use an array. If you want to use a single string as the unique key, use an object. If you want to use object references as the unique key, use a Dictionary.

In your case you should probably use an Object, and a custom toString() method on your "key" class. This is because you want to use a composite of primitive values (NOT an object reference) as your unique key. There is no way to do this natively, so you'll have to mash the values together as a single string. Objects are the best (fastest) hash table for string keys, so that is the collection you should use.

Example:

class User {
    private var m_iUID:int;
    private var m_blnIsCurrent:Boolean;
    public var m_strNearID:String;
    public function User(UID:int, IsCurrent:Boolean) {
        m_iUID = UID;
        m_blnIsCurrent = IsCurrent;
    }

    // Custom toString to mash together primitives
    public function toString() {
        return m_iUID.toString() + "-" + (m_blnIsCurrent ? "1" : "0");
    }
}

// Later:
var allUsers:Object = {}
var user1:User = new User(231049, true);
var user2:User = new User(0x2309, false);

// Implicitly calls toString():
allUsers[user1] = "User 1";
allUsers[user2] = "User 2";

// All of the following will successfully retrieve the value for user1 ("User 1"):
// ONLY the first would work if allUsers was a Dictionary
trace(allUsers[user1]);
trace(allUsers[user1.toString()]); 
trace(allUsers["231049-1"]); 
trace(allUsers[new User(231049, true)]); 

Answer 2

Dictionary and ArrayCollection have some important differences:

• Dictionary maps objects to other objects, while ArrayCollection is just a list of objects.
• ArrayCollection is Flex only, so unusable in a generic AS3 project.

Which one you should use really depends on what you need in your app:

• Will you be using the "identity" object (with user id and "is current") somewhere else, without an associated peer id? In that case, make it a separate Identity class or so and use a Dictionary to map Identity instances to peer ids.
• Do you need to perform lookups based on identities? In other words, do you need to ask "which peer id is associated with this identity?". If so, go for Dictionary + Identity once more, to avoid looping through a list instead.

I'm sure there are more considerations, but these should get you started.