com.sun.tools.xjc.model.CEnumLeafInfo 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 boolean isFieldOutlineEnumerated(Mapping context,
		FieldOutline fieldOutline) {
	final CPropertyInfo propertyInfo = fieldOutline.getPropertyInfo();

	final Collection<? extends CTypeInfo> types = context.getGetTypes()
			.process(context, propertyInfo);

	if (types.size() == 1) {

		final CTypeInfo type = types.iterator().next();

		return type instanceof CEnumLeafInfo;
	} else {
		return false;
	}
}
 

public U onElement(CElementPropertyInfo elementPropertyInfo) {
	final Collection<? extends CTypeInfo> types = context.getGetTypes()
			.process(context, elementPropertyInfo);
	if (types.size() == 1) {
		final CTypeInfo type = types.iterator().next();
		if (type instanceof CBuiltinLeafInfo) {
			return onBuiltinElement(elementPropertyInfo);
		} else if (type instanceof CEnumLeafInfo) {
			return onEnumElement(elementPropertyInfo);
		} else if (type instanceof CArrayInfo) {
			return onArrayElement(elementPropertyInfo);
		} else if (type instanceof CClass) {
			return onClassElement(elementPropertyInfo);
		} else {
			throw new UnsupportedOperationException("Unexpected type.");
		}
	} else {
		return onHeteroElement(elementPropertyInfo);
	}
}
 

public static String getEnumAnnotationDescription(CEnumLeafInfo enumLeafInfo) {
    // To get annotations in the class level javadoc, there needs to be an annotation
    // element as a child of the simpleType element , e.g.
    //<xs:simpleType name="SomeSimpleType">
    //   <xs:annotation>
    //      <xs:documentation>This annotation will be used in the class javadoc</xs:documentation>
    //   </xs:annotation>
    XSAnnotation annotation = enumLeafInfo.getSchemaComponent().getAnnotation();
    return resolveDescription(annotation);
}
 

@Override
public TypeUse getPropertyType(ProcessModel context,
		CPropertyInfo propertyInfo) {
	Collection<? extends CTypeInfo> types = context.getGetTypes().process(
			context, propertyInfo);
	return ((CEnumLeafInfo) types.iterator().next()).base;
}
 

public boolean isFieldOutlineEnumerated(Mapping context,
		FieldOutline fieldOutline) {
	final CPropertyInfo propertyInfo = fieldOutline.getPropertyInfo();

	final Collection<? extends CTypeInfo> types = context.getGetTypes()
			.process(context, propertyInfo);
	if (types.size() == 1) {

		final CTypeInfo type = types.iterator().next();

		return type instanceof CEnumLeafInfo;
	} else {
		return false;
	}
}
 

public U onValue(CValuePropertyInfo valuePropertyInfo) {
	final CNonElement type = context.getGetTypes().getTarget(context,
			valuePropertyInfo);
	if (type instanceof CBuiltinLeafInfo) {
		return onBuiltinValue(valuePropertyInfo);
	} else if (type instanceof CEnumLeafInfo) {
		return onEnumValue(valuePropertyInfo);
	} else {
		return onOtherValue(valuePropertyInfo);
	}
}
 

public U onAttribute(CAttributePropertyInfo attributePropertyInfo) {

		final CNonElement type = context.getGetTypes().getTarget(context,
				attributePropertyInfo);
		if (type instanceof CBuiltinLeafInfo) {
			return onBuiltinAttribute(attributePropertyInfo);
		} else if (type instanceof CEnumLeafInfo) {
			return onEnumAttribute(attributePropertyInfo);
		} else {
			return onOtherAttribute(attributePropertyInfo);
		}
	}
 

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"));
}
 

private void postProcessEnumLeafInfo(Model model, CEnumLeafInfo enumLeafInfo) {
	final String packagedClassName = ClassUtils.getPackagedClassName(enumLeafInfo);
	final String customizationsFileName = packagedClassName.replace(".", "/") + ".xml";
	
	final List<CPluginCustomization> customizations = readCustomizations(customizationsFileName);
	
	enumLeafInfo.getCustomizations().addAll(customizations);
	for (CEnumConstant enumConstant : enumLeafInfo.getConstants()) {
		postProcessEnumConstant(model, enumLeafInfo, enumConstant);
	}
}
 

private void postProcessModel(Model model) {
	for (final CClassInfo classInfo : model.beans().values()) {
		postProcessClassInfo(model, classInfo);
	}
	for (final CEnumLeafInfo enumLeafInfo : model.enums().values()) {
		postProcessEnumLeafInfo(model, enumLeafInfo);
	}
}
 

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

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

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

public static List<CPluginCustomization> findCustomizations(CEnumLeafInfo enumInfo, QName name) {
	final CCustomizations customizations = CustomizationUtils.getCustomizations(enumInfo);

	final List<CPluginCustomization> pluginCustomizations = new LinkedList<CPluginCustomization>();

	for (CPluginCustomization pluginCustomization : customizations) {
		if (fixNull(pluginCustomization.element.getNamespaceURI()).equals(name.getNamespaceURI())
				&& fixNull(pluginCustomization.element.getLocalName()).equals(name.getLocalPart())) {
			pluginCustomization.markAsAcknowledged();
			pluginCustomizations.add(pluginCustomization);
		}
	}

	return pluginCustomizations;
}
 

public static String getPackagedClassName(final CEnumLeafInfo enumLeafInfo) {
	
	if (enumLeafInfo.parent instanceof CClassInfo) {
		return getPackagedClassName((CClassInfo) enumLeafInfo.parent) + '$'
				+ enumLeafInfo.shortName;
	} else {
		final String r = enumLeafInfo.parent.fullName();
		if (r.length() == 0)
			return enumLeafInfo.shortName;
		else
			return r + '.' + enumLeafInfo.shortName;
	}
}
 

public static CCustomizations getCustomizations(final CEnumLeafInfo enumLeafInfo) {
	return enumLeafInfo.getCustomizations();
}
 

private void postProcessEnumConstant(Model model, CEnumLeafInfo enumLeafInfo, CEnumConstant enumConstant) {
	final String packagedClassName = ClassUtils.getPackagedClassName(enumLeafInfo);
	final String customizationsFileName = packagedClassName.replace(".", "/") + "." +enumConstant.getName() + ".xml";
	final List<CPluginCustomization> customizations = readCustomizations(customizationsFileName);
	enumConstant.getCustomizations().addAll(customizations);
}
 

public XJCCMEnumLeafInfoOrigin(CEnumLeafInfo source) {
	super(source);
}
 

@Override
protected MEnumLeafInfoOrigin createEnumLeafInfoOrigin(CEnumLeafInfo info) {
	return new XJCCMEnumLeafInfoOrigin(info);
}
 

@Override
protected String getLocalName(CEnumLeafInfo info) {
	return info.shortName;
}
 

@Override
protected MContainer getContainer(CEnumLeafInfo info) {
	final CClassInfoParent parent = info.parent;
	return parent == null ? null : getContainer(parent);
}
 

@Override
protected MPackageInfo getPackage(CEnumLeafInfo info) {
	return getPackage(info.parent);
}
 

public CMEnumOutlineGenerator(Outline outline, CEnumLeafInfo enumLeafInfo) {
	Validate.notNull(outline);
	Validate.notNull(enumLeafInfo);
	this.outline = outline;
	this.enumLeafInfo = enumLeafInfo;
}
 

public boolean isIgnored(CEnumLeafInfo enumLeafInfo);