Enumeration.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Type;

use TYPO3\CMS\Core\Type\Exception;

abstract class Enumeration implements TypeInterface {

    protected $value;

    protected static $enumConstants;

    public function __construct($value = NULL) {
        if ($value === NULL && !defined('static::__default')) {
            throw new Exception\InvalidEnumerationValueException(
                sprintf('A value for %s is required if no __default is defined.', get_class($this)),
                1381512753
            );
        }
        if ($value === NULL) {
            $value = static::__default;
        }
        static::loadValues();
        if (!$this->isValid($value)) {
            throw new Exception\InvalidEnumerationValueException(
                sprintf('Invalid value %s for %s', $value, get_class($this)),
                1381512761
            );
        }
        $this->setValue($value);
    }

    static protected function loadValues() {
        $class = get_called_class();

        if (isset(static::$enumConstants[$class])) {
            return;
        }

        $reflection = new \ReflectionClass($class);
        $constants = $reflection->getConstants();
        $defaultValue = NULL;
        if (isset($constants['__default'])) {
            $defaultValue = $constants['__default'];
            unset($constants['__default']);
        }
        if (empty($constants)) {
            throw new Exception\InvalidEnumerationValueException(
                sprintf(
                    'No enumeration constants defined for "%s"', $class
                ),
                1381512807
            );
        }
        foreach ($constants as $constant => $value) {
            if (!is_int($value) && !is_string($value)) {
                throw new Exception\InvalidEnumerationDefinitionException(
                    sprintf(
                        'Constant value must be of type integer or string; constant=%s; type=%s',
                        $constant,
                        is_object($value) ? get_class($value) : gettype($value)
                    ),
                    1381512797
                );
            }
        }
        $constantValueCounts = array_count_values($constants);
        arsort($constantValueCounts, SORT_NUMERIC);
        $constantValueCount = current($constantValueCounts);
        $constant = key($constantValueCounts);
        if ($constantValueCount > 1) {
            throw new Exception\InvalidEnumerationDefinitionException(
                sprintf(
                    'Constant value is not unique; constant=%s; value=%s; enum=%s',
                    $constant, $constantValueCount, $class
                ),
                1381512859
            );
        }
        if ($defaultValue !== NULL) {
            $constants['__default'] = $defaultValue;
        }
        static::$enumConstants[$class] = $constants;
    }

    protected function setValue($value) {
        $enumKey = array_search($value, static::$enumConstants[get_class($this)]);
        if ($enumKey === FALSE) {
            throw new Exception\InvalidEnumerationValueException(
                sprintf('Invalid value %s for %s', $value, __CLASS__),
                1381615295
            );
        }
        $this->value = static::$enumConstants[get_class($this)][$enumKey];
    }

    protected function isValid($value) {
        $value = (string) $value;
        foreach (static::$enumConstants[get_class($this)] as $constantValue) {
            if ($value === (string) $constantValue) {
                return TRUE;
            }
        }
        return FALSE;
    }

    static public function getConstants($include_default = FALSE) {
        static::loadValues();
        $enumConstants = static::$enumConstants[get_called_class()];
        if (!$include_default) {
            unset($enumConstants['__default']);
        }
        return $enumConstants;
    }

    public static function cast($value) {
        $currentClass = get_called_class();
        if (!is_object($value) || get_class($value) !== $currentClass) {
            $value = new $currentClass($value);
        }
        return $value;
    }

    public function equals($value) {
        $value = static::cast($value);
        return $this == $value;
    }

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