Return true if graph with name graph_name has field with 
        name field_name.
        
        @param graph_name: Graph Name
        @param field_name: Field Name.
        @return: Boolean
3406
def graphHasField(self, graph_name, field_name):
        
        graph = self._graphDict.get(graph_name, True)
        return graph.hasField(field_name)
336038
function(fieldName) {
                return _.has(this.filterableFields, fieldName) &&
                    !_.isUndefined(this.filterableFields[fieldName].displayName);
            }
798309
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case TOPOLOGY_METRIC:
      return is_set_topologyMetric();
    case COMPONENT_METRIC:
      return is_set_componentMetric();
    case WORKER_METRIC:
      return is_set_workerMetric();
    case TASK_METRIC:
      return is_set_taskMetric();
    case STREAM_METRIC:
      return is_set_streamMetric();
    case NETTY_METRIC:
      return is_set_nettyMetric();
    case COMP_STREAM_METRIC:
      return is_set_compStreamMetric();
    }
    throw new IllegalStateException();
  }
1223297
def hasField(cls, fieldName) :
        """"""
        path = fieldName.split(".")
        v = cls._fields
        for k in path :
            try :
                v = v[k]
            except KeyError :
                return False
        return True
297795
def get_suggested_field_names(schema, graphql_type, field_name):
    """"""

    if isinstance(graphql_type, (GraphQLInterfaceType, GraphQLObjectType)):
        possible_field_names = list(graphql_type.fields.keys())

        return suggestion_list(field_name, possible_field_names)

    # Otherwise, must be a Union type, which does not define fields.
    return []
809185
@Override
	public boolean hasField(String fldname) {
		if (groupFlds.contains(fldname))
			return true;
		if (aggFns != null)
			for (AggregationFn fn : aggFns)
				if (fn.fieldName().equals(fldname))
					return true;
		return false;
	}
1234039
def field_name_exist(self, field_name):
        

        fields = self.class_item.get_fields()
        for f in fields:
            if f.name == field_name:
                return True
        return False
575333
public boolean hasFieldChangedInHierarchy(String name) {
		// Find the field:
		ReloadableType rtype = this;
		FieldMember field = null;
		// Did it exist on this type originally?
		TypeDescriptor originalTypeDescriptor = rtype.getTypeDescriptor();
		FieldMember originalField = originalTypeDescriptor.getField(name);

		TypeDescriptor typedescriptor = rtype.getLatestTypeDescriptor();
		field = typedescriptor.getField(name);
		if (originalField != null && field == null) {
			// Field got removed from this type, going to have to resort to indirection logic or we'll trip over the original version when
			// letting the field instruction run
			return true;
		}

		if (originalField != null && field != null) {
			return !originalField.equals(field);
		}
		if (originalField == null && field != null) {
			return true;
		}

		FieldWalkDiscoveryResult b = hasFieldChangedInHierarchy(name, rtype.getTypeDescriptor().getSupertypeName());
		switch (b) {
			case CHANGED_STOPNOW:
				return true;
			case UNCHANGED_STOPWALKINGNOW:
				return false;
			case DONTKNOW:
				throw new IllegalStateException();
		}
		throw new IllegalStateException();
	}
476352
def connection_field_ast(field)
      f_ast = field_ast(field, connection_arguments)
      return nil if f_ast.nil?
      edges_fields = [edges_field_ast(field.type.unwrap.get_field('edges'))]
      if f_ast.respond_to?(:merge) # GraphQL-Ruby 1.9+
        f_ast.merge(selections: f_ast.selections + edges_fields)
      else
        f_ast.selections.concat(edges_fields)
        f_ast
      end
    end
765682
public static boolean hasAnnotation(CtField field, String annotationName) {
        FieldInfo info = field.getFieldInfo();
        AnnotationsAttribute ainfo = (AnnotationsAttribute)
            info.getAttribute(AnnotationsAttribute.invisibleTag);
        AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
            info.getAttribute(AnnotationsAttribute.visibleTag);
        return checkAnnotation(ainfo, ainfo2, annotationName);
    }
657201
@Override
	public boolean hasField(String fldName) {
		return s1.hasField(fldName) || s2.hasField(fldName);
	}
761030
def have_graph(self, graph):
        """"""
        graph = self.pack(graph)
        return bool(self.sql('graphs_named', graph).fetchone()[0])
288206
def has(self, name):
        
        for a in self.all_annotations:
            if a.name == name:
                return True
        return False
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
1187474
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME:
      return isSetName();
    case STRATEGY_CLASS:
      return isSetStrategy_class();
    case STRATEGY_OPTIONS:
      return isSetStrategy_options();
    case REPLICATION_FACTOR:
      return isSetReplication_factor();
    case CF_DEFS:
      return isSetCf_defs();
    case DURABLE_WRITES:
      return isSetDurable_writes();
    }
    throw new IllegalStateException();
  }
901014
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME_TYPES:
      return isSetName_types();
    case VALUE_TYPES:
      return isSetValue_types();
    case DEFAULT_NAME_TYPE:
      return isSetDefault_name_type();
    case DEFAULT_VALUE_TYPE:
      return isSetDefault_value_type();
    }
    throw new IllegalStateException();
  }
431702
public boolean isField(final String fieldName) {
    if (fieldName != null) {
        return (KEYWORD_LIST.contains(
                fieldName.toUpperCase(Locale.US))
                || fieldName.toUpperCase().startsWith(PROP_FIELD));
    }
    return false;
  }