Comments on: Typesafe Enum Pattern in AS3

By: DamionMurray

DamionMurray — Mon, 23 Feb 2009 03:26:02 +0000

@JoshMcDonald: Once the class is declared as final this implementation of
enumerated types does prove quite useful. The reason the author prevents
further instantiations of the class is to ensure strict adherence to the very
definition of an enumerated type; a type with a fixed number of predefined values.
This “strictness” may seem unnecessary but consider the following scenario. A
method takes a DebitCreditEnum instance as a parameter. Inside the method body the
enum parameter is tested for equality with static constants of the enum class.
Now, if instantiation of an enum were possible, the method could be passed a DebitCreditEnum instance independent of those declared as static constants.
In that case, the test in the method body would fail, but this error would crop
up at run-time and be more difficult to debug compared to a compile-time error.

By: David

David — Fri, 07 Nov 2008 19:30:22 +0000

I recently came across the problem of neededing some enumerations in code I was writing. I tried to come up with an enumerated type as close to the ones used in c# as I could. I saw that an enum type was simply a collection of string values each basically creates as a static member of the enum type. I came up with a base enum class that then can be exteneded into any enum you wish.

package Enums.baseEnum
{

/** the base class for an enumerated type. The values for the type are determined by a string array that is passed in. A user can get/set the current
* value and the current index. Passing an invalid index or and invalid value to the setters will result in an argument error. To create a more standard
* enum type, simply extend this class, creating as many public static constants as you wish, then make an array of all the same constants, and pass to
* the super constructor of this class. For ease of use, remembering intellisence will alphabetize your enum lists, so keep your strings alphabetized
* or include the index as part of the static members name**/
public class Enum
{
public function Enum(values:Array, initialValue:String)
{
if (values == null)
_values = new Array();
else
_values = values;
this.value = defaultValue;
}

protected var _values:Array;

private var _index:int;

public function get index():int
{
return _index;
}
public function set index(val:int):void
{
if(val = _values.length)
throw new ArgumentError(“Enum set index : supplied value of ” + val + ” is outside current range of 0 – ” + _values.length – 1 + “, determined by this Enum’s array [" + _values.toString()"]“);
_index = value;
}

public function set value(value:String):void
{
_index = _values.indexOf(value);
if(_index == -1)
throw new ArgumentError(“Enum set value : supplied value of ” + value + ” is not a recognized entry, available values are ” + _values.toString());
}
public function get value():String
{
return _values[_index].toString();
}
}
}

this class requires an array passed to it. In common use, i believe an array of strings should suffice, however, I am sure objects could also be passed if needed. The next step is to extend the Enum class with whatever enumerated type you would like, creating static strings for each possible value, and then passing that array in the constructor … as follows

package Enums
{
import Enums.baseEnum.Enum;

public class Colors extends Enum
{
public static const Black:String = ‘Black’;
public static const Blue:String = ‘Blue’;
public static const Green:String = ‘Green’;
public static const Red:String = ‘Red’;

public function EquipmentType(initialValue:String)
{
super(['Black','Blue','Green','Red'],initialValue);
}
}
}

then in use of this program, one can create as many Colors objects they want, and each one may be set using the set value call and the ClassName. Static variable…. i.e.

private var myColor:Colors = new Colors(Colors.Blue);

use myColor.value to get the set value or myColor.value = Colors.XXXXX to set the value.

What does everyone think?

By: Josh McDonald

Josh McDonald — Sun, 14 Sep 2008 23:24:13 +0000

An interesting technique, but it does rely on the compiler not one day being optimised in a way that the static code blocks happen before static initialisations. The other question is of course since you’re going to be using typesafe checks against the public consts (and DebitCreditEnum is not final), what benefit do you really get by this code? Who cares if somebody calls new DebitCreditEnum() a few times? It can’t break anything relying on this enum class as far as I can see.

By: Ciprian

Ciprian — Thu, 14 Aug 2008 08:40:23 +0000

I had a similar problem but I found a work-around. It’s not the nicest one, but you could instantiate your DEBIT and CREDIT in the constructor of the DebitCreditEnum class. You put them as vars, you only provide getters (to make them constant to the outside), you set them as null in the beginning, and in the constructor you test if they are null in wich case you instantiate them.

By: chris

chris — Fri, 11 Jan 2008 15:39:42 +0000

Thanks for the tip!

I too was trying the initial approach, which led me to your post.