looping through a class's static members

How do you loop through all static members of a class?

First of all, why would you want to do that? Well, let's say you're writing a game in which the player can move in the four classic compass directions:

public class Directions
{
 public static const NORTH : String = "north";
 public static const SOUTH : String = "south";
 public static const EAST : String = "east";
 public static const WEST : String = "west";
}

Somewhere in your game, you have a moveInDirection() method that accepts a direction. But you want to make sure it doesn't try to move the player in illegal directions, e.g. moveInDirection("up"); The IDE should prevent this, because if you type moveInDirection(Directions.UP) you'll get an error (because there's no UP constant).

However, I'd like to make moveInDirection a bit more idiot proof than having it rely on the IDE. Also, it's possible that directions may be chosen at run time. For instance, a player might type a direction in a textfield, as in a text-adventure game. What if the player types "up"?

So I'd like moveInDirection() to check if the player is trying to make a legal move...

function movieInDirection( direction : String ) : void
{
 if ( isLegal( direction ) )
 {
  ...
 }
}

The question is, how should isLegal() work? The last thing I want to do is to use a bunch of conditionals or an Array...

function isLegal( direction : String ) : Boolean
{
 var legal : Array = [ "north", "south", "east", "west" ];
 
 for each ( var legalDirection : String in legal )
 {
   if ( direction == legalDirection ) return true;
 }
 
 return false;
}

That's a terrible solution, because it couples the class Directions to the Array in my isLegal function. Scaling will be dangerous. For instance, what if I add a new constant to Directions...

public static const INSIDE : String = "inside";

... but forget to add it to the Array?

var legal : Array = [ "north", "south", "east", "west" ]; //Oops! Forgot to add "inside"

A better solution is to loop through all the constants in Directions and check if the player's attempted direction exists. But how do you loop through all the static members of a class? After playing around with arcane solutions involving prototype chains, I settled on using the little-known describeType() function. It's in the flash.utils class, and you import it like this:

import flash.utils.describeType;

If you feed describleType() the Directions class -- trace( describeType( Directions) ) -- it outputs an XML description of the class:

<type name="Directions" base="Class" isDynamic="true" isFinal="true" isStatic="true">
  <extendsClass type="Class"/>
  <extendsClass type="Object"/>
  <constant name="WEST" type="String"/>
  <constant name="NORTH" type="String"/>
  <constant name="EAST" type="String"/>
  <constant name="SOUTH" type="String"/>
  <accessor name="prototype" access="readonly" type="*" declaredBy="Class"/>
  <factory type="Directions">
    <extendsClass type="Enum"/>
    <extendsClass type="Object"/>
  </factory>
</type>

It's then a fairly easy matter to parse the xml, extract all the constants, and test them against the player's choice. I packaged the solution in a utility class:

package com.grumblebee.constants 
{

import flash.utils.describeType;    

  public class Utilities 
  {
     public static function isLegal( enumClass : Class, value : String ) : Boolean
     {
        var xml : XML = describeType( enumClass );
        var xmlList : XMLList = xml.child( "constant" );
        var enumName : String;
      
        for each ( var child : XML in xmlList )
        {
          enumName = child.attribute( "name" ).toString();
          if ( enumClass[ enumName ] == value ) return true;
        }
   
        return false;
     }
     
  }
}

I can't shake the feeling that there's a better way to do this. I'd love to lose the XML parsing. But this is the best I can come up with for the moment. One thing I could do is transform the player's string to upper-case and test it directly to see if there's such a constant in Directions:

if ( Directions[ playerString.toUpperCase() ] != undefined ) ...

But that only works if I stick to the convention of NORTH = "north". It fails if Directions looks like this:

public class Directions
{
 public static const NORTH : String = "n";
 public static const SOUTH : String = "s";
 public static const EAST : String = "e";
 public static const WEST : String = "w";
}

it would also fail in the case of...

public static const UNDER_THE_BRIDGE : String = "under the bridge";

At one point, I thought about adding the isLegal() function to Directions. You can get a class to refer to its own static constants this way:

trace( prototype.constructor[ "NORTH" ] ); //north

Sadly, though prototype.constructor allows you to access individual class variables and constants, for some reason, you can't loop through its members:

for each ( var s: String in prototype.constant ) trace( prototype.constant[ s ] ); //no output

It also doesn't work if you explicitly name the class:

trace( Directions[ "NORTH"] ); //north
for each ( var s : String in Directions ) trace( Directions[ s ] ); //no output.

So until something better comes along, I'm stuck with XML parsing.