If `TRUE` if given field instance or given
field name exists in form, `FALSE` otherwise.
@param \MvcCore\Ext\Forms\IField|string $fieldOrFieldName
@return bool
346285
public function HasField ($fieldOrFieldName = NULL) {
		$fieldName = NULL;
		if ($fieldOrFieldName instanceof \MvcCore\Ext\Forms\IField) {
			$fieldName = $fieldOrFieldName->GetName();
		} else if (is_string($fieldOrFieldName)) {
			$fieldName = $fieldOrFieldName;
		}
		return isset($this->fields[$fieldName]);
	}
538381
public function isFieldExists($table, $field)
	{
		if (isset($this->tables[$table])) {
			$fields = $this->getFields($table);

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

		return false;
	}
1184982
private function validateFieldName($field)
    {
        $fieldName = $field->getName();
        if (!$fieldName || $this->fieldNameExists($fieldName)) {
            throw new FieldNameCollisionException("Field Name: `{$fieldName}` already exists.");
        }

        return true;
    }
634719
public function isSuitableListFieldName($listFieldName) {   
        try {
            $field = $this->getField($listFieldName);
        } catch (Exception $e) {
            return;
        }

        if ($field && $field->isSuitableAsLabel()) {
            return true;
        }
    }
1331227
def does_field_exist(self,collection,field_name):
        '''
        
        '''
        schema = self.get_schema_fields(collection)
        logging.info(schema)
        return True if field_name in [field['name'] for field in schema['fields']] else False
1124086
public function isIdentifier(string $fieldName) : bool
    {
        if (! $this->identifier) {
            return false;
        }

        if (! $this->isIdentifierComposite()) {
            return $fieldName === $this->identifier[0];
        }

        return in_array($fieldName, $this->identifier, true);
    }
641551
public function fieldExists($fieldName, $tableName)
    {
        $tableFields = $this->getFields($tableName);
        $tableName = strtoupper($tableName);
        if (is_array($tableFields)) {
            $fieldName = strtoupper($fieldName);
            $tableFields = array_map('strtoupper', $tableFields);
            if (in_array("{$tableName}.{$fieldName}", $tableFields)) {
                return true;
            }
        }

        return false;
    }
804537
protected function hasCustomfield()
    {

        $function = function ($object, $name) {
            return method_exists($object, 'hasCustomfield') ? $object->hasCustomfield($name) : false;
        };
        return new Twig_SimpleFunction(
                'hasCustomfield', $function
        );
    }
589300
public function isUniqueField($fieldName)
    {
        $mapping = $this->getFieldMapping($fieldName);
        if ($mapping !== false) {
            return isset($mapping['unique']) && $mapping['unique'] == true;
        }
        return false;
    }
69940
protected function _checkFieldType($modelFieldName = null) {
		if (empty($modelFieldName) || !is_string($modelFieldName)) {
			return false;
		}

		if (strpos($modelFieldName, '.') === false) {
			return false;
		}

		list($modelName, $fieldName) = pluginSplit($modelFieldName);
		$schema = $this->_getSchemaForModel($modelName);
		if (($schema === null) || !is_array($schema) || !isset($schema[$fieldName]['type']) ||
			!in_array($schema[$fieldName]['type'], ['text', 'string'])) {
			return false;
		}

		return true;
	}
642433
public function isInclude($fieldName)
    {
        if ($this->hasField($fieldName) === false) {
            return false;
        }

        $class = __CLASS__;

        return ($this->mapping[$fieldName]['include'] instanceof $class);
    }
1071504
public function fieldHasError($fieldName)
    {
        foreach ($this->errors as $error) {
            if ($error->getParam() == $fieldName) {
                return true;
            }
        }

        if (!$this->isSubmitted()) {
            return false;
        }

        if (isset($this->validator) && $this->validator->fieldHasError($fieldName)) {
            return true;
        }
    }
1152714
protected boolean hasFieldError(String fieldname) {
		if ( StringUtils.isEmpty(fieldname)) {
			return false;
		}

		Object action = ActionContext.getContext().getActionInvocation().getAction();
		// check action instance 'ActionSupport'.
		if (!(action instanceof ActionSupport)) {
			return false;
		}

		ActionSupport asupport = (ActionSupport) action;
		Map<String, List<String>> fieldErrors = asupport.getFieldErrors();
		if (CollectionUtils.isEmpty(fieldErrors)) {
			return false;
		}
		List<String> targetFieldErrors = fieldErrors.get(fieldname);
		if (CollectionUtils.isEmpty(targetFieldErrors)) {
			return false;
		}

		return true;
	}
768594
public function isInheritedProperty($fieldName)
    {
        $declaringClass = $this->declaredProperties[$fieldName]->getDeclaringClass();

        return $declaringClass->className !== $this->className;
    }
709489
public function isMultilingualField($fieldName)
    {
        $fieldName = strtolower($fieldName);
        if (isset($this->_aFieldNames[$fieldName])) {
            return (bool) $this->_aFieldNames[$fieldName];
        }

        //not inited field yet
        //and note that this is should be called only in first call after tmp dir is empty
        startProfile('!__CACHABLE2__!');
        $isMultilang = (bool) $this->_getFieldStatus($fieldName);
        stopProfile('!__CACHABLE2__!');

        return (bool) $isMultilang;
    }
1270518
public boolean hasFieldAnnotation(final String fieldAnnotationName) {
        for (final ClassInfo ci : getOverrideOrder()) {
            if (ci.hasDeclaredFieldAnnotation(fieldAnnotationName)) {
                return true;
            }
        }
        return false;
    }
1159365
function &fieldNamed($fieldName)
    {
        $return = NULL;
        if (isset($this->_fields[$fieldName])) {
            $return =& $this->_fields[$fieldName];
        }

        return $return;
    }