Return the field values for the redo code.

<ul><li>0: do not redo</li>
<li>1: redo but do not copy answers</li>
<li>2: redo and copy answers</li></ul>

@staticvar array $data
@return array
9217
public function getRedoValues()
    {
        static $data;

        if (! $data) {
            $data = array(
                self::REDO_NONE => $this->_('No'),
                self::REDO_ONLY => $this->_('Yes (forget answers)'),
                self::REDO_COPY => $this->_('Yes (keep answers)'));
        }

        return $data;
    }
530797
public function getRawValues()
    {
        $values = array();
        foreach ($this->_inputs as $name => $input) {
            /** @var Input $input */
            $values[$name] = call_user_func_array(
                [$input, 'getRawValue'],
                [$name]
            );
        }
        return $values;
    }
589381
public static function completeFields($data) {
		foreach( static::$fields as $fieldname ) {
			if( !isset($data[$fieldname]) ) {
				$data[$fieldname] = '';
			}
		}
		return $data;
	}
168304
public function decode(string $data): array
    {
        $rawData = [];
        parse_str($data, $rawData);

        if ('' !== $data && [] === $rawData) {
            throw DeserializerRuntimeException::createNotParsable($this->getContentType());
        }

        return $this->fixValues($rawData);
    }
741365
public function getValues()
    {
        $result = [];
        $defaults = $this->defaults();
        foreach ($defaults as $name => $value) {
            if ($this->getData()->has($name)) {
                $result[$name] = $this->getData()->get($name);
            } else {
                $result[$name] = $value;
            }
        }
        return $result;
    }
392901
protected function processRetrievedData($data = [])
    {
        $items = [];

        foreach ($data as $eloquent) {
            $value = $eloquent->name;


            foreach ($eloquent->group as $group) {
                $value         = implode('.', [$eloquent->name, $group->name]);
                $this->addKey($value, [
                    'id'    => $group->id,
                    'value' => $value,
                ]);
                $items[$value] = $value;
            }
        }
        return $items;
    }
447513
public function getData()
    {
        $data = [];

        foreach (static::$_classFields[get_called_class()] as $field => $options) {
            $data[$field] = $this->_getFieldValue($field);
        }

        if ($this->validationErrors) {
            $data['validationErrors'] = $this->validationErrors;
        }

        return $data;
    }
597709
public function getData() : ?array
     {
        $rtn = $this->data['data'];

        $rtn = json_decode($rtn, true);

        if ($rtn === false) {
            $rtn = null;
        }

        return $rtn;
     }
439579
protected function getListFieldValue()
    {
        $conditions = $this->query_filter;
        $conditions['limit'] = $this->data_limit;
        $conditions['field_id'] = $this->data_field['field_id'];

        $list = (array) $this->field_value->getList($conditions);
        $this->prepareListFieldValue($list);
        return $list;
    }
985976
protected function getRealValues(array $data) {
        $maps = Arr::getRealType($this->modelName);
        return empty($maps) ? $data : Arr::toRealArr($data, $maps);
    }
19032
final public static function getValues(): array
    {
        if (isset(self::$cache[static::class])) {
            return self::$cache[static::class];
        }

        $rc = new \ReflectionClass(static::class);

        return self::$cache[static::class] = $rc->getConstants();
    }
820151
public function getDirty()
    {
        $dirty = [];
        foreach ($this->getCurrent() as $key => $value) {

            // Value is a default value and `no_saving_default_values` option has been enabled
            if (array_key_exists('no_saving_default_values', $this->internal_options)
                && $this->internal_options['no_saving_default_values']
                && array_key_exists($key, $this->internal_defaults)
                && $this->internal_defaults[$key] === $value) {
                // Do nothing
            }

            // Existing value has changed
            elseif (array_key_exists($key, $this->internal_original_data)
                && $this->internal_original_data[$key] !== $value) {
                $dirty[$key] = $value;
            }

            // New value that has been assigned
            elseif (!array_key_exists($key, $this->internal_original_data)) {
                $dirty[$key] = $value;
            }
        }

        return $dirty;
    }
317488
private function getValuesAsArray()
    {
        if ($this->value === null) {
            return is_array($this->defaultValue) 
                ? $this->defaultValue 
                : [ $this->defaultValue ];
        }
        return $this->value;
    }
211208
public function decode($data): array
    {
        $headerVar = $this->getHeaderField();
        $bodyVar = $this->getBodyField();
        $rawVar = $this->getRawField();

        // Define empty content
        $content = [
            $headerVar => [],
            $bodyVar => ''
        ];

        $headerRegex = "/^---\n(.+?)\n---\n{0,}(.*)$/uis";

        // Normalize line endings to Unix style.
        $data = preg_replace("/(\r\n|\r)/", "\n", $data);

        // Parse header.
        preg_match($headerRegex, ltrim($data), $matches);
        if(empty($matches)) {
            $content[$bodyVar] = $data;
        } else {
            // Normalize frontmatter.
            $frontmatter = preg_replace("/\n\t/", "\n    ", $matches[1]);
            if ($rawVar) {
                $content[$rawVar] = $frontmatter;
            }
            $content[$headerVar] = $this->getHeaderFormatter()->decode($frontmatter);
            $content[$bodyVar] = $matches[2];
        }

        return $content;
    }
1138428
private function all(): array
    {
        $fields = static::$_fields;

        $data = [];
        foreach ($fields as $f) {
            if (isset($this->$f) and !is_null($this->$f)) {
                $data[$f] = $this->$f;
            }
        }

        return $data;
    }
431247
public function getRawValue(): array
	{
		$primaryValues = [];
		foreach ($this->getIterator() as $entity) {
			if ($entity->isPersisted()) {
				$primaryValues[] = $entity->getValue('id');
			}
		}
		return $primaryValues;
	}
513590
public function getDataAsArray()
    {
        $fields = $this->getFields();

        if (!$fields) {
            return [];
        }

        $result = [];

        foreach ($fields as $field) {
            //ignore non-fields
            if (!$field instanceof AbstractFormField) {
                continue;
            }

            // if a field is disabled, we will ignore the field and only set an empty string as value
            if ($field->isDisabled()) {
                if (!array_key_exists($field->getName(), $result)) {
                    $result[$field->getName()] = '';
                }
                continue;
            }


            if ($field instanceof CheckBox) {
                $result[$field->getName()] = $field->isChecked() ? $field->getValue() : '';
            } elseif ($field instanceof RadioButton) {
                // if the field is not checked...
                if (!$field->isChecked()) {
                    // there was no other field with the same name yet
                    if (!array_key_exists($field->getName(), $result)) {
                        // then set the field with an empty value
                        $result[$field->getName()] = '';
                    }
                } // the field is checked
                else {
                    $result[$field->getName()] = $field->getValue();
                }
            } elseif ($field instanceof UploadField) {
                $value = $field->getValue();
                if (!$value ||
                    !isset($value['error']) ||
                    $value['error'] == UPLOAD_ERR_NO_FILE ||
                    empty($value['name'])
                ) {
                    continue;
                }
                $result[$field->getName()] = $value['name'];
            } elseif ($field instanceof AbstractFormField) {
                $result[$field->getName()] = $field->getValue();
            }
        }
        return $result;
    }