import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
private void generate( ClassOutlineImpl outline, CPropertyInfo prop ) {
    // add isSetXXX and unsetXXX.
    MethodWriter writer = outline.createMethodWriter();

    JCodeModel codeModel = outline.parent().getCodeModel();

    FieldAccessor acc = core.create(JExpr._this());

    if( generateIsSetMethod ) {
        // [RESULT] boolean isSetXXX()
        JExpression hasSetValue = acc.hasSetValue();
        if( hasSetValue==null ) {
            // this field renderer doesn't support the isSet/unset methods generation.
            // issue an error
            throw new UnsupportedOperationException();
        }
        writer.declareMethod(codeModel.BOOLEAN,"isSet"+this.prop.getName(true))
            .body()._return( hasSetValue );
    }

    if( generateUnSetMethod ) {
        // [RESULT] void unsetXXX()
        acc.unsetValues(
            writer.declareMethod(codeModel.VOID,"unset"+this.prop.getName(true)).body() );
    }
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
ConstField( ClassOutlineImpl outline, CPropertyInfo prop ) {
    super(outline,prop);

    // we only support value constraints for a single-value property.
    assert !prop.isCollection();

    JPrimitiveType ptype = implType.boxify().getPrimitiveType();

    // generate the constant
    JExpression defaultValue = null;
    if(prop.defaultValue!=null)
        defaultValue = prop.defaultValue.compute(outline.parent());

    $ref = outline.ref.field(JMod.PUBLIC|JMod.STATIC|JMod.FINAL,
        ptype!=null?ptype:implType, prop.getName(true), defaultValue );
    $ref.javadoc().append(prop.javadoc);

    annotate($ref);
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
public void build(XSComplexType ct) {
    XSContentType contentType = ct.getContentType();

    builder.recordBindingMode(ct, FALLBACK_CONTENT);
    BIProperty prop = BIProperty.getCustomization(ct);

    CPropertyInfo p;

    if(contentType.asEmpty()!=null) {
        p = prop.createValueProperty("Content",false,ct,CBuiltinLeafInfo.STRING,null);
    } else {
        RawTypeSet ts = RawTypeSetBuilder.build(contentType.asParticle(),false);
        p = prop.createReferenceProperty("Content", false, ct, ts, true, false, true, false);
    }

    selector.getCurrentBean().addProperty(p);

    // adds attributes and we are through.
    green.attContainer(ct);
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * Gets all the {@link FieldOutline}s newly declared
 * in this class.
 */
public final FieldOutline[] getDeclaredFields() {
    List<CPropertyInfo> props = target.getProperties();
    FieldOutline[] fr = new FieldOutline[props.size()];
    for( int i=0; i<fr.length; i++ )
        fr[i] = parent().getField(props.get(i));
    return fr;
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
protected IsSetField( ClassOutlineImpl outline, CPropertyInfo prop,
        FieldOutline core, boolean unsetMethod, boolean issetMethod ) {
    super(outline,prop);
    this.core = core;
    this.generateIsSetMethod = issetMethod;
    this.generateUnSetMethod = unsetMethod;

    generate(outline,prop);
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
protected AbstractField( ClassOutlineImpl outline, CPropertyInfo prop ) {
    this.outline = outline;
    this.prop = prop;
    this.codeModel = outline.parent().getCodeModel();
    this.implType = getType(IMPLEMENTATION);
    this.exposedType = getType(Aspect.EXPOSED);
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * Returns contents to be added to javadoc.
 */
protected final List<Object> listPossibleTypes( CPropertyInfo prop ) {
    List<Object> r = new ArrayList<Object>();
    for( CTypeInfo tt : prop.ref() ) {
        JType t = tt.getType().toType(outline.parent(),Aspect.EXPOSED);
        if( t.isPrimitive() || t.isArray() )
            r.add(t.fullName());
        else {
            r.add(t);
            r.add("\n");
        }
    }

    return r;
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * @param coreList
 *      A concrete class that implements the List interface.
 *      An instance of this class will be used to store data
 *      for this field.
 */
protected NoExtendedContentField(ClassOutlineImpl context, CPropertyInfo prop, JClass coreList) {
    // the JAXB runtime picks ArrayList if the signature is List,
    // so don't do eager allocation if it's ArrayList.
    // otherwise we need to do eager allocation so that the collection type specified by the user
    // will be used.
    super(context, prop, false);
    this.coreList = coreList;
    generate();
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * @param coreList
 *      A concrete class that implements the List interface.
 *      An instance of this class will be used to store data
 *      for this field.
 */
protected DummyListField(ClassOutlineImpl context, CPropertyInfo prop, JClass coreList) {
    // the JAXB runtime picks ArrayList if the signature is List,
    // so don't do eager allocation if it's ArrayList.
    // otherwise we need to do eager allocation so that the collection type specified by the user
    // will be used.
    super(context, prop, !coreList.fullName().equals("java.util.ArrayList"));
    this.coreList = coreList.narrow(exposedType.boxify());
    generate();
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * Call {@link #generate()} method right after this.
 */
protected AbstractListField(ClassOutlineImpl outline, CPropertyInfo prop, boolean eagerInstanciation) {
    super(outline,prop);
    this.eagerInstanciation = eagerInstanciation;

    if( implType instanceof JPrimitiveType ) {
        // primitive types don't have this tricky distinction
        assert implType==exposedType;
        primitiveType = (JPrimitiveType)implType;
    } else
        primitiveType = null;
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * @param coreList
 *      A concrete class that implements the List interface.
 *      An instance of this class will be used to store data
 *      for this field.
 */
protected UntypedListField(ClassOutlineImpl context, CPropertyInfo prop, JClass coreList) {
    // the JAXB runtime picks ArrayList if the signature is List,
    // so don't do eager allocation if it's ArrayList.
    // otherwise we need to do eager allocation so that the collection type specified by the user
    // will be used.
    super(context, prop, !coreList.fullName().equals("java.util.ArrayList"));
    this.coreList = coreList.narrow(exposedType.boxify());
    generate();
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * @param coreList
 *      A concrete class that implements the List interface.
 *      An instance of this class will be used to store data
 *      for this field.
 */
protected ContentListField(ClassOutlineImpl context, CPropertyInfo prop, JClass coreList) {
    // the JAXB runtime picks ArrayList if the signature is List,
    // so don't do eager allocation if it's ArrayList.
    // otherwise we need to do eager allocation so that the collection type specified by the user
    // will be used.
    super(context, prop, false);
    this.coreList = coreList;
    generate();
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
private FieldRenderer decideRenderer(ClassOutlineImpl outline, CPropertyInfo prop) {

        if (prop instanceof CReferencePropertyInfo) {
            CReferencePropertyInfo p = (CReferencePropertyInfo)prop;
            if (p.isDummy()) {
                return frf.getDummyList(outline.parent().getCodeModel().ref(ArrayList.class));
            }
            if (p.isContent() && (p.isMixedExtendedCust())) {
                return frf.getContentList(outline.parent().getCodeModel().ref(ArrayList.class).narrow(Serializable.class));
            }
        }

        if(!prop.isCollection()) {
            // non-collection field

            // TODO: check for bidning info for optionalPrimitiveType=boxed or
            // noHasMethod=false and noDeletedMethod=false
            if(prop.isUnboxable())
                // this one uses a primitive type as much as possible
                return frf.getRequiredUnboxed();
            else
                // otherwise use the default non-collection field
                return frf.getSingle();
        }

        if( defaultCollectionFieldRenderer==null ) {
            return frf.getList(outline.parent().getCodeModel().ref(ArrayList.class));
        }

        // this field is a collection field.
        // use untyped list as the default. This is consistent
        // to the JAXB spec.
        return defaultCollectionFieldRenderer;
    }
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
public FieldOutline generate(ClassOutlineImpl context, CPropertyInfo prop) {
    if (dummy) {
        return new DummyListField(context, prop, coreList);
    }
    if (content) {
        return new ContentListField(context, prop, coreList);
    }
    return new UntypedListField(context, prop, coreList);
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
public GenericFieldRenderer( Class fieldClass ) {
    try {
        constructor = fieldClass.getDeclaredConstructor(new Class[]{ClassOutlineImpl.class,CPropertyInfo.class});
    } catch (NoSuchMethodException e) {
        throw new NoSuchMethodError(e.getMessage());
    }
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * Determines the FieldRenderer used for the given FieldUse,
 * then generates the field declaration and accessor methods.
 *
 * The <code>fields</code> map will be updated with the newly
 * created FieldRenderer.
 */
private FieldOutline generateFieldDecl(ClassOutlineImpl cc, CPropertyInfo prop) {
    FieldRenderer fr = prop.realization;
    if (fr == null) // none is specified. use the default factory
    {
        fr = model.options.getFieldRendererFactory().getDefault();
    }

    FieldOutline field = fr.generate(cc, prop);
    fields.put(prop, field);

    return field;
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * Generates {@link XmlJavaTypeAdapter} from {@link PropertyInfo} if necessary.
 * Also generates other per-property annotations
 * (such as {@link XmlID}, {@link XmlIDREF}, and {@link XmlMimeType} if necessary.
 */
public final void generateAdapterIfNecessary(CPropertyInfo prop, JAnnotatable field) {
    CAdapter adapter = prop.getAdapter();
    if (adapter != null) {
        if (adapter.getAdapterIfKnown() == SwaRefAdapterMarker.class) {
            field.annotate(XmlAttachmentRef.class);
        } else {
            // [RESULT]
            // @XmlJavaTypeAdapter( Foo.class )
            XmlJavaTypeAdapterWriter xjtw = field.annotate2(XmlJavaTypeAdapterWriter.class);
            xjtw.value(adapter.adapterType.toType(this, EXPOSED));
        }
    }

    switch (prop.id()) {
        case ID:
            field.annotate(XmlID.class);
            break;
        case IDREF:
            field.annotate(XmlIDREF.class);
            break;
    }

    if (prop.getExpectedMimeType() != null) {
        field.annotate2(XmlMimeTypeWriter.class).value(prop.getExpectedMimeType().toString());
    }
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * If the given component has {@link BIInlineBinaryData} customization,
 * reflect that to the specified property.
 */
public static void handle(XSComponent source, CPropertyInfo prop) {
    BIInlineBinaryData inline = Ring.get(BGMBuilder.class).getBindInfo(source).get(BIInlineBinaryData.class);
    if(inline!=null) {
        prop.inlineBinaryData = true;
        inline.markAsAcknowledged();
    }
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
public CPropertyInfo createElementOrReferenceProperty(
        String defaultName, boolean forConstant, XSParticle source,
        RawTypeSet types) {

    boolean generateRef;

    switch(types.canBeTypeRefs) {
    case CAN_BE_TYPEREF:
    case SHOULD_BE_TYPEREF:
        // it's up to the use
        Boolean b = generateElementProperty();
        if(b==null) // follow XJC recommendation
            generateRef = types.canBeTypeRefs== RawTypeSet.Mode.CAN_BE_TYPEREF;
        else // use the value user gave us
            generateRef = b;
        break;
    case MUST_BE_REFERENCE:
        generateRef = true;
        break;
    default:
        throw new AssertionError();
    }

    if(generateRef) {
        return createReferenceProperty(defaultName,forConstant,source,types, false, false, false, false);
    } else {
        return createElementProperty(defaultName,forConstant,source,types);
    }
}
 

import com.sun.tools.internal.xjc.model.CPropertyInfo; //导入依赖的package包/类
/**
 * Reads fields of the super class and includes them
 * to name collision tests.
 */
void readSuperClass( CClassInfo base ) {
    for( ; base!=null; base=base.getBaseClass() ) {
        for( CPropertyInfo p : base.getProperties() )
            occupiedLabels.put(p.getName(true),p);
    }
}