Gets an array of all registered elements of the enum.

@return static[] an array containing all elements in the enum
548799
public static final function values() {
			if (!static::isDone())
				static::autoload();

			$key = get_called_class();

			if (array_key_exists($key, self::$types))
				return self::$types[$key];

			return array();
		}
370841
final public function getAllValues() {
        $subClass = get_called_class();

        // Subclass has already been registered
        if(isset($this->_cachedEnums[$subClass])) {
            return FALSE;
        }

        $reflection = new \ReflectionClass($subClass);

        return $reflection->getConstants();
    }
1195396
public static function getAllNames()
    {
        $className = get_called_class();

        if (!array_key_exists($className, self::$constantsArray)) {
            try {
                $class = new ReflectionClass($className);
            } catch (ReflectionException $e) {
                throw new RuntimeException($e->getMessage(), (int)$e->getCode(), $e);
            }

            self::$constantsArray[$className] = array_keys($class->getConstants());
        }

        return self::$constantsArray[$className];
    }
1369503
public function getAll(): array
    {
        $namespace = $this->getNamespace();
        $length = mb_strlen($namespace);

        $values = [];

        $data = $this->session->getAll();
        foreach ($data as $key => $val) {
            if (mb_substr($key, 0, $length) === $namespace) {
                $key = mb_substr($key, $length);
                $values[$key] = $val;
            }
        }

        return $values;
    }
294790
public static function instances()
    {
        $all = [];
        foreach (static::getNames() as $name => $val) {
            $all[] = new static($name, $val);
        }
        return $all;
    }
300826
public static function enumFonts() {
        return [
            FontAwesomeIconInterface::FONT_AWESOME_FONT,
            FontAwesomeIconInterface::FONT_AWESOME_FONT_BOLD,
            FontAwesomeIconInterface::FONT_AWESOME_FONT_LIGHT,
            FontAwesomeIconInterface::FONT_AWESOME_FONT_REGULAR,
            FontAwesomeIconInterface::FONT_AWESOME_FONT_SOLID,
        ];
    }
1369062
public static function toArray()
    {
        $reflectionClass = new \ReflectionClass(get_called_class());
        $parentRelectionClass = $reflectionClass->getParentClass();

        return array_diff(
            $reflectionClass->getConstants(),
            $parentRelectionClass->getConstants()
        );
    }
1106532
public function getElements()
    {
        foreach ($this->elements as $name => $element) {
            $this->resolveXRef($name);
        }

        return $this->elements;
    }
667982
public function all(): array
    {
        $out = [];
        foreach (parent::all() as $key => $props) {
            $out[$props['originalKey']] = $props['value'];
        }

        return $out;
    }
418501
public function getRegistryNames() : array
    {
        $names = [];
        foreach ($this->getRegistry() as $registryName=>$registryValue)
        {
            $names[] = $registryName;
        }

        return $names;
    }
355090
public function getVariables()
    {
        if (!$this->getUseIndex()) {
            return array();
        }

        $staticVariables = $this->reflection->getStaticVariables();

        // When looping through the variables, we will only take the variables that are
        // specified in the use clause, and will not take any other static variables
        // that may be used by the Closures, allowing this to re-create its state.
        $usedVariables = array();

        foreach ($this->getUseClauseVariables() as $variable) {
            $variable = trim($variable, ' $&');

            $usedVariables[$variable] = $staticVariables[$variable];
        }

        return $usedVariables;
    }
1363788
static function all(): array
    {
        $instances = [];

        foreach (static::getMap() as $key => $value) {
            $instances[$key] = self::$instanceCache[static::class][$key]
                ?? (self::$instanceCache[static::class][$key] = new static($key, $value));
        }

        return $instances;
    }
103228
public static function enumTypes() {
        return [
            DataTablesColumnInterface::DATATABLES_TYPE_DATE,
            DataTablesColumnInterface::DATATABLES_TYPE_HTML,
            DataTablesColumnInterface::DATATABLES_TYPE_HTML_NUM,
            DataTablesColumnInterface::DATATABLES_TYPE_NUM,
            DataTablesColumnInterface::DATATABLES_TYPE_NUM_FMT,
            DataTablesColumnInterface::DATATABLES_TYPE_STRING,
        ];
    }
1227366
public function toArray() {
		return array_filter(array(
			'name' => $this->getAttributeName(),
			'required' => $this->required,
			'type' => $this->type,
			'enum' => $this->getEnumOptions(),
			'default' => $this->default,
		));
	}
140296
public static function all()
    {
        $result = [];
        foreach (self::getConstants() as $k => $v) {
            if (static::isValid($v)) {
                /** @var Value $object */
                $object = new static($v);
                $result[$object->getValue()] = $object;
            }
        }

        return $result;
    }
699733
public static function values()
    {
        $values = [];
        foreach (static::toList() as $key => $value) {
            $values[$key] = new static($value);
        }

        return $values;
    }
625910
public static function getList()
    {
        return [
            static::CHOICE,
            static::CLOZE,
            static::GRAPHIC,
            static::MATCH,
            static::PAIR,
            static::SET,
            static::WORDS,
            static::OPEN,
            static::SELECTION,
            static::GRID,
            static::CONTENT,
            static::ORDERING,
            static::BOOLEAN,
        ];
    }