import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
	Class annotation_class = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
	if ( annotation_class.equals(GLint.class) )
		return "GL11.GL_INT";
	else if ( annotation_class.equals(GLbyte.class) )
		return "GL11.GL_BYTE";
	else if ( annotation_class.equals(GLshort.class) )
		return "GL11.GL_SHORT";
	if ( annotation_class.equals(GLuint.class) )
		return "GL11.GL_UNSIGNED_INT";
	else if ( annotation_class.equals(GLubyte.class) )
		return "GL11.GL_UNSIGNED_BYTE";
	else if ( annotation_class.equals(GLushort.class) )
		return "GL11.GL_UNSIGNED_SHORT";
	else if ( annotation_class.equals(GLfloat.class) )
		return "GL11.GL_FLOAT";
	else if ( annotation_class.equals(GLdouble.class) )
		return "GL11.GL_DOUBLE";
	else
		return null;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
	Class annotation_class = NativeTypeTranslator.getClassFromType(annotation.getAnnotationType());
	if ( annotation_class.equals(GLint.class) )
		return "GLES20.GL_INT";
	else if ( annotation_class.equals(GLbyte.class) )
		return "GLES20.GL_BYTE";
	else if ( annotation_class.equals(GLshort.class) )
		return "GLES20.GL_SHORT";
	if ( annotation_class.equals(GLuint.class) )
		return "GLES20.GL_UNSIGNED_INT";
	else if ( annotation_class.equals(GLubyte.class) )
		return "GLES20.GL_UNSIGNED_BYTE";
	else if ( annotation_class.equals(GLushort.class) )
		return "GLES20.GL_UNSIGNED_SHORT";
	else if ( annotation_class.equals(GLfloat.class) )
		return "GLES20.GL_FLOAT";
	else
		return null;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
/**
 * Gets all the annotations on the given declaration.
 */
private Annotation[] getAllAnnotations(Declaration decl, Locatable srcPos) {
    List<Annotation> r = new ArrayList<Annotation>();

    for( AnnotationMirror m : decl.getAnnotationMirrors() ) {
        try {
            String fullName = m.getAnnotationType().getDeclaration().getQualifiedName();
            Class<? extends Annotation> type =
                getClass().getClassLoader().loadClass(fullName).asSubclass(Annotation.class);
            Annotation annotation = decl.getAnnotation(type);
            if(annotation!=null)
                r.add( LocatableAnnotation.create(annotation,srcPos) );
        } catch (ClassNotFoundException e) {
            // just continue
        }
    }

    return r.toArray(EMPTY_ANNOTATION);
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
private static Class translateAnnotation(AnnotationMirror annotation) {
	NativeType native_type = getAnnotation(annotation, NativeType.class);
	if ( native_type != null ) {
		return getClassFromType(annotation.getAnnotationType());
	} else
		return null;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
private Collection<Class> translateAnnotations() {
	Collection<Class> result = new ArrayList<Class>();
	for ( AnnotationMirror annotation : Utils.getSortedAnnotations(declaration.getAnnotationMirrors()) ) {
		Class translated_result = translateAnnotation(annotation);
		if ( translated_result != null ) {
			result.add(translated_result);
		}
	}
	return result;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
static int getAnnotationLineNumber (MethodDeclaration method, String className)
{
	for (AnnotationMirror mirror : method.getAnnotationMirrors ())
	{
		if (!className.equals (mirror.getAnnotationType ().getDeclaration ().getQualifiedName ()))
			continue;
		SourcePosition pos = mirror.getPosition ();
		return pos == null ? 0 : pos.line ();
	}
	return 0;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
static int[] getAnnotationArrayLineNumbers (MethodDeclaration method, String className, String attr)
{
	for (AnnotationMirror mirror : method.getAnnotationMirrors ())
	{
		if (!className.equals (mirror.getAnnotationType ().getDeclaration ().getQualifiedName ()))
			continue;
		Map<AnnotationTypeElementDeclaration, AnnotationValue> map = mirror.getElementValues ();
		for (AnnotationTypeElementDeclaration key : map.keySet ())
		{
			if (!attr.equals (key.getSimpleName ()))
				continue;
			@SuppressWarnings ("unchecked")
			Collection<AnnotationValue> c = (Collection<AnnotationValue>)map.get (key).getValue ();
			if (c == null)
				return null;
			int[] returnVal = new int[c.size ()];
			int i = 0;
			for (AnnotationValue v : c)
			{
				SourcePosition pos = v.getPosition ();
				if (pos == null)
					returnVal[i++] = 0;
				else
					returnVal[i++] = pos.line ();
			}
			return returnVal;
		}
	}
	return null;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
private String derivedClassName(ClassDeclaration d) {
  String generatedClass;
  AnnotationMirror ann = getAnnotation(d,GEN_IMPL_ANNOTATION);
  if (ann != null) {
    generatedClass = getAnnotationElementValue("generatedClass()", ann);
  } else {
    generatedClass = d.getQualifiedName()+"Impl";
  }
  return generatedClass;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
/**
 * Return an annotation from a declaration, given its fq name
 *
 * @param d The declaration to look at
 * @param annotationName Name of the annotation
 */
private static AnnotationMirror getAnnotation(Declaration d, String annotationName) {
  for (AnnotationMirror ann : d.getAnnotationMirrors()) {
    AnnotationType type = ann.getAnnotationType();
    if (type.toString().equals(annotationName)) {
      return ann;
    }
  }
  return null;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
/**
 * Get the value of an element of an annotation
 *
 * @param elementName
 * @param ann
 * @return
 */
private static String getAnnotationElementValue(String elementName, AnnotationMirror ann) {
  Map<AnnotationTypeElementDeclaration,AnnotationValue> values =
    ann.getElementValues();
  for (AnnotationTypeElementDeclaration element : values.keySet()) {
    if (element.toString().equals(elementName)) {
      AnnotationValue val = values.get(element);
      return (String)val.getValue();
    }
  }
  return null;
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
public static <T extends Annotation> T getAnnotation(AnnotationMirror annotation, Class<T> type) {
	return annotation.getAnnotationType().getDeclaration().getAnnotation(type);
}
 

import com.sun.mirror.declaration.AnnotationMirror; //导入依赖的package包/类
public String getAutoTypeFromAnnotation(AnnotationMirror annotation) {
	return null;
}