Returns a list of all fields. Subtype fields come before this type's
        fields.
175009
def all_fields(self):
        
        fields = []
        if self.parent_type:
            fields.extend(self.parent_type.all_fields)
        fields.extend([f for f in self.fields])
        return fields
1367655
public static Field[] getAllFields(Class<?> c) {
        List<Field> listOfFields = new ArrayList<Field>();
        getAllFields(c, listOfFields);

        Field[] arrayOffields = new Field[listOfFields.size()];
        listOfFields.toArray(arrayOffields);
        return arrayOffields;
    }
161579
def fields(self):
        
        if self._fields is None:
            self._fields = FieldList(
                self._version,
                assistant_sid=self._solution['assistant_sid'],
                task_sid=self._solution['sid'],
            )
        return self._fields
786445
public GroovyFieldDoc[] fields() {
        Collections.sort(fields);
        return fields.toArray(new GroovyFieldDoc[fields.size()]);
    }
622587
public Map<FieldDescriptorType, Object> getAllFields() {
    if (hasLazyField) {
      SmallSortedMap<FieldDescriptorType, Object> result =
          SmallSortedMap.newFieldMap(16);
      for (int i = 0; i < fields.getNumArrayEntries(); i++) {
        cloneFieldEntry(result, fields.getArrayEntryAt(i));
      }
      for (Map.Entry<FieldDescriptorType, Object> entry :
          fields.getOverflowEntries()) {
        cloneFieldEntry(result, entry);
      }
      if (fields.isImmutable()) {
        result.makeImmutable();
      }
      return result;
    }
    return fields.isImmutable() ? fields : Collections.unmodifiableMap(fields);
  }
1259486
private static Field[] getAllFields(Object delegate) {
		
		ArrayList<Field> fields = new ArrayList<Field>(Arrays.asList(delegate.getClass()
				.getDeclaredFields()));
		Class superClass = delegate.getClass().getSuperclass();
		while(superClass != null){
		
		if (superClass != null) {
			Field[] parentFields = superClass.getDeclaredFields();
			if (parentFields.length != 0) {
				fields.addAll(Arrays.asList(superClass
						.getDeclaredFields()));
			}
			
		}
		superClass = superClass.getSuperclass();
		}
		return fields.toArray(new Field[fields.size()]);

	}
36968
function() {
	   var values = [];
	   for(var i = 0 ; i < this.subFields.length ; i++) {
	      values[i] = this.subFields[i].getValue();
	   }
	   return values;
	}
215856
def _get_simple_fields(self):
        
        fields = []
        for field_name in self.cls._fields:
            field = self.cls.get_field(field_name)
            if not isinstance(field, MultiValuesField):
                fields.append(field_name)
        return fields
1315847
def _collect_fields(field_parts_list, include_parents):
    """"""
    fields = []
    subpart_lists = defaultdict(list)

    for parts in field_parts_list:
        field, subparts = parts[0], parts[1:]
        if subparts:
            if include_parents and field not in fields:
                fields.append(field)
            subpart_lists[field].append(subparts)
        else:
            fields.append(field)

    subfields = dict((field, _collect_fields(subparts, include_parents))
                     for field, subparts in six.iteritems(subpart_lists))

    return ParsedFieldList(fields, subfields)
1236890
def inherited_fields
      return [] unless has_parent?

      names = parent.fields.keys - fields.keys
      names.concat(parent.aliases.reject { |k,v| !parent.has_field?(v) }.keys)
      names.sort!

      names
    end
420613
def get_all_fields(cls, class_obj=None, fields=None):
        

        def return_fields(obj):

            internal_fields = fields
            if internal_fields is None:
                internal_fields = {}

            for attribute in dir(obj):

                try:
                    attr_val = getattr(obj, attribute)
                    attr_cls = attr_val.__class__

                    # If it is a model field, call on init
                    if issubclass(attr_cls, ModelField):
                        internal_fields[attribute] = attr_val
                except:
                    pass

            return internal_fields

        if class_obj is None:
            class_obj = cls

            fields = return_fields(class_obj)
            for parent_class in cls.__bases__:
                parent_fields = cls.get_all_fields(parent_class, fields)
                for field_name, field_value in list(parent_fields.items()):
                    if not field_name in fields:
                        fields[field_name] = field_value

            return fields

        else:
            if not isinstance(class_obj, CollectionModel):
                return fields
1083199
private Set<Field> getItemFields() {
		Class next = Item.class;
		Set<Field> fields = new HashSet<>(getFields(next));
		while (next.getSuperclass() != Object.class) {
			next = next.getSuperclass();
			fields.addAll(getFields(next));
		}
		return fields;
	}
511656
def p_enumerated_subtype_field(self, p):
        ''
        p[0] = AstSubtypeField(
            self.path, p.lineno(1), p.lexpos(1), p[1], p[2])
784170
public JField []getDeclaredFields()
  {
    ArrayList<JavaField> fieldList = getFieldList();
    
    JField[] fields = new JField[fieldList.size()];

    fieldList.toArray(fields);

    return fields;
  }
430306
def fields(self):
        ''''''
        key = self.id + ':fields'
        encoding = self.client.encoding
        return tuple(sorted((f.decode(encoding)
                             for f in self.client.smembers(key))))
331463
def get_fields(self):
        """"""
        fields = super(DataSerializer, self).get_fields()

        # Hide collections/entities fields on list views as fetching them may be expensive.
        if self.parent is not None:
            del fields['collections']
            del fields['entities']

        return fields
392833
def _get_inherited_field_types(class_to_field_type_overrides, schema_graph):
    """"""
    inherited_field_type_overrides = dict()
    for superclass_name, field_type_overrides in class_to_field_type_overrides.items():
        for subclass_name in schema_graph.get_subclass_set(superclass_name):
            inherited_field_type_overrides.setdefault(subclass_name, dict())
            inherited_field_type_overrides[subclass_name].update(field_type_overrides)
    return inherited_field_type_overrides