Question

Is there a way to create a class’s constants dynamically? I know this sounds a bit odd but let me explain what I’m trying to do:

• I have a Enum class who’s attributes are defined by static const definitions
• This class extends the PHP SplEnum class
• Rather than type in each of these definitions in code I’d like to have a static initialiser go out to the database and pull the enumerated values

Maybe somethings like this:

class myEnum extends SplEnum {
    public static function init () {
        $myNameValuePair = DB_Functions::get_enum_list();
        foreach ( $myNameValuePair as $name => $value) {
            $const = array ( self , $name );
            $const = $value;
        }
    }
}

I recognise that this won’t actually work as it doesn’t set CONST’s but rather static variables. Maybe my whole idea is hair brained and there’s a better technique to this. Anyway, any method to achieve the end goal is greatly appreciated.

UPDATE

I think it might be helpful to be a little more clear on my goals because I think it’s entirely possibly that my use of Constants is not a good one. Basically I want to achieve is typical of the Enumerated list’s requirements:

1. Constrain function signatures. I want to be able to ask for a “set” of values as an input to a function. For instance:

   public function do_something ( ENUM_Types $type ) {}

2. Simple and Compact. Allow for a simple and compact syntax when used in code. For instance with the use of constants I might write a conditional statement something like:

   if ( $my_var === ENUM_Types::TypeA ) {}

3. Dynamic enumeration. I’d like this enumeration to be managed through the frontend and stored in the database (I’m using wordpress admin screens for this in case anyone cares). At run time this “list” should be pulled out of the DB and made available to the code as an enumeration (or similar structure that achieves the goals above).

Answer 1

Wrap your “enum” values in a singleton and implement the (non-static) magic __get method:

<?php
class DynamicEnums {

  private static $singleton;

  private $enum_values;

  public static function singleton() {
    if (!self::$singleton) {
        self::$singleton = new DynamicEnums();
    }
    return self::$singleton;
  }

  function __construct() {
    $this->enum_values = array( //fetch from somewhere
        'one' => 'two',
        'buckle' => 'my shoe!',
    );
  }

  function __get($name) {
    return $this->enum_values[$name]; //or throw Exception?
  }

  public static function values() {
    return self::singleton()->enum_values; //warning... mutable!
  }
}

For bonus points, create a (non-OO) function that returns the singleton:

function DynamicEnums() {
    return DynamicEnums::singleton();
}

Consumers of “DynamicEnums” would look like:

echo DynamicEnums::singleton()->one;
echo DynamicEnums()->one;            //can you feel the magic?
print_r(DynamicEnums::values());

[edit] More enum-like.