org.jf.dexlib2.immutable.ImmutableAnnotationElement Java Examples

private List<ImmutableAnnotation> buildVisibilityAnnotationTag
		(VisibilityAnnotationTag t, Set<String> skipList) {
   	if (t.getAnnotations() == null)
   		return Collections.emptyList();
   	
   	List<ImmutableAnnotation> annotations = new ArrayList<ImmutableAnnotation>();
       for (AnnotationTag at: t.getAnnotations()) {
           String type = at.getType();
           if (!skipList.add(type))
           	continue;
           
           Set<String> alreadyWritten = new HashSet<String>();
           List<AnnotationElement> elements = null;
           if (!at.getElems().isEmpty()) {
           	elements = new ArrayList<AnnotationElement>();
            for (AnnotationElem ae : at.getElems()) {
            	if (ae.getName() == null || ae.getName().isEmpty())
            		throw new RuntimeException("Null or empty annotation name encountered");
            	if (!alreadyWritten.add(ae.getName()))
            		throw new RuntimeException("Duplicate annotation attribute: " + ae.getName());
            	
                EncodedValue value = buildEncodedValueForAnnotation(ae);
                ImmutableAnnotationElement element = new ImmutableAnnotationElement
                		(ae.getName(), value);
                elements.add(element);
            }
           }
           
           String typeName = SootToDexUtils.getDexClassName(at.getType());
           ImmutableAnnotation ann = new ImmutableAnnotation(getVisibility(t.getVisibility()),
           		typeName, elements);
           annotations.add(ann);
       }
       return annotations;
}
 

private Annotation buildEnclosingMethodTag(EnclosingMethodTag t, Set<String> skipList) {
	if (!skipList.add("Ldalvik/annotation/EnclosingMethod;"))
		return null;
	
	if (t.getEnclosingMethod() == null)
		return null;

	String[] split1 = t.getEnclosingMethodSig().split("\\)");
 String parametersS = split1[0].replaceAll("\\(", "");
 String returnTypeS = split1[1];
 
 List<String> typeList = new ArrayList<String>();
    if (!parametersS.equals("")) {
        for (String p : Util.splitParameters(parametersS)) {
            if (!p.isEmpty())
            	typeList.add(p);
        }
    }
    
 ImmutableMethodReference mRef = new ImmutableMethodReference
 		(SootToDexUtils.getDexClassName(t.getEnclosingClass()),
 		t.getEnclosingMethod(), typeList, returnTypeS);
	ImmutableMethodEncodedValue methodRef = new ImmutableMethodEncodedValue
			(dexFile.internMethodReference(mRef));
	AnnotationElement methodElement = new ImmutableAnnotationElement("value", methodRef);
	
	return new ImmutableAnnotation(AnnotationVisibility.SYSTEM,
			"Ldalvik/annotation/EnclosingMethod;",
			Collections.singleton(methodElement));
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable ImmutableSet<? extends ImmutableAnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableUtils.nullToEmptySet(elements);
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable ImmutableSet<? extends ImmutableAnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableUtils.nullToEmptySet(elements);
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable Collection<? extends AnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableAnnotationElement.immutableSetOf(elements);
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable ImmutableSet<? extends ImmutableAnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableUtils.nullToEmptySet(elements);
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable Collection<? extends AnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableAnnotationElement.immutableSetOf(elements);
}
 

private List<Annotation> buildMemberClassesAttribute(SootClass parentClass,
 		InnerClassAttribute t, Set<String> skipList) {
 	List<Annotation> anns = null;
 	Set<String> memberClasses = null;
 	
 	// Collect the inner classes
 	for (Tag t2 : t.getSpecs()) {
 		InnerClassTag icTag = (InnerClassTag) t2;
 		String outerClass = getOuterClassNameFromTag(icTag);

// Only classes with names are member classes
if (icTag.getOuterClass() != null
		&& parentClass.getName().equals(outerClass)) {
	if (memberClasses == null)
		memberClasses = new HashSet<String>();
	memberClasses.add(SootToDexUtils.getDexClassName(icTag.getInnerClass()));
}
 	}
 	
 	// Write the member classes
 	if (memberClasses != null
 			&& !memberClasses.isEmpty()
 			&& skipList.add("Ldalvik/annotation/MemberClasses;")) {
     	List<EncodedValue> classes = new ArrayList<EncodedValue>();
  	for (String memberClass : memberClasses) {
  		ImmutableTypeEncodedValue classValue = new ImmutableTypeEncodedValue(memberClass);
  		classes.add(classValue);
  	}
  	
 		ImmutableArrayEncodedValue classesValue =
 				new ImmutableArrayEncodedValue(classes);
 		ImmutableAnnotationElement element =
 				new ImmutableAnnotationElement("value", classesValue);
  	ImmutableAnnotation memberAnnotation =
 				new ImmutableAnnotation(AnnotationVisibility.SYSTEM,
 						"Ldalvik/annotation/MemberClasses;",
 						Collections.singletonList(element));
  	if (anns == null) anns = new ArrayList<Annotation>();
  	anns.add(memberAnnotation);
 	}
 	return anns;
 }
 

private List<Annotation> buildInnerClassAttribute(SootClass parentClass,
 		InnerClassAttribute t, Set<String> skipList) {
 	if (t.getSpecs() == null)
 		return null;
 	
 	List<Annotation> anns = null;
 	for (Tag t2 : t.getSpecs()) {
 		InnerClassTag icTag = (InnerClassTag) t2;
 		
     	// In Dalvik, both the EnclosingMethod/EnclosingClass tag and the
     	// InnerClass tag are written to the inner class which is different
     	// to Java. We thus check whether this tag actually points to our
 		// outer class.
 		String outerClass = getOuterClassNameFromTag(icTag);
String innerClass = icTag.getInnerClass().replaceAll("/", ".");
			
// Only write the InnerClass tag to the inner class itself, not
// the other one. If the outer class points to our parent, but
// this is simply the wrong inner class, we also continue with the
// next tag.
 		if (!parentClass.hasOuterClass()
 				|| !innerClass.equals(parentClass.getName()))
 			continue;
 		
 		// If the outer class points to the very same class, we null it
 		if (parentClass.getName().equals(outerClass)
 				&& icTag.getOuterClass() == null)
 			outerClass = null;
 		
 		// Do not write garbage. Never.
 		if (parentClass.getName().equals(outerClass))
 			continue;
 		
 		// This is an actual inner class. Write the annotation
     	if (skipList.add("Ldalvik/annotation/InnerClass;")) {
  		// InnerClass annotation
      	List<AnnotationElement> elements = new ArrayList<AnnotationElement>();
   	
   	ImmutableAnnotationElement flagsElement = new ImmutableAnnotationElement
   			("accessFlags", new ImmutableIntEncodedValue(icTag.getAccessFlags()));
   	elements.add(flagsElement);
   	
   	ImmutableEncodedValue nameValue;
   	if (icTag.getShortName() != null && !icTag.getShortName().isEmpty())
   		nameValue = new ImmutableStringEncodedValue(icTag.getShortName());
   	else
   		nameValue = ImmutableNullEncodedValue.INSTANCE;
   	
   	ImmutableAnnotationElement nameElement = new ImmutableAnnotationElement
    		("name", nameValue);
    elements.add(nameElement);
   	
   	if (anns == null) anns = new ArrayList<Annotation>();
   	anns.add(new ImmutableAnnotation(AnnotationVisibility.SYSTEM,
   			"Ldalvik/annotation/InnerClass;",
   			elements));
     	}
 	}
 	    	
 	return anns;
 }
 

private List<ImmutableAnnotation> buildVisibilityParameterAnnotationTag
  		(VisibilityParameterAnnotationTag t, Set<String> skipList,
  				int paramIdx) {
if (t.getVisibilityAnnotations() == null)
  		return Collections.emptyList();

      int paramTagIdx = 0;
  	List<ImmutableAnnotation> annotations = new ArrayList<ImmutableAnnotation>();
      for (VisibilityAnnotationTag vat : t.getVisibilityAnnotations()) {
      	if (paramTagIdx == paramIdx
      			&& vat != null
      			&& vat.getAnnotations() != null)
       	for (AnnotationTag at : vat.getAnnotations()) {
            String type = at.getType();
            if (!skipList.add(type))
            	continue;
            
            Set<String> alreadyWritten = new HashSet<String>();
            List<AnnotationElement> elements = null;
            if (!at.getElems().isEmpty()) {
            	elements = new ArrayList<AnnotationElement>();
	            for (AnnotationElem ae : at.getElems()) {
	            	if (ae.getName() == null || ae.getName().isEmpty())
	            		throw new RuntimeException("Null or empty annotation name encountered");
	            	if (!alreadyWritten.add(ae.getName()))
	            		throw new RuntimeException("Duplicate annotation attribute: " + ae.getName());
	
	            	EncodedValue value = buildEncodedValueForAnnotation(ae);
	                ImmutableAnnotationElement element = new ImmutableAnnotationElement(ae.getName(), value);
	                elements.add(element);
	            }
            }
            
            ImmutableAnnotation ann = new ImmutableAnnotation(getVisibility(vat.getVisibility()),
            		SootToDexUtils.getDexClassName(at.getType()),
            		elements);
            annotations.add(ann);
       	}
      	paramTagIdx++;
      }
      return annotations;
  }
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable ImmutableSet<? extends ImmutableAnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableUtils.nullToEmptySet(elements);
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable Collection<? extends AnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableAnnotationElement.immutableSetOf(elements);
}
 

public ImmutableAnnotationEncodedValue(@Nonnull String type,
                                       @Nullable Collection<? extends AnnotationElement> elements) {
    this.type = type;
    this.elements = ImmutableAnnotationElement.immutableSetOf(elements);
}
 

@Nonnull @Override public ImmutableSet<? extends ImmutableAnnotationElement> getElements() { return elements; } 

@Nonnull @Override public ImmutableSet<? extends ImmutableAnnotationElement> getElements() { return elements; } 

@Nonnull @Override public ImmutableSet<? extends ImmutableAnnotationElement> getElements() { return elements; } 

@Nonnull @Override public ImmutableSet<? extends ImmutableAnnotationElement> getElements() { return elements; }