Zwraca czy zmodyfikowano pole
@param string $field nazwa pola
@return boolean
546391
public final function isModified($field)
    {
        //brak klucza w tablicy stanu - niezmodyfikowane
        if (!array_key_exists($field, $this->_state)) {
            return false;
        }
        //wartość liczbowa - porównanie proste
        if (is_numeric($this->$field) && $this->_state[$field] == $this->$field) {
            return false;
        }
        //porównanie z typem
        return ($this->_state[$field] !== $this->$field);
    }
922086
public function field($field) {
        $field = is_array($field) ? $field : explode(',', $field);
        foreach ((array) $field as $k => $v) {
            $this->build()->bindExpression('field', $v);
        }

        return $this->connection;
    }
912031
public function stickAction()
    {
        $this->getResponse()->setTypePlain();
        //brak id
        if (!$this->id) {
            return '';
        }
        //brak pliku
        if (null === ($file = (new CmsFileQuery)->findPk($this->id)) || $this->hash != $file->name) {
            return $this->view->getTranslate()->_('Przypinanie nie powiodło się');
        }
        //przypina plik
        $file->setSticky();
        return '';
    }
487957
public function isFieldVirtualised($field)
    {
        // Don't defer if field is non-virtualised
        $ignore = $this->getNonVirtualisedFields();
        if (in_array($field, $ignore)) {
            return false;
        }

        // Don't defer if no virtual page
        $copied = $this->CopyContentFrom();
        if (!$copied || !$copied->exists()) {
            return false;
        }

        // Check if copied object has this field
        return $copied->hasField($field);
    }
855094
public function hasFieldsOnPosition($position)
	{
		$fieldsOnPosition = false;

		foreach ($this->getFields() as $field) {
			if ($field->getPosition() == $position) {
				$fieldsOnPosition = true;
			}
		}

		return $fieldsOnPosition;
	}
711829
public function existsField(string $field) : bool
        {
                return $this->_redis->hexists($this->_key, $field) ? true : false;
        }
843493
public function column($field, $key = '')
    {
        $result = false;
        if (isset($this->options['field'])) {
            unset($this->options['field']);
        }
        if ($key && '*' != $field) {
            $field = $key . ',' . $field;
        }
        $cursor = $this->field($field)->fetchCursor(true)->select();
        $cursor->setTypeMap(['root' => 'array']);
        $resultSet = $cursor->toArray();
        if ($resultSet) {
            $fields = array_keys($resultSet[0]);
            $count  = count($fields);
            $key1   = array_shift($fields);
            $key2   = $fields ? array_shift($fields) : '';
            $key    = $key ?: $key1;
            foreach ($resultSet as $val) {
                $name = $val[$key];
                if ($name instanceof ObjectID) {
                    $name = $name->__toString();
                }
                if (2 == $count) {
                    $result[$name] = $val[$key2];
                } elseif (1 == $count) {
                    $result[$name] = $val[$key1];
                } else {
                    $result[$name] = $val;
                }
            }
        } else {
            $result = [];
        }
        return $result;
    }
672570
protected function populateValue($field) : bool
    {
        $elements = $this->getFields($field);

        $return = true;

        foreach ($elements as $element) {
            if ($element instanceof AbstractField) {
                if (!$this->isSubmit()) {
                    $return = !$this->getDefaultValue($element) ? false : $return;
                } else {
                    $return = !$this->getFieldValue($element) ? false : $return;
                }
            } else {
                $return = !$this->populateValue($element) ? false : $return;
            }
        }

        return $return;
    }
46058
public function is_set($field) {
        return (isset($this->data[$field]) || isset($this->extradata[$field]));
    }
1059458
protected function isFillable(string $field): bool
    {
        if (static::FILLABLE === '*') {
            return true;
        }

        if (!empty(static::FILLABLE)) {
            return in_array($field, static::FILLABLE);
        }

        if (static::SECURED === '*') {
            return false;
        }

        return !in_array($field, static::SECURED);
    }
966311
protected function isConfirmed(string $key, string $field) : bool
    {
        return $this->isSame($key, $field.'_confirm');
    }
527138
public function validated($field = null, $default = false)
	{
		if ($field === null)
		{
			return $this->validated;
		}

		return array_key_exists($field, $this->validated) ? $this->validated[$field] : $default;
	}
896102
public function isVariableRequired( $field )
    {
        switch ( $field )
        {
            case 'email':
                $user = eZUser::currentUser();
                if( !$user->isAnonymous() )
                {
                    return false;
                }
                return true;
            case 'recaptcha':
                // if the user bypasses captcha, don't validate field
                $bypassCaptcha = ezcomPermission::hasAccessToSecurity( 'AntiSpam' , 'bypass_captcha' );
                if( $bypassCaptcha['result'] )
                {
                    return false;
                }
                return true;
            default:
            return parent::isVariableRequired( $field );
        }
    }
1292600
public function hasFieldError($field)
    {
        foreach ((array)$this->errors as $err) {

            if ($err instanceof FieldValidationError) {
                $tfield = $err->getFieldResolved();
                if($tfield == $field)
                    return true;
            }
        }

        return false;
    }
146003
public function changed($field = null)
    {
        if ($this->owner->isNewRecord)
            return false;
        if ($field)
            return $this->getDbAttribute($field) != $this->owner->getAttribute($field);
        foreach ($this->owner->getAttributes() as $k => $v)
            if ($this->getDbAttribute($k) != $v)
                return true;
        return false;
    }
536148
public function mapFrom($field)
    {
        return isset($this->mapping[$field]) ? $this->mapping[$field] : $field;
    }
1199956
public function canMap(Field $field)
    {
        return
            $field->type instanceof FieldType\MultipleStringField ||
            $field->type instanceof FieldType\TextField ||
            $field->type instanceof FieldType\FullTextField;
    }