Get the field modifiers as a string, e.g. "public static final". For the modifier bits, call getModifiers().

@return The field modifiers, as a string.
778637
public String getModifierStr() {
        final StringBuilder buf = new StringBuilder();
        TypeUtils.modifiersToString(modifiers, ModifierType.FIELD, /* ignored */ false, buf);
        return buf.toString();
    }
351353
protected String getQueryModifier() {

        String queryModifier = parseOptionalStringValue(m_configObject, JSON_KEY_QUERY_MODIFIER);
        return (null == queryModifier) && (null != m_baseConfig)
        ? m_baseConfig.getGeneralConfig().getQueryModifier()
        : queryModifier;
    }
555605
public Map<String, String> getCustomFields() {
        Map<String, String> fields = new HashMap<String, String>();
        for (CustomField f : customFields) {
            fields.put(f.getName(), f.getValue());
        }
        return fields;
    }
1073122
public java.util.List<ModificationState> getModificationStates() {
        if (modificationStates == null) {
            modificationStates = new com.amazonaws.internal.SdkInternalList<ModificationState>();
        }
        return modificationStates;
    }
830288
@GwtIncompatible("Class.getDeclaredFields")
	public ToStringBuilder addAllFields() {
		List<Field> fields = getAllDeclaredFields(instance.getClass());
		for(Field field : fields) {
			addField(field);
		}
		return this;
	}
789413
public static int jlClassGetModifiers(Class<?> clazz) {
		//		ReloadableType rtype = getReloadableTypeIfHasBeenReloaded(clazz);
		ReloadableType rtype = getRType(clazz);
		if (rtype == null) {
			return clazz.getModifiers();
		}
		else {
			//Note: the "super bit" may be set in class modifiers but we should block it out, it
			//shouldn't be shown to users of the reflection API.
			return rtype.getLatestTypeDescriptor().getModifiers() & ~Opcodes.ACC_SUPER;
		}
	}
799756
private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result =
      new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
      if (field.isRepeated()) {
        final List<?> value = (List<?>) getField(field);
        if (!value.isEmpty()) {
          result.put(field, value);
        }
      } else {
        if (hasField(field)) {
          result.put(field, getField(field));
        }
      }
    }
    return result;
  }
23585
private FieldPosition[] getPositiveSuffixFieldPositions() {
        if (positiveSuffixFieldPositions == null) {
            if (posSuffixPattern != null) {
                positiveSuffixFieldPositions = expandAffix(posSuffixPattern);
            } else {
                positiveSuffixFieldPositions = EmptyFieldPositionArray;
            }
        }
        return positiveSuffixFieldPositions;
    }
296863
public void getStaticField(VariableElement field) throws IOException
    {
        if (!field.getModifiers().contains(Modifier.STATIC))
        {
            throw new IllegalArgumentException(field+" is not static");
        }
        int index = subClass.resolveFieldIndex(field);
        getstatic(index);
    }
363046
def get_active_modifiers(self):
        
        keys = ctypes.pointer(charcodemap_t())
        nkeys = ctypes.c_int(0)

        _libxdo.xdo_get_active_modifiers(
            self._xdo, ctypes.byref(keys), ctypes.byref(nkeys))
        return [keys[i] for i in range(nkeys.value)]
429734
@Override
  public final Field[] retrieveFields(final Class<?> clazz) {
    Set<Field> fieldsSet = new HashSet<Field>();
    for (Field fld : clazz.getDeclaredFields()) {
      int modifiersMask = fld.getModifiers();
      if ((modifiersMask & Modifier.PRIVATE) > 0
            && (modifiersMask & Modifier.STATIC) == 0) {
        fieldsSet.add(fld);
      }
    }
    final Class<?> superClazz = clazz.getSuperclass();
    if (superClazz != null && superClazz != java.lang.Object.class) {
      for (Field fld : retrieveFields(superClazz)) {
        fieldsSet.add(fld);
      }
    }
    return fieldsSet.toArray(new Field[fieldsSet.size()]);
  }
1201442
public String modifiers() {
        int modifiers = getModifiers();
        if (isAnnotationTypeElement() ||
                (isMethod() && containingClass().isInterface())) {
            // Remove the implicit abstract modifier.
            return Modifier.toString(modifiers & ~Modifier.ABSTRACT);
        } else {
            return Modifier.toString(modifiers);
        }
    }
519927
private String getFieldsString() {
        final StringBuilder fieldsString = new StringBuilder();

        for (final String field : fields) {
            // XML namespaces require that the colon be percent-escaped but nothing else
            fieldsString.append(':').append(field.replace(":", "%3A"));
        }

        return fieldsString.toString();
    }
107514
public boolean[] getModified()
    {
        int iFieldCount = this.getFieldCount();  // BaseField Count
        boolean[] rgbModified = new boolean[iFieldCount];
        for (int iFieldSeq = DBConstants.MAIN_FIELD; iFieldSeq < iFieldCount + DBConstants.MAIN_FIELD; iFieldSeq++)
        {
            BaseField field = this.getField(iFieldSeq);
            rgbModified[iFieldSeq] = field.isModified();
        }
        return rgbModified;
    }
1333521
public Map<String, Reflector> fields() {
        Map<String, Reflector> result;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT) {
            result = new ArrayMap<>();
        } else {
            result = new HashMap<>();
        }
        Class<?> type = type();
        do {
            // all field
            for (Field field : type.getDeclaredFields()) {
                if (!isClass ^ Modifier.isStatic(field.getModifiers())) {
                    String name = field.getName();
                    // add
                    if (!result.containsKey(name))
                        result.put(name, field(name));
                }
            }

            type = type.getSuperclass();
        }
        while (type != null);

        return result;
    }
817012
public static List<String> getDeclaredFields(Class<?> baseClass) {

        Method[] methods = baseClass.getMethods();

        List<String> fields = new ArrayList<>();

        for (Method fm : methods) {
            if ((!fm.getName().startsWith(GET_METHOD_PREFIX) && !fm.getName().startsWith(IS_METHOD_PREFIX)) || fm.getParameterCount() != 0) {
                continue;
            }

            String field = getFieldNameFromMethod(fm);
            fields.add(field);
        }
        return fields;
    }
881320
private static int getTypeModifiers(TypeElement type) {
    int modifiers = ElementUtil.fromModifierSet(type.getModifiers());
    if (type.getKind().isInterface()) {
      modifiers |= java.lang.reflect.Modifier.INTERFACE | java.lang.reflect.Modifier.ABSTRACT
          | java.lang.reflect.Modifier.STATIC;
    }
    if (ElementUtil.isSynthetic(type)) {
      modifiers |= ElementUtil.ACC_SYNTHETIC;
    }
    if (ElementUtil.isAnnotationType(type)) {
      modifiers |= ElementUtil.ACC_ANNOTATION;
    }
    if (ElementUtil.isEnum(type)) {
      modifiers |= ElementUtil.ACC_ENUM;
    }
    if (ElementUtil.isAnonymous(type)) {
      modifiers |= ElementUtil.ACC_ANONYMOUS;
    }
    return modifiers;
  }