Tell if this filter contains a filter on the given field.

@param string $field
@return bool
335761
public function hasFilter(string $field): bool
    {
        foreach ($this->filters as $filter) {
            if ($filter->hasFilter($field)) {
                return true;
            }
        }

        return false;
    }
711829
public function existsField(string $field) : bool
        {
                return $this->_redis->hexists($this->_key, $field) ? true : false;
        }
725257
public function offsetExists($field) {
        return isset($this->values[$field]) || isset($this->factories[$field]);
    }
187824
public function isFillable($field)
    {
        return !in_array($field, $this->guarded) && !$this->fillable || in_array($field, $this->fillable);
    }
146820
public function contains($field, $value)
    {
        return function ($object) use ($field, $value) {
            return false !== strpos(ClosureExpressionBuilder::getObjectFieldValue($object, $field), $value);
        };
    }
10866
public function exists($field)
    {
        // Remove \0 from begin of field name.
        if (strpos($field, "\0") === 0) {
            $field = substr($field, 3);
        }

        return isset($this->$field);
    }
154265
public function isRequired($field)
    {
        $parts = explode('.', $field);
        $entity = $this->entity($parts);

        $isNew = true;
        if ($entity instanceof EntityInterface) {
            $isNew = $entity->isNew();
        }

        $validator = $this->_getValidator($parts);
        $fieldName = array_pop($parts);
        if (!$validator->hasField($fieldName)) {
            return false;
        }
        if ($this->type($field) !== 'boolean') {
            return $validator->isEmptyAllowed($fieldName, $isNew) === false;
        }

        return false;
    }
909530
public function getNormalizerForField($field)
    {
        if (!empty($this->fields[ $field ])) {
            return $this->fields[ $field ];
        } else {
            return false;
        }
    }
257735
protected static function isExpression($field)
    {
        $alias = explode(' as ', $field);
        $field = trim($alias[0]);
        if (preg_match('/\S+\(\S*\)/', $field) === 1) {
            if (isset($alias[1])) {
                return trim($alias[1]);
            }

            return true;
        }

        return false;
    }
1262405
public function by($field, $value)
    {
        $filtered = $this->filter(function($fieldset) use($field, $value) {
            if (isset($fieldset->{$field}) and $fieldset->{$field} == $value) {
                return true;
            }
            return false;
        });
        return $filtered->isEmpty() ? null : ($filtered->count() > 1 ? $filtered : $filtered->first());
    }
1132829
public function count($field = '*')
    {
        $r = 0;
        foreach ($this->queries as $query) {
            $t = $query->count($field);
            $r += $t;
        }

        return $r;
    }
260109
public function inError(string $field): bool
    {
        foreach ($this->_errors as $item) {
            if ($field === $item['name']) {
                return true;
            }
        }
        return false;
    }
835810
protected function isPrimaryHeader(Field $field)
    {
        return $field->isHeader || Helpers::strIs(Config::getHeadersPatterns(), $field->name);
    }
368299
public function hasField($fieldName)
    {
        $fields = array_filter($this->fields, function(Field $field) use ($fieldName) {
            return $field->name == $fieldName || $field->getNameWithAlias() == $fieldName;
        });

        if (count($fields) == 0) {
            return false;
        }

        return true;
    }
597206
public function hasField($field)
    {
        $schema = static::getSchema();
        return (
            array_key_exists($field, $this->record)
            || array_key_exists($field, $this->components)
            || $schema->fieldSpec(static::class, $field)
            || $schema->unaryComponent(static::class, $field)
            || $this->hasMethod("get{$field}")
        );
    }
538381
public function isFieldExists($table, $field)
	{
		if (isset($this->tables[$table])) {
			$fields = $this->getFields($table);

			return $fields->where('name', $field)->count() > 0;
		}

		return false;
	}
646246
public function hasParam($field) {
        foreach ($this->getParams() as $param) {
            if ($param instanceof Expr && $param->getField() === $field) {
                return true;
            }
        }

        return false;
    }