import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
private synchronized XmlSchemaGenerator<TypeMirror, TypeDeclaration, FieldDeclaration, MethodDeclaration> getSchemaGenerator() {
    if(xsdgen==null) {
        xsdgen = new XmlSchemaGenerator<TypeMirror,TypeDeclaration,FieldDeclaration,MethodDeclaration>( types.getNavigator(), types );

        for (Map.Entry<QName, Reference> e : additionalElementDecls.entrySet()) {
            Reference value = e.getValue();
            if(value!=null) {
                NonElement<TypeMirror, TypeDeclaration> typeInfo = refMap.get(value);
                if(typeInfo==null)
                    throw new IllegalArgumentException(e.getValue()+" was not specified to JavaCompiler.bind");
                xsdgen.add(e.getKey(),!(value.type instanceof PrimitiveType),typeInfo);
            } else {
                xsdgen.add(e.getKey(),false,null);
            }
        }
    }
    return xsdgen;
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
private boolean testFieldModifiers(FieldDeclaration fieldDeclaration) {
    Collection<Modifier> modifiers = fieldDeclaration.getModifiers();

    // must not worry for private/protected. cannot be accessed from outside.
    if (modifiers.contains(Modifier.PROTECTED) || modifiers.contains(Modifier.PRIVATE))
        return true;

    // no public/package access without getters/setters for non final fields
    if (!fieldDeclaration.getModifiers().contains(Modifier.FINAL) &&
        !checkGettersSetters(fieldDeclaration.getSimpleName())) {
        reportWarning(fieldDeclaration, "The class declares the  " +
            (modifiers.contains(Modifier.PUBLIC) ? "public" : "package") + " field " +
            fieldDeclaration.getSimpleName() + ".\n" + ErrorMessages.NO_GETTERS_SETTERS_ERROR_MESSAGE);
        return false;
    }

    return true;
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
private static void validateField(FieldDeclaration field) {
	// Check if field is "public static final"
	Collection<Modifier> modifiers = field.getModifiers();
	if ( modifiers.size() != 3
	     || !modifiers.contains(Modifier.PUBLIC)
	     || !modifiers.contains(Modifier.STATIC)
	     || !modifiers.contains(Modifier.FINAL) ) {
		throw new RuntimeException("Field " + field.getSimpleName() + " is not declared public static final");
	}

	// Check suported types (int, long, float, String)
	TypeMirror field_type = field.getType();
	if ( field_type instanceof PrimitiveType ) {
		PrimitiveType field_type_prim = (PrimitiveType)field_type;
		PrimitiveType.Kind field_kind = field_type_prim.getKind();
		if ( field_kind != PrimitiveType.Kind.INT
		     && field_kind != PrimitiveType.Kind.LONG
		     && field_kind != PrimitiveType.Kind.FLOAT
		     && field_kind != PrimitiveType.Kind.BYTE ) {
			throw new RuntimeException("Field " + field.getSimpleName() + " is not of type 'int', 'long' or 'float'");
		}
	} else if ( "java.lang.String".equals(field_type.toString()) ) {
	} else {
		throw new RuntimeException("Field " + field.getSimpleName() + " is not a primitive type or String");
	}

	Object field_value = field.getConstantValue();
	if ( field_value == null ) {
		throw new RuntimeException("Field " + field.getSimpleName() + " has no initial value");
	}
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
private static void generateField(PrintWriter writer, FieldDeclaration field, FieldDeclaration prev_field) {
	validateField(field);

	Object value = field.getConstantValue();
	String field_value_string;
	Class field_value_class = value.getClass();
	if ( field_value_class.equals(Integer.class) ) {
		field_value_string = "0x" + Integer.toHexString((Integer)field.getConstantValue()).toUpperCase();
	} else if ( field_value_class.equals(Long.class) ) {
		field_value_string = "0x" + Long.toHexString((Long)field.getConstantValue()).toUpperCase() + 'L';
	} else if ( field_value_class.equals(Float.class) ) {
		field_value_string = field.getConstantValue() + "f";
	} else if ( value.getClass().equals(Byte.class) ) {
		field_value_string = "0x" + Integer.toHexString((Byte)field.getConstantValue()).toUpperCase();
	} else if ( field_value_class.equals(String.class) ) {
		field_value_string = "\"" + field.getConstantValue() + "\"";
	} else {
		throw new RuntimeException("Field is of unexpected type. This means there is a bug in validateField().");
	}

	boolean hadDoc = prev_field != null && prev_field.getDocComment() != null;
	boolean hasDoc = field.getDocComment() != null;
	boolean newBatch = prev_field == null || !prev_field.getType().equals(field.getType()) || (!hadDoc && field.getDocComment() != null) || (hadDoc && hasDoc && !prev_field.getDocComment().equals(field.getDocComment()));

	// Print field declaration
	if ( newBatch ) {
		if ( prev_field != null )
			writer.println(";\n");

		Utils.printDocComment(writer, field);
		writer.print("\tpublic static final " + field.getType().toString() + " " + field.getSimpleName() + " = " + field_value_string);
	} else
		writer.print(",\n\t\t" + field.getSimpleName() + " = " + field_value_string);
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public static void generateFields(PrintWriter writer, Collection<FieldDeclaration> fields) {
	if ( 0 < fields.size() ) {
		writer.println();
		FieldDeclaration prev_field = null;
		for ( FieldDeclaration field : fields ) {
			generateField(writer, field, prev_field);
			prev_field = field;
		}
		writer.println(";");
	}
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public J2SJAXBModel bind(
    Collection<Reference> rootClasses,
    Map<QName,Reference> additionalElementDecls,
    String defaultNamespaceRemap,
    AnnotationProcessorEnvironment env) {

    ModelBuilder<TypeMirror,TypeDeclaration,FieldDeclaration,MethodDeclaration> builder =
        new ModelBuilder<TypeMirror,TypeDeclaration,FieldDeclaration,MethodDeclaration>(
            InlineAnnotationReaderImpl.theInstance,
            new APTNavigator(env),
            Collections.<TypeDeclaration,TypeDeclaration>emptyMap(),
            defaultNamespaceRemap );

    builder.setErrorHandler(new ErrorHandlerImpl(env.getMessager()));

    for( Reference ref : rootClasses ) {
        TypeMirror t = ref.type;

        XmlJavaTypeAdapter xjta = ref.annotations.getAnnotation(XmlJavaTypeAdapter.class);
        XmlList xl = ref.annotations.getAnnotation(XmlList.class);

        builder.getTypeInfo(new Ref<TypeMirror,TypeDeclaration>(builder,t,xjta,xl));
    }

    TypeInfoSet r = builder.link();
    if(r==null)     return null;

    if(additionalElementDecls==null)
        additionalElementDecls = Collections.emptyMap();
    else {
        // fool proof check
        for (Map.Entry<QName, ? extends Reference> e : additionalElementDecls.entrySet()) {
            if(e.getKey()==null)
                throw new IllegalArgumentException("nulls in additionalElementDecls");
        }
    }
    return new JAXBModelImpl(r,builder.reader,rootClasses,new HashMap(additionalElementDecls));
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public FieldDeclaration getDeclaredField(TypeDeclaration clazz, String fieldName) {
    for( FieldDeclaration fd : clazz.getFields() ) {
        if(fd.getSimpleName().equals(fieldName))
            return fd;
    }
    return null;
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
@Override
public void visitClassDeclaration(ClassDeclaration classDeclaration) {

    _containingClass = classDeclaration;
    _containingClassMethods = classDeclaration.getMethods();

    testClassModifiers(classDeclaration);

    ConstructorCheckResult ccr = verifyConstructors(classDeclaration);

    if (!ccr.hasNoArgConstructor) {
        reportError(classDeclaration, ErrorMessages.NO_NOARG_CONSTRUCTOR_ERROR_MESSAGE);
    }

    if (ccr.isFinalNoArgConstructor) {
        reportError(classDeclaration, ErrorMessages.NO_NOARG_CONSTRUCTOR_CANNOT_BE_PRIVATE_MESSAGE);
    }

    //		if (!implementsSerializable(classDeclaration)) {
    //			reportWarning(classDeclaration, ErrorMessages.NO_SERIALIZABLE_ERROR_MESSAGE);
    //		}

    // super.visitClassDeclaration(classDeclaration);
    // visit the subcomponents of this class
    // this should have been already provided by the MirrorAPI. bad API, bad! :P
    final Collection<MethodDeclaration> methods = _containingClassMethods;
    for (MethodDeclaration methodDeclaration : methods) {
        methodDeclaration.accept(this);
    }

    final Collection<FieldDeclaration> fields = classDeclaration.getFields();
    for (FieldDeclaration fieldDeclaration : fields) {
        fieldDeclaration.accept(this);
    }

}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public static boolean applicableOnDeclaration(ElementType applicableType, Declaration typeDeclaration) {

        if (typeDeclaration instanceof ClassDeclaration)
            return applicableType.equals(ElementType.TYPE);
        if (typeDeclaration instanceof MethodDeclaration)
            return applicableType.equals(ElementType.METHOD);
        if (typeDeclaration instanceof FieldDeclaration)
            return applicableType.equals(ElementType.FIELD);
        if (typeDeclaration instanceof ConstructorDeclaration)
            return applicableType.equals(ElementType.CONSTRUCTOR);
        // TODO add others when needed

        return false;
    }
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public void visitFieldDeclaration(FieldDeclaration d) {
	// no-op		
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public void visitFieldDeclaration (FieldDeclaration fieldDeclaration)
{
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public JAXBModelImpl(TypeInfoSet<TypeMirror, TypeDeclaration, FieldDeclaration, MethodDeclaration> types,
                     AnnotationReader<TypeMirror, TypeDeclaration, FieldDeclaration, MethodDeclaration> reader,
                     Collection<Reference> rootClasses,
                     Map<QName, Reference> additionalElementDecls) {
    this.types = types;
    this.reader = reader;
    this.additionalElementDecls = additionalElementDecls;

    Navigator<TypeMirror,TypeDeclaration,FieldDeclaration,MethodDeclaration> navigator = types.getNavigator();

    for( ClassInfo<TypeMirror,TypeDeclaration> i : types.beans().values() ) {
        classList.add(i.getName());
    }

    for(ArrayInfo<TypeMirror,TypeDeclaration> a : types.arrays().values()) {
        String javaName = navigator.getTypeName(a.getType());
        classList.add(javaName);
    }

    for( EnumLeafInfo<TypeMirror,TypeDeclaration> l : types.enums().values() ) {
        QName tn = l.getTypeName();
        if(tn!=null) {
            String javaName = navigator.getTypeName(l.getType());
            classList.add(javaName);
        }
    }

    for (Reference ref : rootClasses)
        refMap.put(ref,getXmlType(ref));

    // check for collision between "additional" ones and the ones given to JAXB
    // and eliminate duplication
    Iterator<Map.Entry<QName, Reference>> itr = additionalElementDecls.entrySet().iterator();
    while(itr.hasNext()) {
        Map.Entry<QName, Reference> entry = itr.next();
        if(entry.getValue()==null)      continue;

        NonElement<TypeMirror,TypeDeclaration> xt = getXmlType(entry.getValue());

        assert xt!=null;
        refMap.put(entry.getValue(),xt);
        if(xt instanceof ClassInfo) {
            ClassInfo<TypeMirror,TypeDeclaration> xct = (ClassInfo<TypeMirror,TypeDeclaration>) xt;
            Element<TypeMirror,TypeDeclaration> elem = xct.asElement();
            if(elem!=null && elem.getElementName().equals(entry.getKey())) {
                itr.remove();
                continue;
            }
        }
        ElementInfo<TypeMirror,TypeDeclaration> ei = types.getElementInfo(null,entry.getKey());
        if(ei!=null && ei.getContentType()==xt)
            itr.remove();
    }
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public Collection<FieldDeclaration> getDeclaredFields(TypeDeclaration c) {
    List<FieldDeclaration> l = new ArrayList<FieldDeclaration>(c.getFields());
    return sort(l);
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public ClassDeclaration getDeclaringClassForField(FieldDeclaration f) {
    return (ClassDeclaration)f.getDeclaringType();
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public TypeMirror getFieldType(FieldDeclaration f) {
    return f.getType();
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public String getFieldName(FieldDeclaration f) {
    return f.getSimpleName();
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public FieldDeclaration[] getEnumConstants(TypeDeclaration clazz) {
    EnumDeclaration ed = (EnumDeclaration) clazz;
    Collection<EnumConstantDeclaration> constants = ed.getEnumConstants();
    return constants.toArray(new EnumConstantDeclaration[constants.size()]);
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public boolean isTransient(FieldDeclaration f) {
    return f.getModifiers().contains(Modifier.TRANSIENT);
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public Location getFieldLocation(FieldDeclaration decl) {
    return getLocation(decl);
}
 

import com.sun.mirror.declaration.FieldDeclaration; //导入依赖的package包/类
public boolean isStaticField(FieldDeclaration f) {
    return hasModifier(f,Modifier.STATIC);
}