Java TypeEncodedValue类代码示例

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Nonnull
@Override
public EncodedValue rewrite(@Nonnull EncodedValue encodedValue) {
    switch (encodedValue.getValueType()) {
        case ValueType.TYPE:
            return new RewrittenTypeEncodedValue((TypeEncodedValue) encodedValue);
        case ValueType.FIELD:
            return new RewrittenFieldEncodedValue((FieldEncodedValue) encodedValue);
        case ValueType.METHOD:
            return new RewrittenMethodEncodedValue((MethodEncodedValue) encodedValue);
        case ValueType.ENUM:
            return new RewrittenEnumEncodedValue((EnumEncodedValue) encodedValue);
        case ValueType.ARRAY:
            return new RewrittenArrayEncodedValue((ArrayEncodedValue) encodedValue);
        case ValueType.ANNOTATION:
            return new RewrittenAnnotationEncodedValue((AnnotationEncodedValue) encodedValue);
        default:
            return encodedValue;
    }
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
public static void getMethodAnnotaionPrepareClasses(DexDiffInfo dexDiffInfo, Set<String> prepareclasses){

        for (DexBackedMethod method:dexDiffInfo.getModifiedMethods()){
            Set<? extends Annotation>annotations = method.getAnnotations();
            if (annotations == null){
                continue;
            }
            for (Annotation annotation:annotations){
                String type = annotation.getType();
                if (type!= null&&type.startsWith("L")&&type.endsWith(";")){
                    prepareclasses.add(type.substring(1, type.length() - 1).replace('/', '.'));
                    System.out.println("prepare class: " + type);
                }
                Set<? extends AnnotationElement> elements = annotation.getElements();
                for (AnnotationElement dexBackedAnnotationElement:elements){
                    if (dexBackedAnnotationElement.getValue() instanceof DexBackedArrayEncodedValue){
                        List<? extends EncodedValue> values = ((DexBackedArrayEncodedValue) dexBackedAnnotationElement.getValue()).getValue();
                        for (EncodedValue encodedValue:values) {
                            if (encodedValue instanceof TypeEncodedValue) {
                                prepareclasses.add(((TypeEncodedValue) encodedValue).getValue().substring(1, ((TypeEncodedValue) encodedValue).getValue().length() - 1).replace('/', '.'));
                                System.out.println("prepare class: " + ((TypeEncodedValue) encodedValue).getValue());
                            }
                        }

                    }else if (dexBackedAnnotationElement.getValue() instanceof DexBackedTypeEncodedValue){
                        String value = ((DexBackedTypeEncodedValue) dexBackedAnnotationElement.getValue()).getValue();
                        prepareclasses.add(value.substring(1, value.length() - 1).replace('/', '.'));
                        System.out.println("prepare class: " + value);
                    }
                }
            }
        }

    }
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
public boolean equals(@Nullable Object o) {
    if (o instanceof TypeEncodedValue) {
        return getValue().equals(((TypeEncodedValue)o).getValue());
    }
    return false;
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
public boolean equals( Object o) {
    if (o instanceof TypeEncodedValue) {
        return getValue().equals(((TypeEncodedValue)o).getValue());
    }
    return false;
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Nonnull
public static ImmutableEncodedValue of(@Nonnull EncodedValue encodedValue) {
    switch (encodedValue.getValueType()) {
        case ValueType.BYTE:
            return ImmutableByteEncodedValue.of((ByteEncodedValue) encodedValue);
        case ValueType.SHORT:
            return ImmutableShortEncodedValue.of((ShortEncodedValue) encodedValue);
        case ValueType.CHAR:
            return ImmutableCharEncodedValue.of((CharEncodedValue) encodedValue);
        case ValueType.INT:
            return ImmutableIntEncodedValue.of((IntEncodedValue) encodedValue);
        case ValueType.LONG:
            return ImmutableLongEncodedValue.of((LongEncodedValue) encodedValue);
        case ValueType.FLOAT:
            return ImmutableFloatEncodedValue.of((FloatEncodedValue) encodedValue);
        case ValueType.DOUBLE:
            return ImmutableDoubleEncodedValue.of((DoubleEncodedValue) encodedValue);
        case ValueType.STRING:
            return ImmutableStringEncodedValue.of((StringEncodedValue) encodedValue);
        case ValueType.TYPE:
            return ImmutableTypeEncodedValue.of((TypeEncodedValue) encodedValue);
        case ValueType.FIELD:
            return ImmutableFieldEncodedValue.of((FieldEncodedValue) encodedValue);
        case ValueType.METHOD:
            return ImmutableMethodEncodedValue.of((MethodEncodedValue) encodedValue);
        case ValueType.ENUM:
            return ImmutableEnumEncodedValue.of((EnumEncodedValue) encodedValue);
        case ValueType.ARRAY:
            return ImmutableArrayEncodedValue.of((ArrayEncodedValue) encodedValue);
        case ValueType.ANNOTATION:
            return ImmutableAnnotationEncodedValue.of((AnnotationEncodedValue) encodedValue);
        case ValueType.NULL:
            return ImmutableNullEncodedValue.INSTANCE;
        case ValueType.BOOLEAN:
            return ImmutableBooleanEncodedValue.of((BooleanEncodedValue) encodedValue);
        default:
            Preconditions.checkArgument(false);
            return null;
    }
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
public boolean equals(@Nullable Object o) {
    if (o instanceof TypeEncodedValue) {
        return getValue().equals(((TypeEncodedValue) o).getValue());
    }
    return false;
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Nonnull
private BuilderEncodedValue internEncodedValue(@Nonnull EncodedValue encodedValue) {
    switch (encodedValue.getValueType()) {
        case ValueType.ANNOTATION:
            return internAnnotationEncodedValue((AnnotationEncodedValue) encodedValue);
        case ValueType.ARRAY:
            return internArrayEncodedValue((ArrayEncodedValue) encodedValue);
        case ValueType.BOOLEAN:
            boolean value = ((BooleanEncodedValue) encodedValue).getValue();
            return value ? BuilderBooleanEncodedValue.TRUE_VALUE : BuilderBooleanEncodedValue.FALSE_VALUE;
        case ValueType.BYTE:
            return new BuilderByteEncodedValue(((ByteEncodedValue) encodedValue).getValue());
        case ValueType.CHAR:
            return new BuilderCharEncodedValue(((CharEncodedValue) encodedValue).getValue());
        case ValueType.DOUBLE:
            return new BuilderDoubleEncodedValue(((DoubleEncodedValue) encodedValue).getValue());
        case ValueType.ENUM:
            return internEnumEncodedValue((EnumEncodedValue) encodedValue);
        case ValueType.FIELD:
            return internFieldEncodedValue((FieldEncodedValue) encodedValue);
        case ValueType.FLOAT:
            return new BuilderFloatEncodedValue(((FloatEncodedValue) encodedValue).getValue());
        case ValueType.INT:
            return new BuilderIntEncodedValue(((IntEncodedValue) encodedValue).getValue());
        case ValueType.LONG:
            return new BuilderLongEncodedValue(((LongEncodedValue) encodedValue).getValue());
        case ValueType.METHOD:
            return internMethodEncodedValue((MethodEncodedValue) encodedValue);
        case ValueType.NULL:
            return BuilderNullEncodedValue.INSTANCE;
        case ValueType.SHORT:
            return new BuilderShortEncodedValue(((ShortEncodedValue) encodedValue).getValue());
        case ValueType.STRING:
            return internStringEncodedValue((StringEncodedValue) encodedValue);
        case ValueType.TYPE:
            return internTypeEncodedValue((TypeEncodedValue) encodedValue);
        default:
            throw new ExceptionWithContext("Unexpected encoded value type: %d", encodedValue.getValueType());
    }
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
public static void writeTo(@Nonnull IndentingWriter writer, @Nonnull EncodedValue encodedValue,
                           @Nullable String containingClass)
        throws IOException {
    switch (encodedValue.getValueType()) {
        case ValueType.ANNOTATION:
            AnnotationEncodedValueAdaptor.writeTo(writer, (AnnotationEncodedValue) encodedValue, containingClass);
            return;
        case ValueType.ARRAY:
            ArrayEncodedValueAdaptor.writeTo(writer, (ArrayEncodedValue)encodedValue, containingClass);
            return;
        case ValueType.BOOLEAN:
            BooleanRenderer.writeTo(writer, ((BooleanEncodedValue) encodedValue).getValue());
            return;
        case ValueType.BYTE:
            ByteRenderer.writeTo(writer, ((ByteEncodedValue) encodedValue).getValue());
            return;
        case ValueType.CHAR:
            CharRenderer.writeTo(writer, ((CharEncodedValue) encodedValue).getValue());
            return;
        case ValueType.DOUBLE:
            DoubleRenderer.writeTo(writer, ((DoubleEncodedValue) encodedValue).getValue());
            return;
        case ValueType.ENUM:
            EnumEncodedValue enumEncodedValue = (EnumEncodedValue)encodedValue;
            boolean useImplicitReference = false;
            if (enumEncodedValue.getValue().getDefiningClass().equals(containingClass)) {
                useImplicitReference = true;
            }
            writer.write(".enum ");
            ReferenceUtil.writeFieldDescriptor(writer, enumEncodedValue.getValue(), useImplicitReference);
            return;
        case ValueType.FIELD:
            FieldEncodedValue fieldEncodedValue = (FieldEncodedValue)encodedValue;
            useImplicitReference = false;
            if (fieldEncodedValue.getValue().getDefiningClass().equals(containingClass)) {
                useImplicitReference = true;
            }
            ReferenceUtil.writeFieldDescriptor(writer, fieldEncodedValue.getValue(), useImplicitReference);
            return;
        case ValueType.FLOAT:
            FloatRenderer.writeTo(writer, ((FloatEncodedValue) encodedValue).getValue());
            return;
        case ValueType.INT:
            IntegerRenderer.writeTo(writer, ((IntEncodedValue) encodedValue).getValue());
            return;
        case ValueType.LONG:
            LongRenderer.writeTo(writer, ((LongEncodedValue) encodedValue).getValue());
            return;
        case ValueType.METHOD:
            MethodEncodedValue methodEncodedValue = (MethodEncodedValue)encodedValue;
            useImplicitReference = false;
            if (methodEncodedValue.getValue().getDefiningClass().equals(containingClass)) {
                useImplicitReference = true;
            }
            ReferenceUtil.writeMethodDescriptor(writer, methodEncodedValue.getValue(), useImplicitReference);
            return;
        case ValueType.NULL:
            writer.write("null");
            return;
        case ValueType.SHORT:
            ShortRenderer.writeTo(writer, ((ShortEncodedValue) encodedValue).getValue());
            return;
        case ValueType.STRING:
            ReferenceFormatter.writeStringReference(writer, ((StringEncodedValue) encodedValue).getValue());
            return;
        case ValueType.TYPE:
            writer.write(((TypeEncodedValue)encodedValue).getValue());
    }
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
public static ImmutableTypeEncodedValue of(@Nonnull TypeEncodedValue typeEncodedValue) {
    if (typeEncodedValue instanceof ImmutableTypeEncodedValue) {
        return (ImmutableTypeEncodedValue)typeEncodedValue;
    }
    return new ImmutableTypeEncodedValue(typeEncodedValue.getValue());
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
public int compareTo(@Nonnull EncodedValue o) {
    int res = Ints.compare(getValueType(), o.getValueType());
    if (res != 0) return res;
    return getValue().compareTo(((TypeEncodedValue)o).getValue());
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
public static ImmutableTypeEncodedValue of( TypeEncodedValue typeEncodedValue) {
    if (typeEncodedValue instanceof ImmutableTypeEncodedValue) {
        return (ImmutableTypeEncodedValue)typeEncodedValue;
    }
    return new ImmutableTypeEncodedValue(typeEncodedValue.getValue());
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
public int compareTo( EncodedValue o) {
    int res = Ints.compare(getValueType(), o.getValueType());
    if (res != 0) return res;
    return getValue().compareTo(((TypeEncodedValue)o).getValue());
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
public static ImmutableTypeEncodedValue of(@Nonnull TypeEncodedValue typeEncodedValue) {
    if (typeEncodedValue instanceof ImmutableTypeEncodedValue) {
        return (ImmutableTypeEncodedValue) typeEncodedValue;
    }
    return new ImmutableTypeEncodedValue(typeEncodedValue.getValue());
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
public int compareTo(@Nonnull EncodedValue o) {
    int res = Ints.compare(getValueType(), o.getValueType());
    if (res != 0) return res;
    return getValue().compareTo(((TypeEncodedValue) o).getValue());
}
 

import org.jf.dexlib2.iface.value.TypeEncodedValue; //导入依赖的package包/类
@Override
protected void writeEncodedValue(@Nonnull InternalEncodedValueWriter writer,
                                 @Nonnull EncodedValue encodedValue) throws IOException {
    switch (encodedValue.getValueType()) {
        case ValueType.ANNOTATION:
            AnnotationEncodedValue annotationEncodedValue = (AnnotationEncodedValue) encodedValue;
            writer.writeAnnotation(annotationEncodedValue.getType(), annotationEncodedValue.getElements());
            break;
        case ValueType.ARRAY:
            ArrayEncodedValue arrayEncodedValue = (ArrayEncodedValue) encodedValue;
            writer.writeArray(arrayEncodedValue.getValue());
            break;
        case ValueType.BOOLEAN:
            writer.writeBoolean(((BooleanEncodedValue) encodedValue).getValue());
            break;
        case ValueType.BYTE:
            writer.writeByte(((ByteEncodedValue) encodedValue).getValue());
            break;
        case ValueType.CHAR:
            writer.writeChar(((CharEncodedValue) encodedValue).getValue());
            break;
        case ValueType.DOUBLE:
            writer.writeDouble(((DoubleEncodedValue) encodedValue).getValue());
            break;
        case ValueType.ENUM:
            writer.writeEnum(((EnumEncodedValue) encodedValue).getValue());
            break;
        case ValueType.FIELD:
            writer.writeField(((FieldEncodedValue) encodedValue).getValue());
            break;
        case ValueType.FLOAT:
            writer.writeFloat(((FloatEncodedValue) encodedValue).getValue());
            break;
        case ValueType.INT:
            writer.writeInt(((IntEncodedValue) encodedValue).getValue());
            break;
        case ValueType.LONG:
            writer.writeLong(((LongEncodedValue) encodedValue).getValue());
            break;
        case ValueType.METHOD:
            writer.writeMethod(((MethodEncodedValue) encodedValue).getValue());
            break;
        case ValueType.NULL:
            writer.writeNull();
            break;
        case ValueType.SHORT:
            writer.writeShort(((ShortEncodedValue) encodedValue).getValue());
            break;
        case ValueType.STRING:
            writer.writeString(((StringEncodedValue) encodedValue).getValue());
            break;
        case ValueType.TYPE:
            writer.writeType(((TypeEncodedValue) encodedValue).getValue());
            break;
        default:
            throw new ExceptionWithContext("Unrecognized value type: %d", encodedValue.getValueType());
    }
}