com.sun.tools.xjc.outline.EnumOutline Java Examples

public MEnumConstantOutline generate(MEnumOutline parent,
		MModelInfo<NType, NClass> modelInfo,
		MEnumConstantInfo<NType, NClass> enumConstantInfo) {

	final CEnumLeafInfo eli = enumConstant.getEnclosingClass();

	final EnumOutline enumOutline = outline.getEnum(eli);

	for (EnumConstantOutline enumConstantOutline : enumOutline.constants) {
		if (enumConstantOutline.target == enumConstant) {
			return new CMEnumConstantOutline(parent, enumConstantInfo,
					enumConstantOutline.constRef);
		}
	}
	return null;
}
 

public MEnumOutline generate(MPackageOutline parent,
		MModelInfo<NType, NClass> modelInfo,
		MEnumLeafInfo<NType, NClass> enumLeafInfo) {
	final EnumOutline eo = outline.getEnum(this.enumLeafInfo);

	final CMEnumOutline enumOutline = new CMEnumOutline(parent.getParent(),
			parent, enumLeafInfo, eo.clazz);

	for (MEnumConstantInfo<NType, NClass> enumConstantInfo : enumLeafInfo
			.getConstants()) {

		if (enumConstantInfo.getOrigin() instanceof EnumConstantOutlineGeneratorFactory) {
			final MEnumConstantOutlineGenerator generator = ((EnumConstantOutlineGeneratorFactory) enumConstantInfo
					.getOrigin()).createGenerator(outline);
			final MEnumConstantOutline enumConstantOutline = generator
					.generate(enumOutline, modelInfo, enumConstantInfo);
			if (enumConstantOutline != null) {
				enumOutline.addEnumConstantOutline(enumConstantOutline);
			}
		}
	}
	return enumOutline;
}
 

@Override
public boolean run(Outline outline, Options options, ErrorHandler errorHandler){
	JCodeModel codeModel = outline.getCodeModel();

	Collection<? extends ClassOutline> classOutlines = outline.getClasses();
	for(ClassOutline classOutline : classOutlines){
		JDefinedClass beanClazz = classOutline.implClass;

		nullifyJavadoc(beanClazz);
	}

	Collection<? extends EnumOutline> enumOutlines = outline.getEnums();
	for(EnumOutline enumOutline : enumOutlines){
		JDefinedClass clazz = enumOutline.clazz;

		nullifyJavadoc(clazz);
	}

	return true;
}
 

public static void buildEnumModel(Outline outline, CGModel cgModel, ErrorReceiver errorReceiver) {
for (EnumOutline eo : outline.getEnums()) {
	EnumInfo enumInfo = new EnumInfo();
	enumInfo.setPackageName(eo._package()._package().name());
	enumInfo.setName(eo.clazz.name());
	if (!StringUtil.isEmpty(enumInfo.getPackageName())) {
		enumInfo.setFullName(enumInfo.getPackageName() + "." + enumInfo.getName());
	} else {
		enumInfo.setFullName(enumInfo.getName());
	}
	
	// enum constant
	for (EnumConstantOutline eco : eo.constants) {
		EnumConstantInfo enumConstant = new EnumConstantInfo();
		// name of this enum constant
		enumConstant.setName(eco.target.getName());
		// value of this enum constant
		enumConstant.setValue(eco.target.getLexicalValue());
		// java doc on this enum constant
		enumConstant.setDocComment(eco.target.javadoc);

		// add this enum constant in the enum model
		enumInfo.getEnumConstants().add(enumConstant);
	}

	// xsd annotation as doc comment
	String docComment = ModelBuilder.getDocumentation(eo.target
			.getSchemaComponent());
	enumInfo.setDocComment(docComment);

	// add this enum in the codegen model
	cgModel.getEnums().add(enumInfo);
}
  }
 

protected void processEnumOutline(EnumOutline enumOutline) {
	CEnumLeafInfo enumLeafInfo = enumOutline.target;
	JClass enumType = enumLeafInfo.base.toType(enumOutline.parent(),
			Aspect.EXPOSED).boxify();

	final JDefinedClass theClass = enumOutline.clazz;

	ClassUtils._implements(theClass, theClass.owner().ref(EnumValue.class)
			.narrow(enumType));

	final JMethod enumValue$enumValue = theClass.method(JMod.PUBLIC,
			enumType, "enumValue");
	enumValue$enumValue.annotate(Override.class);
	enumValue$enumValue.body()._return(JExpr._this().invoke("value"));
}
 

@Override
public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) {
	for (final EnumOutline enumOutline : outline.getEnums()) {
		if (!getIgnoring().isIgnored(enumOutline)) {
			processEnumOutline(enumOutline);
		}
	}
	return true;
}
 

public boolean isIgnored(EnumOutline enumOutline) {
	for (QName name : getIgnoredCustomizationElementNames()) {
		if (CustomizationUtils.containsCustomization(enumOutline, name)) {
			return true;
		}
	}
	return false;
}
 

private List<JClass> generateImplements(EnumOutline enumOutline,
		Map<String, JClass> knownClasses) {
	final JDefinedClass theClass = enumOutline.clazz;
	final List<CPluginCustomization> implementsInterfaceCustomizations = CustomizationUtils
			.findCustomizations(enumOutline,
					Customizations.IMPLEMENTS_ELEMENT_NAME);
	return generateImplements(theClass, implementsInterfaceCustomizations,
			knownClasses);
}
 

private JClass generateExtends(EnumOutline enumOutline,
		Map<String, JClass> knownClasses) {
	final JDefinedClass theClass = enumOutline.clazz;
	final CPluginCustomization extendsClassCustomization = CustomizationUtils
			.findCustomization(enumOutline,
					Customizations.EXTENDS_ELEMENT_NAME);
	return generateExtends(theClass, extendsClassCustomization,
			knownClasses);
}
 

public static CPluginCustomization findCustomization(EnumOutline classOutline, QName name) {
	final CCustomizations customizations = CustomizationUtils.getCustomizations(classOutline);
	final CPluginCustomization customization = customizations.find(name.getNamespaceURI(), name.getLocalPart());
	if (customization != null) {
		customization.markAsAcknowledged();
	}
	return customization;
}
 

public static boolean containsCustomization(EnumOutline enumOutline, QName name) {
	final CPluginCustomization customization = findCustomization(enumOutline, name);
	if (customization != null) {
		customization.markAsAcknowledged();
	}
	return customization != null;
}
 

public static CCustomizations getCustomizations(EnumOutline enumOutline) {
	return getCustomizations(enumOutline.target);
}
 

public static List<CPluginCustomization> findCustomizations(EnumOutline enumOutline, QName name) {
	return findCustomizations(enumOutline.target, name);
}
 

EnumOutline getEnumOutline(final JType typeSpec) {
	return this.enums.get(typeSpec.fullName());
}
 

public EpisodeBuilder addEnum(final EnumOutline enumOutline) {
	this.outlines.add(new OutlineAdaptor(enumOutline.target.getSchemaComponent(), OutlineAdaptor.OutlineType.ENUM, enumOutline.clazz));
	return this;
}
 

@Override
public boolean run(Outline outline, Options options, ErrorHandler errorHandler){
	JCodeModel codeModel = outline.getCodeModel();

	Collection<? extends ClassOutline> classOutlines = outline.getClasses();
	for(ClassOutline classOutline : classOutlines){
		JDefinedClass beanClazz = classOutline.implClass;

		CPluginCustomization classCustomization = CustomizationUtils.findCustomization(classOutline, AnnotatePlugin.ANNOTATE_CLASS_QNAME);
		if(classCustomization != null){
			annotate(codeModel, beanClazz, classCustomization);
		}

		Map<String, JFieldVar> fieldVars = beanClazz.fields();

		FieldOutline[] fieldOutlines = classOutline.getDeclaredFields();
		for(FieldOutline fieldOutline : fieldOutlines){
			CPropertyInfo propertyInfo = fieldOutline.getPropertyInfo();

			List<CPluginCustomization> propertyCustomizations = CustomizationUtils.findPropertyCustomizationsInProperty(propertyInfo, AnnotatePlugin.ANNOTATE_PROPERTY_QNAME);
			for(CPluginCustomization propertyCustomization : propertyCustomizations){
				JFieldVar fieldVar = fieldVars.get(propertyInfo.getName(false));

				annotate(codeModel, fieldVar, propertyCustomization);
			}
		}
	}

	Collection<? extends EnumOutline> enumOutlines = outline.getEnums();
	for(EnumOutline enumOutline : enumOutlines){
		JDefinedClass clazz = enumOutline.clazz;

		CPluginCustomization enumCustomization = CustomizationUtils.findCustomization(enumOutline, AnnotatePlugin.ANNOTATE_ENUM_QNAME);
		if(enumCustomization != null){
			annotate(codeModel, clazz, enumCustomization);
		}

		List<EnumConstantOutline> enumConstantOutlines = enumOutline.constants;
		for(EnumConstantOutline enumConstantOutline : enumConstantOutlines){
			CCustomizations enumConstantCustomizations = enumConstantOutline.target.getCustomizations();

			for(CPluginCustomization enumConstantCustomization : enumConstantCustomizations){
				Element element = enumConstantCustomization.element;

				if((AnnotatePlugin.ANNOTATE_ENUM_CONSTANT_QNAME.getNamespaceURI()).equals(element.getNamespaceURI()) && (AnnotatePlugin.ANNOTATE_ENUM_CONSTANT_QNAME.getLocalPart()).equals(element.getLocalName())){
					annotate(codeModel, enumConstantOutline.constRef, enumConstantCustomization);

					enumConstantCustomization.markAsAcknowledged();
				}
			}
		}
	}

	return true;
}
 

private void processEnumOutline(EnumOutline enumOutline,
		Map<String, JClass> knownClasses) {

	generateExtends(enumOutline, knownClasses);
	generateImplements(enumOutline, knownClasses);

}
 

public boolean isIgnored(EnumOutline enumOutline);