Get the possible values of the enumaration as an array.

@return array An array of integer constants.
189943
public static function asArray()
    {
        return array(
            'AUTHOR' => self::AUTHOR,
            'CANDIDATE' => self::CANDIDATE,
            'PROCTOR' => self::PROCTOR,
            'SCORER' => self::SCORER,
            'TEST_CONSTRUCTOR' => self::TEST_CONSTRUCTOR,
            'TUTOR' => self::TUTOR
        );
    }
1298730
public function toArray()
    {
        $values = $this->values;
        return array_map(
            function ($cursor) use ($values) {
                return $values[$cursor];
            },
            $this->nameToCursor
        );
    }
3359
public function toArray()
    {
        $name = $this->name();

        $value = $this->computeValue();
        $delta = $this->computeDelta();

        return [
            'name' => $name,
            'key' => $this->key(),
            'granularity' => $this->granularity(),
            'prefix' => $this->prefix(),
            'suffix' => $this->suffix(),
            'hasChart' => $this->hasChart(),
            'span' => $this->span(),
            'value' => $value,
            'abbreviated_value' => (is_numeric($value)) ? U::number_abbreviate(round($value, 2), 1) : $value,
            'delta' => $delta,
            'abbreviated_delta' => (is_numeric($delta)) ? U::number_abbreviate(round($delta, 2), 1) : $delta,
        ];
    }
1022325
public static function getAllValues(): array
	{
		$enumerables = self::getCache();
		$result = [];

		foreach ($enumerables as $enumerable => $value) {
			$result[] = $value;
		}

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

        return $values;
    }
1255591
public function toArray()
    {
        $result = parent::toArray();
        $result['latitude']     = $this->latitude;
        $result['longitude']    = $this->longitude;
        $result['precision']    = $this->precision;

        return $result;
    }
317488
private function getValuesAsArray()
    {
        if ($this->value === null) {
            return is_array($this->defaultValue) 
                ? $this->defaultValue 
                : [ $this->defaultValue ];
        }
        return $this->value;
    }
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];
    }
1311661
public function getValues()
        {
            $values = [];

            foreach ($this->parts as $part) {
                if ($part instanceof Criterion) {
                    if ($part->getValue() !== null) {
                        $values[] = $part->getValue();
                    }
                } else {
                    foreach ($part->getValues() as $value) {
                        if ($value !== null) {
                            $values[] = $value;
                        }
                    }
                }
            }

            return $values;
        }
1293051
public function values()
    {
        $result = [];
        foreach ($this->collection() as $param) {
            $result = $result + $param->values();
        }

        return $result;
    }
1312490
private function parseArray()
    {
        $length = $this->parseUnsignedInt32();
        $stopAt = strlen($this->buffer) - $length;
        $array = [];

        while (strlen($this->buffer) > $stopAt) {
            $array[] = $this->parseField();
        }

        return $array;
    }
78837
public function getValue()
    {
        $values = [];
        
        $this->getChildren()->forAll(function (ElementInterface $child) use (&$values) {
            foreach ($this->locales as $locale) {
                $values[$locale['code']][$child->getName()] = $this->getChildValue($child, $locale['code']);
            }
        });
        
        return $values;
    }
427522
public function toArray()
    {
        return [
            'name' => $this->getName(),
            'text' => $this->getText(),
            'style' => $this->getStyle(),
            'type' => $this->getType(),
            'value' => $this->getValue(),
            'confirm' => $this->getConfirm()->toArray(),
        ];
    }
13086
public function getEnumerations()
    {
        $enums = array();
        foreach ($this->element->getElementsByTagName('enumeration') as $enum) {
            $enums[] = $enum->getAttribute('value');
        };
        return $enums;
    }
710235
public function values(): array
    {
        $ret = [];
        foreach (array_keys($this->__data) as $key) {
            $ret[$key] = $this->innerGet($key);
        }
        return $ret;
    }
244887
public function toArray() {
        $out = [];
        for ($i=static::ROWS;$i-->0;) {
            $out[$i] = $this[$i]->toArray();
        }
        return $out;
    }
18117
final public static function getMembers(): array
    {
        if (!isset(self::$constants[static::class])) {
            $reflection = new ReflectionClass(static::class);
            $constants = self::sortConstants($reflection);
            self::guardConstants($constants);
            self::$constants[static::class] = $constants;
        }

        return self::$constants[static::class];
    }