LiraNuna's Development Blog

Being a huge C/C++ fan, I had a really hard time switching to AS3 and giving up most of C++’s power features as enumerations.

I was surprised that a programming language that is based on Java and C# doesn’t support native enumerations built in the language. After a quick look-up at various Google searches, turns out no one has implemented a type-safe assignable enumerations design pattern in AS3. The various code examples I’ve seen were either not type safe or not assignable (using the enumerations as ‘global’ consts). Since those were not the behaviors I wanted, I had to write my own.

One major problem I was facing was how to shadow the data of the enumerations, just like C++ does (although in C++ they could be used as integers as well). Using integers was out of the question and using strings would be more of a resource hog than helper.

The solution is recursive declaration – declare a class, which has itself on the inside using recursive constructor (a constructor that receives ‘itself’, much like copy constructor in C++).

This may sound crazy, but it actually works – Flash IDE does not complain and the result is a type-safe assignable type that you can only assign a set of specific values to.

This following code is an example of a ‘Direction’ enumeration written in AS3 and I can’t see any reason why not use it, this simple structure enables you to:

• Declare a class typed ‘Direction’
• Set the declared variable to a specific set of values predefined in the class
• Check and compare the variable (using either a boolean condition or a switch statement) to the predefined set of values
• Shadowing of the values to an abstract data, meaning that unlike C++, you cannot preform arithmetic operations on it

And here is the code, commented:

package
{
	class Direction
	{
		/*
		 * The actual enumeration values. Note that the sorting order doesn't matter.
		 */
		public static const NONE:Direction	= new Direction(NONE);
		public static const UP:Direction	= new Direction(UP);
		public static const DOWN:Direction	= new Direction(DOWN);
		public static const LEFT:Direction	= new Direction(LEFT);
		public static const RIGHT:Direction	= new Direction(RIGHT);

		/* Constructor */
		public function Direction(d:Direction)
		{
			/*
			 * Empty fake constructor
			 * The part that matter is that it accepts a 'copy' of itself
			 * For the recursive assignment to work
			 */
		}
	}
}

The reason the above code uses the ‘recursive’ constructor structure, is to ensure type safety. When assigning a new Direction type, only the above predefined list of values can be assigned. Another reason is, when you declare a function that takes a direction, you eliminate the possibility to invoke the function with ‘new Direction()’ as an argument and passing an undefined value (Direction.NONE should be used for that).

The constructor only requires one argument, which is typed as Direction as well, eliminating any possible casts to another type, shadowing the actual data (a reference to self) inside the class, making it a true type safe implementation.

Since in AS3, everything must be an object (a class), this leads to some interesting options, such as ‘helper functions’ which could be embedded inside the ‘enum’ itself, for example, the Java-like ‘toString’ function, could be easily implemented inside the Direction class as:

public function toString()
{
	switch(this) {
		case Direction.UP:
			return "Up";
		case Direction.DOWN:
			return "Down";
		case Direction.LEFT:
			return "Left";
		case Direction.RIGHT:
			return "Right";
		default:
			/* Direction.NONE is considered 'undefined' (no direction) */
			return "undefined";
	}
}

Now you can do anything an enueration was designed to do:

var dir:Direction = Direction.UP;  // Legal, Direction.UP is valid.
dir = 0;	                       // Illegal, '0' is not in the predefined set of values
trace(dir.toString());             // Will print 'Up' if above method is used

There you have it – a type safe assignable enumeration implementation in AS3.