Get values of the defined enumerators as array
@return mixed[]
174458
public function getValues(): array
    {
        $enumeration = $this->enumeration;
        $values      = [];
        foreach ($this->getOrdinals() as $ord) {
            $values[] = $enumeration::byOrdinal($ord)->getValue();
        }
        return $values;
    }
950484
public function getNames()
    {
        $enums = [];

        foreach (static::toArray() as $name => $value) {
            if ($this->has($value)) {
                $enums[] = $name;
            }
        }

        return $enums;
    }
317488
private function getValuesAsArray()
    {
        if ($this->value === null) {
            return is_array($this->defaultValue) 
                ? $this->defaultValue 
                : [ $this->defaultValue ];
        }
        return $this->value;
    }
294523
public function toArray()
    {
        $arr = [];
        foreach ($this as $k => $entry) {
            if (!$entry instanceof Generic) {
                continue;
            }
            $arr[$k] = $entry->value;
        }
        return $arr;
    }
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;
        }
710235
public function values(): array
    {
        $ret = [];
        foreach (array_keys($this->__data) as $key) {
            $ret[$key] = $this->innerGet($key);
        }
        return $ret;
    }
44859
public function getComputedProperties()
    {
        $result = array();

        if($row = $this->getIterator()->current()) {
            $result = $row->getComputedProperties();
        }

        return $result;
    }
1327190
public function toArray(): array
    {
        return [
            'type' => $this->type,
            'configuration' => $this->configuration,
            'weight' => $this->weight,
            'score_mode' => $this->scoreMode,
            'filter' => ($this->filter instanceof Filter
                ? $this
                    ->filter
                    ->toArray()
                : null),
        ];
    }
1302181
public function getValues()
    {
        $values = array();
        foreach ($this->rows as $name => $row) {
            $values[$name] = $row->getValue();
        }

        return $values;
    }
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();
    }
350471
function getValues()
    {
        $values = $this->getValue();
        $v = is_array($values)? $values : [$values];
        $r = [];
        foreach ($v as $name => $value){
            $r[$name] = new Values($value);
        }
        return $r;
    }
1056844
public function getEnum()
    {
        $classNames = ClassInfo::subclassesFor($this->getBaseClass());
        $dataobject = strtolower(DataObject::class);
        unset($classNames[$dataobject]);
        return array_values($classNames);
    }
1362045
public function toArray()
    {
        return [
            'folderId' => $this->folder->getId(),
            'usageType' => $this->usageType,
            'usageId' => $this->usageId,
            'status' => $this->status,
        ];
    }
349927
public function getKeyValuePair() {
        $result = array();

        foreach ($this->items as $key => $entry) {
            $result[$key] = $entry->value;
        }

        return $result;
    }
1106790
public function getArray()
    {
        $options = [];

        if ($this->isDisabled() || $this->canHaveValue() && empty($this->values)) {
            return $options;
        }

        foreach ($this->values as $value) {
            $options[] = $this->flag();
            $options[] = $value;
        }

        if (empty($options)) {
            $options[] = $this->flag();
        }

        return $options;
    }
830833
public static function getValues(): array
    {
        $values = [];
        foreach (self::TYPES as $type) {
            $values[$type] = self::getValue($type);
        }

        return $values;
    }
1045160
public function getMutators(): array
    {
        $mutators = $this->reflection->getMutators();

        //Trying to resolve mutators based on field type
        foreach ($this->getFields() as $field => $type) {
            //Resolved mutators
            $resolved = [];

            if (
                is_array($type)
                && is_scalar($type[0])
                && $filter = $this->mutatorsConfig->getMutators('array::' . $type[0])
            ) {
                //Mutator associated to array with specified type
                $resolved += $filter;
            } elseif (is_array($type) && $filter = $this->mutatorsConfig->getMutators('array')) {
                //Default array mutator
                $resolved += $filter;
            } elseif (!is_array($type) && $filter = $this->mutatorsConfig->getMutators($type)) {
                //Mutator associated with type directly
                $resolved += $filter;
            }

            //Merging mutators and default mutators
            foreach ($resolved as $mutator => $filter) {
                if (!array_key_exists($field, $mutators[$mutator])) {
                    $mutators[$mutator][$field] = $filter;
                }
            }
        }

        return $mutators;
    }