@throws InvalidValueDataException

@return mixed
171014
public function getIdentifier()
    {
        $identifierAttribute = $this->getFamily()->getAttributeAsIdentifier();
        if ($identifierAttribute) {
            /** @noinspection ExceptionsAnnotatingAndHandlingInspection */

            return $this->get($identifierAttribute->getCode());
        }

        return $this->getId();
    }
1306346
public function resolveDataValue($data)
    {
        if ($data instanceof Data) {

            return $this->setData($data);

        } elseif (is_array($data)) {

            return $this->setData(new Data($data));
        }

        throw new \InvalidArgumentException(
            "Data must be View\Data or array value"
        );
    }
718369
public function val() {
		if (isset($_POST[$this->paramName])) {
			$value = $_POST[$this->paramName];
			if (get_magic_quotes_gpc()==1)
			{
				// we check first for arrays
				if (is_array($value)){
					if (!array_walk_recursive($value, "stripslashes")) {
						throw new \Exception('<b>Error!</b> An error occured while walking GET array "'.$this->paramName.'".');
					}
						
					return $value;
				}
				
				return stripslashes($value);
			}
			else
			{
				return $value;
			}
		} else {
			if ($this->defaultValue instanceof ValueInterface) {
				return $this->defaultValue->val();
			} else {
				return $this->defaultValue;
			}
		}
	}
511229
public function getValue()
    {
        if (!(is_array($this->data) && count($this->data))) {
            return null;
        }

        return implode('', $this->data);
    }
842086
public function getLoadValue()
    {
        if ($this->formField->value !== null) {
            return $this->formField->value;
        }

        $defaultValue = !$this->model->exists
            ? $this->formField->getDefaultFromData($this->data ?: $this->model)
            : null;

        return $this->formField->getValueFromData($this->data ?: $this->model, $defaultValue);
    }
1042738
protected function initConnectionData()
    {
        if ($this->connectionData) {
            return;
        }

        if (!$this->connectionUrl) {
            throw new \UnexpectedValueException(
                'Expected a connectionUrl, got nowt.'
            );
        }

        $parsed = parse_url($this->connectionUrl);
        if ($parsed === false) {
            throw new UnexpectedValueException(
                'Expected a sensible connectionUrl, got nowt but rubbish.'
            );
        }
        $this->connectionData = $parsed;
    }
648123
protected function getRawValue()
    {
        $value = null;

        $data = &$this->getForm()->getFormData();

        if ($this->autocomplete) {
            $id = $this->id;
            if (isset($data[$id]) && $data[$id] != '') {
                $value = $data[$id];
            }
        } else {
            if (isset($data[$this->id . '_nonce'])) {
                $id = $data[$this->id . '_nonce'];
                if (isset($data[$id]) && $data[$id] != '') {
                    $value = $data[$id];
                }
            }
        }

        return $value;
    }
19984
public function getValidValue()
    {
        $values = [];
        foreach($this->values as $key => $value) {
            if ($this->isValidValue($value)) {
                $values[$key] = $value->getValidValue();
            }
        }
        return $values;
    }
142944
public function createValueBuilder() {
		try {
			return new EagerValueBuilder($this->ormDialectConfig->parseDateTime($this->value));
		} catch (\InvalidArgumentException $e) {
			throw new CorruptedDataException(null, 0, $e);
		}
	}
213289
public function getConvertedValue()
    {
        if ($this->valueHasBeenConverted === false) {
            $this->convertedValue = $this->executeValueConversion();
            $this->valueHasBeenConverted = true;
        }

        return $this->convertedValue;
    }
166133
public function getDatatypes() {
        if (empty($this->data)) {
            $this->data = $this->parse_string();
        }
        if (!is_array($this->data)) {
            throw new \UnexpectedValueException('No data set yet.');
        }

        $result = [];
        foreach ($this->titles as $cName) {
            $column = array_column($this->data, $cName);
            $cDatatypes = array_map(DatatypeEnum::class . '::getValidTypeFromSample', $column);

            $result[$cName] = $this->getMostFrequentDatatypeForColumn($cDatatypes);
        }

        $this->data_types = $result;

        return !empty($this->data_types) ? $this->data_types : [];
    }
991331
public function checkValue()
    {
        $this->value = $this->htmlEditor->getValue();
        $value = $this->htmlEditor->checkValue();
        return $value;
    }
1289737
public function getValueList()
    {

        //$list = $this->valueList;
        $list=[];
        if (isset($_POST[$this->requestName])) {
            foreach ($_POST[$this->requestName] as $value) {
                $list[] = trim($value);
            }
        }

        return $list;

    }
76733
public function toFloat()
    {
        if (is_array($this->value)) {
            throw new InvalidNotArrayException($this->name);
        } elseif (!empty($this->value) && !is_numeric($this->value)) {
            throw new InvalidNumericException($this->name, $this->value);
        }

        $this->value = (float) $this->value;

        return $this;
    }
45573
public function getData()
    {
        // The application has the option of passing the query parameter
        // in, perhaps using its own middleware, or allowing Omnipay to
        // provide it.

        $crypt = $this->getCrypt() ?: $this->httpRequest->query->get('crypt');

        // Make sure we have a crypt parameter before trying to decrypt it.

        if (empty($crypt) || !is_string($crypt) || substr($crypt, 0, 1) !== '@') {
            throw new InvalidResponseException('Missing or invalid "crypt" parameter');
        }

        // Remove the leading '@' and decrypt the remainder into a query string.
        // An InvalidResponseException is thrown if the crypt parameter data is not
        // a hexadecimal string.

        $hexString = substr($crypt, 1);

        if (! preg_match('/^[0-9a-f]+$/i', $hexString)) {
            throw new InvalidResponseException('Invalid "crypt" parameter; not hexadecimal');
        }

        $queryString = openssl_decrypt(
            hex2bin($hexString),
            'aes-128-cbc',
            $this->getEncryptionKey(),
            OPENSSL_RAW_DATA,
            $this->getEncryptionKey()
        );

        parse_str($queryString, $data);

        // The result will be ASCII data only, being a very restricted set of
        // IDs and flags, so can be treated as UTF-8 without any conversion.

        return($data);
    }
949789
protected static function requireValue($data, $key)
    {
        if (isset($data[$key])) {
            return $data[$key];
        } else {
            throw new Exception\InvalidDataException("Required value for '$key' is missing");
        }
    }
245972
public function getMinValue()
    {
        $values = $this->values->toArray();

        uasort($values, $this->cmpValues('getName'));

        return reset($values);
    }