Java AttEnclosingMethod类代码示例

import com.android.dx.cf.attrib.AttEnclosingMethod; //导入依赖的package包/类
/**
 * Gets the {@code EnclosingMethod} attribute out of a given
 * {@link AttributeList}, if any, translating it to an annotation.
 * If the class really has an enclosing method, this returns an
 * {@code EnclosingMethod} annotation; if not, this returns
 * an {@code EnclosingClass} annotation.
 *
 * @param attribs {@code non-null;} the attributes list to search in
 * @return {@code null-ok;} the converted {@code EnclosingMethod} or
 * {@code EnclosingClass} annotation, if there was an
 * attribute to translate
 */
private static Annotation translateEnclosingMethod(AttributeList attribs) {
    AttEnclosingMethod enclosingMethod = (AttEnclosingMethod)
        attribs.findFirst(AttEnclosingMethod.ATTRIBUTE_NAME);

    if (enclosingMethod == null) {
        return null;
    }

    CstType enclosingClass = enclosingMethod.getEnclosingClass();
    CstNat nat = enclosingMethod.getMethod();

    if (nat == null) {
        /*
         * Dalvik doesn't use EnclosingMethod annotations unless
         * there really is an enclosing method. Anonymous classes
         * are unambiguously identified by having an InnerClass
         * annotation with an empty name along with an appropriate
         * EnclosingClass.
         */
        return AnnotationUtils.makeEnclosingClass(enclosingClass);
    }

    return AnnotationUtils.makeEnclosingMethod(
            new CstMethodRef(enclosingClass, nat));
}
 

import com.android.dx.cf.attrib.AttEnclosingMethod; //导入依赖的package包/类
/**
 * Parses an {@code EnclosingMethod} attribute.
 */
private Attribute enclosingMethod(DirectClassFile cf, int offset,
        int length, ParseObserver observer) {
    if (length != 4) {
        throwBadLength(4);
    }

    ByteArray bytes = cf.getBytes();
    ConstantPool pool = cf.getConstantPool();

    int idx = bytes.getUnsignedShort(offset);
    CstType type = (CstType) pool.get(idx);

    idx = bytes.getUnsignedShort(offset + 2);
    CstNat method = (CstNat) pool.get0Ok(idx);

    Attribute result = new AttEnclosingMethod(type, method);

    if (observer != null) {
        observer.parsed(bytes, offset, 2, "class: " + type);
        observer.parsed(bytes, offset + 2, 2, "method: " +
                        DirectClassFile.stringOrNone(method));
    }

    return result;
}
 

import com.android.dx.cf.attrib.AttEnclosingMethod; //导入依赖的package包/类
/**
 * Creates an XMLVM element for the given type and appends it to the given
 * root element.
 * 
 * @param cf
 *            the {@link DirectClassFile} instance of this class
 * @param root
 *            the root element to append the generated element to
 * @param referencedTypes
 *            will be filled with the types references in this class file
 * @return the generated element
 */
private Element processClass(DirectClassFile cf, Element root,
        Map<String, ReferenceKind> referencedTypes) {
    Element classElement = new Element("class", NS_XMLVM);
    CstType type = cf.getThisClass();
    PackagePlusClassName parsedClassName = parseClassName(type.getClassType().getClassName());
    addReference(referencedTypes, parsedClassName.toString(), ReferenceKind.SELF);
    classElement.setAttribute("name", parsedClassName.className);
    classElement.setAttribute("package", parsedClassName.packageName);
    String superClassName = "";

    // if we are an innerclass add the enclosingMethod
    AttEnclosingMethod enclosingMethodAnnotation = (AttEnclosingMethod) cf.getAttributes().findFirst(
            AttEnclosingMethod.ATTRIBUTE_NAME);

    if (enclosingMethodAnnotation != null) {
        CstType enclosingClass=enclosingMethodAnnotation.getEnclosingClass();
        CstNat enclosingMethod = enclosingMethodAnnotation.getMethod();
        if(enclosingClass!=null){
            addReference(referencedTypes, enclosingClass.toHuman(), ReferenceKind.USAGE);
            classElement.setAttribute("enclosingClass", enclosingClass.toHuman());
        }
        if(enclosingMethod!=null){
            classElement.setAttribute("enclosingMethod", enclosingMethod.toHuman());
        }
    }
    
    //get signature annotation if availabke
    AttSignature signatureAnnotation=(AttSignature) cf.getAttributes().findFirst(
            AttSignature.ATTRIBUTE_NAME);
    
    if(signatureAnnotation!=null){
        classElement.setAttribute("signature", signatureAnnotation.getSignature().toHuman());
    }
    
    // This can happen for java.lang.Object.
    if (cf.getSuperclass() != null) {
        superClassName = parseClassName(cf.getSuperclass().getClassType().getClassName())
                .toString();
        addReference(referencedTypes, superClassName, ReferenceKind.SUPER_CLASS);
    }

    classElement.setAttribute("extends", superClassName);

    processAccessFlags(cf.getAccessFlags(), classElement);

    TypeList interfaces = cf.getInterfaces();
    if (interfaces.size() > 0) {
        String interfaceList = "";
        for (int i = 0; i < interfaces.size(); ++i) {
            if (i > 0) {
                interfaceList += ",";
            }
            String interfaceName = parseClassName(interfaces.getType(i).getClassName())
                    .toString();
            interfaceList += interfaceName;
            addReference(referencedTypes, interfaceName, ReferenceKind.INTERFACE);
        }
        classElement.setAttribute("interfaces", interfaceList);
    }

    root.addContent(classElement);
    return classElement;
}