Auxiliary method for getting errors in nested entities

@param string $field the field in this entity to check for errors
@return array errors in nested entity if any
1510
protected function _nestedErrors($field)
    {
        $path = explode('.', $field);

        // Only one path element, check for nested entity with error.
        if (count($path) === 1) {
            return $this->_readError($this->get($path[0]));
        }

        $entity = $this;
        $len = count($path);
        while ($len) {
            $part = array_shift($path);
            $len = count($path);
            $val = null;
            if ($entity instanceof EntityInterface) {
                $val = $entity->get($part);
            } elseif (is_array($entity)) {
                $val = isset($entity[$part]) ? $entity[$part] : false;
            }

            if (is_array($val) ||
                $val instanceof Traversable ||
                $val instanceof EntityInterface
            ) {
                $entity = $val;
            } else {
                $path[] = $part;
                break;
            }
        }
        if (count($path) <= 1) {
            return $this->_readError($entity, array_pop($path));
        }

        return [];
    }
1159028
public function getErrors($attribute = null): array
    {
        if ($attribute === null) {
            return $this->errors === null ? [] : $this->errors;
        } else {
            return isset($this->errors[$attribute]) ? $this->errors[$attribute] : [];
        }
    }
53176
public function getErrors($type = self::ERROR_ALL) {
        if ($type === self::ERROR_ALL) {
            return $this->_errors;
        }

        $clean = array();

        if ($this->_errors) {
            foreach ($this->_errors as $error) {
                if ($error['type'] === self::ERROR_NESTING) {
                    $clean[] = $error;

                } else if ($error['type'] === self::ERROR_CLOSING) {
                    $clean[] = $error;

                } else if ($error['type'] === self::ERROR_SCOPE) {
                    $clean[] = $error;
                }
            }
        }

        return $clean;
    }
1137440
public function getRaw($field)
    {
        if (!array_key_exists($field, $this->entity)) {
            return null;
        }
        return $this->entity[$field];
    }
1324977
public function errors($options = [])
    {
        $errors = [];
        $errored = false;
        foreach ($this as $entity) {
            $result = $entity->errors($options);
            $errors[] = $result;
            if ($result) {
                $errored = true;
            }
        }
        return $errored ? $errors : [];
    }
605387
public function url($field)
    {
        return (filter_var(trim($this->get($field)), FILTER_VALIDATE_URL) !== false) ?: $this->error($field,
            __FUNCTION__);
    }
899535
public function get($field)
    {
        if (!is_null($this->filtered) && ! is_null($this->filtered[0])) {
            return isset($this->filtered[0][0][$field]) ? $this->filtered[0][0][$field] : null;
        }

        // Todo: Get values of entities
    }
1054878
public function email($field)
    {
        return (filter_var(trim($this->get($field)), FILTER_VALIDATE_EMAIL) !== false) ?: $this->error($field,
            __FUNCTION__);
    }
971383
public function errors($field = null)
    {
        if ($field) {
            return $this->errors[$field] ?? [];
        }

        return array_merge([], ...array_values($this->errors));
    }
540405
public function error_message($field = null, $default = false)
	{
		if ($field === null)
		{
			$messages = array();
			foreach ($this->error() as $field => $e)
			{
				$messages[$field] = $e->get_message();
			}
			return $messages;
		}

		return array_key_exists($field, $this->errors) ? $this->errors[$field]->get_message() : $default;
	}
1351536
public function hasError($field=null){
        if($field == null){
            return count($this->errors) > 0;
        }
        return array_key_exists($field, $this->errors);
    }
201347
public function errorString($field = null)
    {
        $res = [];
        $errors = $this->errors();
        foreach ($errors as $k => $v) {
            $res[$k] = implode(',', $v);
        }
        if (!empty($field)) {
            return Arrays::get($res, $field, '');
        }

        return implode('|', $res);
    }
170244
private function getValues(array $field)
    {
        if ($field['type'] !== 'select') {
            return null;
        }
        $field = Bag::from($field);

        // Get the appropriate values
        return is_string($field->get('values', [])) ? $this->getEntityValues($field) : $this->getYamlValues($field);
    }
1266819
protected function getField($field)
    {
        foreach ($this->getFields() as $annotatedField) {
            if ($annotatedField->name === $field) {
                return $annotatedField;
            }
        }

        return null;
    }
1134450
public function getErrorMessages() : array
    {
        $errors = $this->getErrors(true);
        $return = array();
        foreach ($errors as $error) {
            $return[] = 'Field: ' . $error->getFieldName() . '| Message: ' . $error->getErrorMessage();
        }
        return $return;
    }
6350
public function rules($field)
    {
        return (isset($this->data[$field]) && $validate = $this->data[$field]['validate']) ? $validate : array();
    }
481014
public function error($field)
    {
        return ($this->submitted && isset($this->errors[$field])) ? $this->errors[$field] : null;
    }