<?php
/**
* mpl           by ERB software
* @author       stefan.erb(at)erb-software.com
* @since        PHP 5.2 (Für PHP 5.3 kann man einige Dinge einfacher machen)
*/

/**
 * Die Klasse Enum ist ein Kunstrukt zum Erstellen von Enumeratoren
 */

/**
 * php52.php beinhaltet die Funktion get_called_class() für PHP52
 * Ab PHP53 wirden diese Datei die die Funktion für PHP52 zur Verfügung stellt
 * nicht mehr gebraucht.
 */
require_once(dirname(__FILE__).'/php52.php');
require_once(dirname(__FILE__).'/IEnum.php');

 
/**
 * Die Funktion createEnum erstellt eine Enumklasse
 * @param String    Name des Enums
 * @param Array oder Werteliste (siehe Beispiele)
 * @example
 *      // Enum erstellen mit einer beliebigen Anzahl Parameter
 *      createEnum('Enum1', 'a', 'b');
 *      echo Enum1::a(); //-> a
 *
 *      // Enum erstellen mit einem Array. Der Key ist der Name der Funktion
 *      createEnum('Enum2', array('A' => 'aa', 'B' => 'bb'));
 *      echo Enum2::B(); //-> bb
 *      
 *      // Enum erstellen mit einem Array. Der Funktionsname ist gleich dem value
 *      createEnum('Enum3', array('aaa', 'bbb'));
 *      echo Enum3::aaa(); //-> aaa
 */
function createEnum($name, $enums){
	$params = func_get_args();  
	return call_user_func_array(array('Enum', 'create'), $params);
}

/*
* @example
*   class Enum1 extends AbstractEnum{
*       // die ersten 3 Funktionen müssen so 1:1 übernommen werden
*       protected static function className(){return __CLASS__;}
*       public static function getInstance(){return new self();}
*       public static function getEnum($value){$e = new self(); return $e->createEnum($value);}
*       // Ab hier kommen die verschiedenen Enums
*       public static function A(){return new self('a');}
*       public static function B(){return new self('b');}
*   }
*  
*   $enum = Enum1::A();
*   switch ($enum){
*       case Enum1::A(): echo 'a'; break;
*       case Enum1::B(): echo 'b'; break;
*       default: echo 'default';
*   }
*   if (Enum1::A()->equal($enum)) echo 'HalloA1';
*   $enum = Enum1::getEnum('a');
*/
class Enum implements IEnum{
	static public $index;
	protected $paramNames = array();

	/**
	 * S T A T I S C H E   M E T H O D E N
	 */
   
	/**
	 * analog der Funktion createEnum($name, $enums)
	 * @param String    Name des Enums
	 * @param Array oder Werteliste (siehe Beispiele)
	 * @static
	 * @example
	 *      // Enum erstellen mit einer beliebigen Anzahl Parameter
	 *      Enum::create('Enum1', 'a', 'b');
	 *      echo Enum1::a();    //-> a
	 *
	 *      // Enum erstellen mit einem Array. Der Key ist der Name der Funktion
	 *      Enum::create('Enum2', array('A' => 'aa', 'B' => 'bb'));
	 *      echo Enum2::B();    //-> bb
	 *      
	 *      // Enum erstellen mit einem Array. Der Funktionsname ist gleich dem Value
	 *      // zusätzlich als ist diese Klasse eine Ableitung von Enum2
	 *      Enum::create('Enum3 extends Enum2', array('aaa', 'bbb'));
	 *      echo Enum3::aaa();  //-> aaa     
	 *      echo Enum3::B();    //-> bb     
	 */
	public static function create($name, $enums){      
		if(!is_array($enums)){
			$enums = func_get_args();
			$name = array_shift($enums);
		}
		// Falls kein extends mitgegeben wurde, die Enum-Klasse als Extends angeben
		if (!preg_match('/^[[:alnum:]_]+[ ]+extends[ ]+[[:alnum:]_]+$/', $name)){
			$name = "{$name} extends ".__CLASS__;
		}
	   
		// Classencode generieren
		$php = "class {$name}{\n";
		foreach($enums as $key => $value){
			if (is_numeric($key)) list($key, $value) = array($value, $value);
			preg_match_all('/[[:alnum:]_]+/i', $key, $keyElements);
			$key = implode('', $keyElements[0]);            
			$php .= "public static function {$key}(){return new self('{$value}');}\n";    
		}    
		$php .= "}\n";      
		eval($php);
	}
   
	/**
	 * erstellt eine leere Instance der Enumklasse. Dies wird verwednet um auf
	 * Funktionen wie getEnum() etc zuzugreiffen ohne einen bestimmten ENUM auszuwählen
	 * @return Enum
	 * @static
	 */  
	public static function getInstance(){
		$class = get_called_class();
		return new $class();        
	}
	   
	/**
	 * Erstellt ein Enum anhand des Wertes
	 * @param Wert
	 * @return Enum
	 * @static
	 */
	public static function getEnum($value){
		return self::getInstance()->__getEnum($value, get_called_class());
	}
   
	/**
	 * Erstellt ein Enum anhand des Keys
	 * @param $key
	 * @return Enum
	 * @static
	 */
	public static function getEnumKey($key){
		return self::getInstance()->__getEnumKey($key, get_called_class());
	}    
   
	/**
	 * wandelt die Enums in einen Array array('EnumName' => EnumValue)
	 * @return array
	 * @static
	 */
	public static function toArray($paramName = 'value'){
		return self::getInstance()->__toArray(get_called_class(), 'value');
	}
	
	/**
	 * gibt alle Values als Array aus
	 * @param $glue
	 * @return String
	 * @static
	 */
	public static function implode($glue, $paramName = 'value'){
		return implode($glue, self::toArray());
	}
   
	/**
	 * O B J E K T - M E T H O D E N
	 */
	
	/**
	 * constructer
	 * @param $value
	 * @param $paramlist
	 */
	public function __construct($value = NULL){
		$this->params = func_get_args();
		$this->value = array_shift($this->params);
		foreach($this->paramNames as $index => $name){
			$this->$name = $this->params[$index];
		}
	}
	/**
	 * gibt den Enum als String zurück. Dies entspricht dem Value
	 * @return String
	 */
	public function __toString(){
		return (String) $this->value;
	}
	/**
	 * überprüft ob der Enum dem ausgewählten Enum entspricht
	 * @param $var
	 * @return Boolean
	 * @example
	 *          $enum = Enum1::A();
	 *          if (Enum1::A()->equal($enum)) echo 'HalloA1';
	 */
	public function equal($var){
		return (Boolean) (is_a($var, get_called_class())) and ($var == $this);
	}
   
	/**
	 * gibt ein Enum anhand eines passenden Wertes zurück
	 * @example
	 *      $enum = Enum1::getInstance()->__getEnum('a');    
	 * @param $value
	 * @param $className
	 * @return Enum
	 */
	public function __getEnum($value, $className){
		if($func = array_search($value, $this->__toArray($className))) return $this->$func();
		throw new Exception("no Enum found for '{$value}' in '{$className}'");
	}
	
	/**
	 * Erstellt ein Array mit allen Enums dieses Types
	 * @example $array = Enum1::getInstance()->__toArray();
	 * @return array('EnumName' => 'value')
	 */
	protected function __toArray($className, $paramName = 'value'){
		$enums = array_diff(get_class_methods($className), get_class_methods(__CLASS__));
		$er = error_reporting(E_ERROR);
		foreach($enums as $func){
			if($this->$func() instanceof self) $array[$func] = $this->$func()->$paramName;
		}
		error_reporting($er);
		return $array;        
	}
   

	/**
	 * gibt ein Enum anhand eines passenden Wertes zurück
	 * @example
	 *      $enum = Enum1::getInstance()->__getEnum('a');    
	 * @param $value
	 * @access protected
	 * @return Enum
	 */
	protected function __getEnumKey($key, $className){
		if(array_key_exists($key, $this->__toArray($className))) return $this->$key();
		throw new Exception("no Enum found for '{$key}' in '{$className}'");
	}
}
?>