Version 2.0

README.md

@@ -42,9 +42,6 @@ class Action extends Enum
 ## Usage
 
 ```php
-$action = new Action(Action::VIEW);
-
-// or
 $action = Action::VIEW();
 ```
 
@@ -58,9 +55,22 @@ function setAction(Action $action) {
 }
 ```
 
+Each Enum instance for a given key is a singleton, so you can use:
+
+```php
+function setAction(Action $action) {
+    if ($action === Action::VIEW()) {
+        //
+    }
+}
+```
+
+**Note** that this is not true, if you `unserialize()` Enums.
+In case another Enum instance already exists,
+an `E_USER_NOTICE` is triggered.
+
 ## Documentation
 
-- `__construct()` The constructor checks that the value exist in the enum
 - `__toString()` You can `echo $myValue`, it will display the enum value (value of the constant)
 - `getValue()` Returns the current value of the enum
 - `getKey()` Returns the key of the current value on Enum
@@ -74,6 +84,8 @@ Static methods:
 - `isValid()` Check if tested value is valid on enum set
 - `isValidKey()` Check if tested key is valid on enum set
 - `search()` Return key for searched value
+- `fromKey()` Return Enum instance for the given key
+- `fromValue()` Return Enum instance for the given value
 
 ### Static methods
 
@@ -91,23 +103,8 @@ $action = Action::EDIT();
 
 Static method helpers are implemented using [`__callStatic()`](http://www.php.net/manual/en/language.oop5.overloading.php#object.callstatic).
 
-If you care about IDE autocompletion, you can either implement the static methods yourself:
-
-```php
-class Action extends Enum
-{
-    const VIEW = 'view';
-
-    /**
-     * @return Action
-     */
-    public static function VIEW() {
-        return new Action(self::VIEW);
-    }
-}
-```
-
-or you can use phpdoc (this is supported in PhpStorm for example):
+If you care about IDE autocompletion,
+you can use phpdoc (this is supported in PhpStorm for example):
 
 ```php
 /**

src/Enum.php

@@ -6,6 +6,8 @@
 
 namespace MyCLabs\Enum;
 
+use BadMethodCallException;
+
 /**
  * Base Enum class
  *
@@ -18,32 +20,27 @@
 abstract class Enum
 {
     /**
-     * Enum value
+     * Enum name
      *
-     * @var mixed
+     * @var string
      */
-    protected $value;
+    private $name;
 
     /**
-     * Store existing constants in a static cache per object.
+     * Enum value
      *
-     * @var array
+     * @var mixed
      */
-    protected static $cache = array();
+    private $value;
 
     /**
      * Creates a new value of some type
      *
      * @param mixed $value
-     *
-     * @throws \UnexpectedValueException if incompatible type is given.
      */
-    public function __construct($value)
+    final private function __construct($name, $value)
     {
-        if (!$this->isValid($value)) {
-            throw new \UnexpectedValueException("Value '$value' is not part of the enum " . get_called_class());
-        }
-
+        $this->name = $name;
         $this->value = $value;
     }
 
@@ -62,7 +59,7 @@ public function getValue()
      */
     public function getKey()
     {
-        return static::search($this->value);
+        return $this->name;
     }
 
     /**
@@ -74,15 +71,14 @@ public function __toString()
     }
 
     /**
-     * Compares one Enum with another.
-     *
-     * This method is final, for more information read https://github.com/myclabs/php-enum/issues/4
-     *
-     * @return bool True if Enums are equal, false if not equal
+     * Register object in cache and trigger a notice if it already exists.
      */
-    final public function equals(Enum $enum)
+    public function __wakeup()
     {
-        return $this->getValue() === $enum->getValue() && get_called_class() == get_class($enum);
+        $enum = EnumManager::get($this);
+        if ($enum !== $this) {
+            trigger_error("Enum is already initialized", E_USER_NOTICE);
+        }
     }
 
     /**
@@ -104,8 +100,8 @@ public static function values()
     {
         $values = array();
 
-        foreach (static::toArray() as $key => $value) {
-            $values[$key] = new static($value);
+        foreach (static::toArray() as $name => $value) {
+            $values[$name] = EnumManager::get(new static($name, $value));
         }
 
         return $values;
@@ -118,13 +114,7 @@ public static function values()
      */
     public static function toArray()
     {
-        $class = get_called_class();
-        if (!array_key_exists($class, static::$cache)) {
-            $reflection            = new \ReflectionClass($class);
-            static::$cache[$class] = $reflection->getConstants();
-        }
-
-        return static::$cache[$class];
+        return EnumManager::constants(new static(null, null));
     }
 
     /**
@@ -165,22 +155,54 @@ public static function search($value)
         return array_search($value, static::toArray(), true);
     }
 
+    /**
+     * Returns Enum by value
+     *
+     * @return static
+     */
+    public static function fromValue($value)
+    {
+        $name = static::search($value);
+        if ($name === false) {
+            return null;
+        }
+
+        return EnumManager::get(new static($name, $value));
+    }
+
+    /**
+     * Returns Enum by key
+     *
+     * @return static
+     */
+    public static function fromKey($name)
+    {
+        $array = static::toArray();
+        if (isset($array[$name]) || array_key_exists($name, $array)) {
+            return EnumManager::get(new static($name, $array[$name]));
+        }
+
+        return null;
+    }
+
     /**
      * Returns a value when called statically like so: MyEnum::SOME_VALUE() given SOME_VALUE is a class constant
      *
      * @param string $name
      * @param array  $arguments
      *
      * @return static
-     * @throws \BadMethodCallException
+     * @throws BadMethodCallException
      */
     public static function __callStatic($name, $arguments)
     {
-        $array = static::toArray();
-        if (isset($array[$name])) {
-            return new static($array[$name]);
+        $result = static::fromKey($name);
+
+        if ($result === null) {
+            $msg = "No static method or enum constant '$name' in class " . get_called_class();
+            throw new BadMethodCallException($msg);
         }
 
-        throw new \BadMethodCallException("No static method or enum constant '$name' in class " . get_called_class());
+        return $result;
     }
 }

src/EnumManager.php

@@ -0,0 +1,55 @@
+<?php
+/**
+ * @link    http://github.com/myclabs/php-enum
+ * @license http://www.opensource.org/licenses/mit-license.php MIT (see the LICENSE file)
+ */
+
+namespace MyCLabs\Enum;
+
+use ReflectionObject;
+
+/**
+ * Enum instance manager
+ *
+ * @internal
+ */
+abstract class EnumManager
+{
+    /**
+     * Store existing Enum instances.
+     *
+     * @var array
+     */
+    private static $instances = array();
+
+    /**
+     * Returns the Enum instance for the given prototype
+     *
+     * @return Enum
+     */
+    public static function get(Enum $enum)
+    {
+        $reflection = new ReflectionObject($enum);
+        $class = $reflection->getName();
+        $name = $enum->getKey();
+
+        if (isset(self::$instances[$class][$name])) {
+            return self::$instances[$class][$name];
+        }
+
+        self::$instances[$class][$name] = $enum;
+        return $enum;
+    }
+
+    /**
+     * Returns all possible values as an array
+     *
+     * @return array Constant name in key, constant value in value
+     */
+    public static function constants(Enum $enum)
+    {
+        $reflection = new ReflectionObject($enum);
+        $result = $reflection->getConstants();
+        return $result;
+    }
+}