Java Field.getInitialValue方法代码示例

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
@Override
protected Field reField(Field field) {
    String name = field.getName();
    String newType;
    boolean isBasic = false;
    boolean isArray = false;
    if (field.getType().startsWith("[")) {
        isArray = true;
    }
    if (basicType.containsKey(field.getType())) {
        newType = field.getType();
        isBasic = true;
    } else {

        newType = DefineUtils.getDalvikClassName(field.getType());
    }
    String defineClass = DefineUtils.getDalvikClassName(field.getDefiningClass());
    return new ImmutableField(
            reType,
            classProcessor.filedProcess(defineClass, isBasic ? basicType.get(newType) : newType + (isArray ? "[]" : ""), name).fieldName,
            isBasic ? newType :
                    DefineUtils.getDefineClassName(classProcessor.classProcess(isBasic ? basicType.get(newType) : newType).className, isArray),
            field.getAccessFlags(),
            field.getInitialValue(),
            getAnnotation(field.getAnnotations()));
}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
@Override
protected Field onSimpleEdit(Field patch, PatcherAnnotation annotation, Field target, boolean inPlace) {

	// Use the static field initializer value in source only
	// if not renaming, given that the static constructor in
	// source would only initialize it if not renamed.
	// This makes behavior predictable across compilers.
	EncodedValue value = inPlace ? target.getInitialValue() : null;
	value = filterInitialValue(patch, value);

	onSimpleRemove(patch, annotation, target);

	Field patched = new BasicField(
			patch.getDefiningClass(),
			patch.getName(),
			patch.getType(),
			patch.getAccessFlags(),
			value,
			annotation.getFilteredAnnotations());

	return super.onSimpleEdit(patched, annotation, target, inPlace);

}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
public static ImmutableField of(Field field) {
    if (field instanceof  ImmutableField) {
        return (ImmutableField)field;
    }
    return new ImmutableField(
            field.getDefiningClass(),
            field.getName(),
            field.getType(),
            field.getAccessFlags(),
            field.getInitialValue(),
            field.getAnnotations());
}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
public static void writeTo(IndentingWriter writer, Field field, boolean setInStaticConstructor) throws IOException {
    EncodedValue initialValue = field.getInitialValue();
    int accessFlags = field.getAccessFlags();

    if (setInStaticConstructor &&
            AccessFlags.STATIC.isSet(accessFlags) &&
            AccessFlags.FINAL.isSet(accessFlags) &&
            initialValue != null) {
        if (!EncodedValueUtils.isDefaultValue(initialValue)) {
            writer.write("# The value of this static final field might be set in the static constructor\n");
        } else {
            // don't write out the default initial value for static final fields that get set in the static
            // constructor
            initialValue = null;
        }
    }

    writer.write(".field ");
    writeAccessFlags(writer, field.getAccessFlags());
    writer.write(field.getName());
    writer.write(':');
    writer.write(field.getType());
    if (initialValue != null) {
        writer.write(" = ");
        EncodedValueAdaptor.writeTo(writer, initialValue);
    }

    writer.write('\n');

    Collection<? extends Annotation> annotations = field.getAnnotations();
    if (annotations.size() > 0) {
        writer.indent(4);
        AnnotationFormatter.writeTo(writer, annotations);
        writer.deindent(4);
        writer.write(".end field\n");
    }
}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
public static ImmutableField of(Field field) {
    if (field instanceof ImmutableField) {
        return (ImmutableField) field;
    }
    return new ImmutableField(
            field.getDefiningClass(),
            field.getName(),
            field.getType(),
            field.getAccessFlags(),
            field.getInitialValue(),
            field.getAnnotations());
}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
@Override
public EncodedValue apply(Field input) {
    EncodedValue initialValue = input.getInitialValue();
    if (initialValue == null) {
        return ImmutableEncodedValueFactory.defaultValueForType(input.getType());
    }
    return initialValue;
}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
@Override
public boolean apply(Field input) {
    EncodedValue encodedValue = input.getInitialValue();
    return encodedValue != null && !EncodedValueUtils.isDefaultValue(encodedValue);
}
 

import org.jf.dexlib2.iface.Field; //导入方法依赖的package包/类
public void intern(@Nonnull ClassDef classDef) {
    PoolClassDef poolClassDef = new PoolClassDef(classDef);

    PoolClassDef prev = internedItems.put(poolClassDef.getType(), poolClassDef);
    if (prev != null) {
        throw new ExceptionWithContext("Class %s has already been interned", poolClassDef.getType());
    }

    typePool.intern(poolClassDef.getType());
    typePool.internNullable(poolClassDef.getSuperclass());
    typeListPool.intern(poolClassDef.getInterfaces());
    stringPool.internNullable(poolClassDef.getSourceFile());

    HashSet<String> fields = new HashSet<String>();
    for (Field field : poolClassDef.getFields()) {
        String fieldDescriptor = ReferenceUtil.getShortFieldDescriptor(field);
        if (!fields.add(fieldDescriptor)) {
            throw new ExceptionWithContext("Multiple definitions for field %s->%s",
                    poolClassDef.getType(), fieldDescriptor);
        }
        fieldPool.intern(field);

        EncodedValue initialValue = field.getInitialValue();
        if (initialValue != null) {
            DexPool.internEncodedValue(initialValue, stringPool, typePool, fieldPool, methodPool);
        }

        annotationSetPool.intern(field.getAnnotations());
    }

    HashSet<String> methods = new HashSet<String>();
    for (PoolMethod method : poolClassDef.getMethods()) {
        String methodDescriptor = ReferenceUtil.getShortMethodDescriptor(method);
        if (!methods.add(methodDescriptor)) {
            throw new ExceptionWithContext("Multiple definitions for method %s->%s",
                    poolClassDef.getType(), methodDescriptor);
        }
        methodPool.intern(method);
        internCode(method);
        internDebug(method);
        annotationSetPool.intern(method.getAnnotations());

        for (MethodParameter parameter : method.getParameters()) {
            annotationSetPool.intern(parameter.getAnnotations());
        }
    }

    annotationSetPool.intern(poolClassDef.getAnnotations());
}