Enumerable in PHP

<?PHP
    /**
     * ILLI
     *
     * @category   ILLI
     * @package    ILLI
     * @subpackage SystemType
     * @link       http://illi.be
     * @license    http://l.illi.be
     * @copyright  ILLI Conference
     */

    /**
     * ILLI System Type Enum
     *
     * @category   ILLI
     * @package    ILLI
     * @subpackage SystemType
     * @link       http://illi.be
     * @license    http://l.illi.be
     * @copyright  ILLI Conference
     */
    ABSTRACT CLASS ILLI_System_Type_Enum EXTENDS ILLI_System_Type_Abstract
    {
        private static $__reflectionBase    = NULL;
        private static $__constantsBase     = array();

        private $__reflectionClass      = NULL;
        private $__constantsClass       = array();

        private $__definedConstants     = NULL;

        private $__definedDefault       = NULL;
        private $__initValue            = NULL;
        private $__definedValue         = NULL;

        const STRICT_INTEGER            = 0x00000001;
        const STRICT_STRING         = 0x00000002;
        const STRICT_FLOAT          = 0x00000004;

        const STRICT_SCALAR         = 0x00000007;


        const STRICT_TYPE           = 0x00000001;

        private $mode               = 0;


        final public function __construct($default = NULL)
        {
            if(NULL === self::$__reflectionBase)
            {
                self::$__reflectionBase  = new ReflectionClass(__CLASS__);
                self::$__constantsBase   = self::$__reflectionBase->getConstants();
            }
            $this->__reflectionClass = new ReflectionClass($this->getQualifiedName());
            $this->__constantsClass  = $this->__reflectionClass->getConstants();

            // hide constants from base
            $diff = array_intersect_assoc(self::$__constantsBase, $this->__constantsClass);
            foreach($diff as $const => $val)
                unset($this->__constantsClass[$const]);

            $this->__definedConstants = new ILLI_System_Type_AssocArray($this->__constantsClass);

            if(sizeOf($this->__constantsClass) <= 1)
                throw new ILLI_Exception_ArgumentExpected
                (
                    ILLI_System_E::ARGUMENT_EXPECTED_ENUMERABLE_CONSTANT_EXPECTED,
                    array($this->getQualifiedName())
                );

            if(FALSE === $this->__definedConstants->offsetExists('__DEFAULT'))
                throw new ILLI_Exception_ArgumentExpected
                (
                    ILLI_System_E::ARGUMENT_EXPECTED_ENUMERABLE_DEFAULT_EXPECTED,
                    array
                    (
                        $this->getQualifiedName(),
                        '__DEFAULT'
                    )
                );

            $this->__definedDefault = $this->__definedConstants->offsetGet('__DEFAULT');

            if(NULL === $this->__definedDefault)
                throw new ILLI_Exception_ArgumentExpected
                (
                    ILLI_System_E::ARGUMENT_EXPECTED_ENUMERABLE_IS_NULL,
                    array
                    (
                        $this->getQualifiedName(),
                        '__DEFAULT'
                    )
                );

            $this->__definedConstants->offsetUnset('__DEFAULT');

            if(FALSE === $this->isDefinedValue($this->__definedDefault))
                throw new ILLI_Exception_ArgumentExpected
                (
                    ILLI_SYSTEM_E::ARGUMENT_EXPECTED_ENUMERABLE_DEFINED_EXPECTED,
                    array
                    (
                        $this->getQualifiedName(),
                        '__DEFAULT',
                        $this->__definedDefault
                    )
                );

            if(NULL === $default)
                $default = $this->__definedDefault;

            $this->define($default);
            $this->__initValue = $default;
        }

        final public function define($value)
        {
            try
            {
                if(FALSE === $this->isDefinedValue($value))
                    throw new ILLI_Exception_ArgumentOutOfRange
                    (
                        ILLI_SYSTEM_E::ARGUMENT_OUT_OF_ENUM_INDEX,
                        array($value)
                    );
            }
            catch(ILLI_Exception_ArgumentOutOfRange $e)
            {
                throw $e;
            }
            catch(ILLI_Exception_Argument $e)
            {
                throw new ILLI_Exception_ArgumentOutOfRange
                (
                    ILLI_SYSTEM_E::ARGUMENT_OUT_OF_ENUM_INDEX,
                    $e,
                    array($const)
                );
            }

            $this->__definedValue = $value;
        }

        final public function getValues()
        {
            return $this->__definedConstants->getValues();
        }

        final public function getNames($value = NULL)
        {
            return $this->__definedConstants->getOffsets($value);
        }

        final public function getValue($const)
        {
            try
            {
                if(FALSE === $this->isDefinedConst($const))
                    throw new ILLI_Exception_ArgumentOutOfRange
                    (
                        ILLI_SYSTEM_E::ARGUMENT_OUT_OF_ENUM_INDEX,
                        array($const)
                    );
            }
            catch(ILLI_Exception_ArgumentOutOfRange $e)
            {
                throw $e;
            }
            catch(ILLI_Exception_Argument $e)
            {
                throw new ILLI_Exception_ArgumentOutOfRange
                (
                    ILLI_SYSTEM_E::ARGUMENT_OUT_OF_ENUM_INDEX,
                    $e,
                    array($const)
                );
            }

            return $this->__definedConstants->offsetGet($const);
        }

        final public function reset()
        {
            $this->define($this->__initValue);
        }

        final public function getDefinedValue()
        {
            return $this->__definedValue;
        }

        final public function getDefinedName()
        {
            $res = $this->getDefinedNames();
            return array_shift($res);
        }

        final public function getDefinedNames()
        {
            return $this->getNames($this->__definedValue);
        }

        final public function getDefaultValue()
        {
            return $this->__initValue;
        }

        final public function getDefaultName()
        {
            $res = $this->getDefaultNames();
            return array_shift($res);
        }

        final public function getDefaultNames()
        {
            return $this->getNames($this->__initValue);
        }

        public function __toString()
        {
            return (string) $this->getDefinedValue();
        }

        public function __invoke()
        {
            return $this->getDefinedValue();
        }

        private function isDefinedValue($value)
        {
            if(NULL === $value)
                throw new ILLI_Exception_ArgumentNull;

            if(!is_integer($value))
                throw new ILLI_Exception_ArgumentExpected
                (
                    ILLI_System_E::ARGUMENT_EXPECTED_INTEGER
                );

            foreach($this->__definedConstants as $key => $val)
                if($value === $val)
                    return TRUE;

            return FALSE;
        }

        private function isDefinedConst($const)
        {
            if(NULL === $const)
                throw new ILLI_Exception_ArgumentNull;

            if(!is_string($const))
                throw new ILLI_Exception_ArgumentExpected
                (
                    ILLI_System_E::ARGUMENT_EXPECTED_STRING
                );

            return $this->__definedConstants->offsetExists($const);
        }
    }