jeaf.Enumeration.xpt Maven / Gradle / Ivy
«EXTENSION java::Naming»
«EXTENSION java::GeneratorCommons»
«EXTENSION functions::Enumeration»
«IMPORT uml»
«IMPORT java»
«IMPORT JMM»
«DEFINE JEAFEnumTemplate FOR JEAFEnumeration»
«FILE packagePath()+"/"+name+".java" src_gen»
«getFileHeader()»
package «packageName()»;
«IF this.hasCustomImplementation»
«PROTECT CSTART "/*" CEND "*/" ID "Import:" + this.fqn()»
// TODO: Please add your custom imports here.
«ENDPROTECT»
«ENDIF»
«EXPAND functions::Javadoc::JavadocForType»
«EXPAND java::Helper::GenerateDeprecationAnnotation-»
«IF this.extensibleEnum == false || generateHeavyStyleExtensibleEnums() == false»
public enum «name» «IF this.general.isEmpty== false»implements «FOREACH this.general AS interface SEPARATOR ", "»«interface.fqn()»«ENDFOREACH»«ENDIF» {
«FOREACH this.ownedLiteral AS literal SEPARATOR ", "»
«EXPAND functions::Javadoc::JavadocForLiteral FOR literal»
«EXPAND java::Helper::GenerateDeprecationAnnotation FOR literal -»
«literal.name»«IF literal.slot.size > 0»(
«FOREACH literal.getOrderedSlots() AS slot SEPARATOR ", "»«slot.getSlotValue()»«ENDFOREACH»
)«ENDIF»
«ENDFOREACH»
«IF this.hasDynamicLiterals»
«EXPAND jeafgenerator::api::JavaEnumerationExtensionPoint::AddDynamicLiterals»
«ENDIF»
«IF extensibleEnum && this.hasUnknownLiteral() == false»
,
/**
* Literal UNKNOWN is used in case that an unknown literal of this enumeration is received e.g. via an external interface.
*/
UNKNOWN
«ENDIF»
;
«IF this.ownedAttribute.size > 0»
«IF this.extensibleEnum && this.hasUnknownLiteral() == false»
/**
* Empty constructor is required for UNKNWON literal.
*/
private «this.name»() {
«FOREACH this.ownedAttribute AS attr»
«IF attr.type.isStringType()»
«attr.name» = null;
«ELSE»«IF attr.type.isBooleanType()»
«attr.name» = false;
«ELSE»
«IF attr.type.isEnumeration()»
«attr.name» = null;
«ELSE»
«attr.name» = -1;
«ENDIF»
«ENDIF»
«ENDIF»
«ENDFOREACH»
}
«ENDIF»
/**
* Initialize object.
*/
private «this.name»(«this.ownedAttribute.asParameterDefinitionList()») {
«FOREACH this.ownedAttribute AS attr»
«attr.name» = «attr.asParameter()»;
«ENDFOREACH»
}
«EXPAND Attribute::DoPropertyDeclaration FOREACH this.ownedAttribute»
«EXPAND Attribute::Getter FOREACH this.ownedAttribute»
«ENDIF»
«IF this.hasCustomImplementation»
«PROTECT CSTART "/*" CEND "*/" ID this.fqn()»
// TODO: Please add your custom implementation here.
«ENDPROTECT»
«ENDIF»
«ELSE»
public final class «name» {
public static enum «name»Type {
«FOREACH this.ownedLiteral AS literal SEPARATOR ", "»
«EXPAND functions::Javadoc::JavadocForLiteral FOR literal»
«EXPAND java::Helper::GenerateDeprecationAnnotation FOR literal -»
«literal.name»«IF literal.slot.size > 0»(
«FOREACH literal.getOrderedSlots() AS slot SEPARATOR ", "»«IF slot.isEnumTypeSlot()»«slot.definingFeature.type.fqn()».«ENDIF»«IF slot.isStringTypeSlot()»"«ENDIF»«slot.value.first().stringValue()»«IF slot.isStringTypeSlot()»"«ENDIF»«IF slot.isFloatTypeSlot()»f«ENDIF»«ENDFOREACH»
)«ENDIF»
«ENDFOREACH»
«IF extensibleEnum && this.hasUnknownLiteral() == false»
,
/**
* Literal UNKNOWN is used in case that an unknown literal of this enumeration is received e.g. via an external interface.
*/
UNKNOWN
«ENDIF»
;
«IF this.ownedAttribute.size > 0»
/**
* Empty constructor is required for UNKNWON literal.
*/
private «this.name»Type() {
«FOREACH this.ownedAttribute AS attr»
«IF attr.type.isStringType()»
«attr.name» = null;
«ELSE»«IF attr.type.isBooleanType()»
«attr.name» = false;
«ELSE»
«IF attr.type.isEnumeration()»
«attr.name» = null;
«ELSE»
«attr.name» = -1;
«ENDIF»
«ENDIF»
«ENDIF»
«ENDFOREACH»
}
/**
* Initialize object.
*/
private «this.name»Type(«this.ownedAttribute.asParameterDefinitionList()») {
«FOREACH this.ownedAttribute AS attr»
«attr.name» = «attr.asParameter()»;
«ENDFOREACH»
}
«EXPAND Attribute::DoPropertyDeclaration FOREACH this.ownedAttribute»
«EXPAND Attribute::Getter FOREACH this.ownedAttribute»
«ENDIF»
}
«FOREACH this.ownedLiteral AS literal»
«EXPAND functions::Javadoc::JavadocForLiteral FOR literal»
«EXPAND java::Helper::GenerateDeprecationAnnotation FOR literal -»
public static final «name» «literal.name» = new «name»(«name»Type.«literal.name»);
«ENDFOREACH»
/**
* Literal of the enumeration that is represented by this instance.
*/
private «name»Type literal;
/**
* In case that the literal is unknown then also it's actual name is still available as unknownLiteralName
*/
private String unknownLiteralName;
/**
* Method returns extensible enumeration based on the passed name. If the literal name is unknown then an instance
* representing "unknown" will be returned.
*
* @param pLiteral Enumeration literal that should be used to initialize the extensible enumeration. The parameter
* must not be null.
* @return
*/
public static «name» valueOf( String pLiteralName ) {
«name» lEnum;
try {
«name»Type lEnumValue = Enum.valueOf(«name»Type.class, pLiteralName);
switch (lEnumValue) {
«FOREACH this.ownedLiteral AS literal»
case «literal.name»:
lEnum = «literal.name»;
break;
«ENDFOREACH»
default:
lEnum = new «name»(lEnumValue);
}
}
catch (IllegalArgumentException e) {
lEnum = new «name»(pLiteralName);
}
return lEnum;
}
/**
* Default constructor is only intended to be used for deserialization as many frameworks required that. For "normal" object creation available constructors {@link #«name»(«name»Type)} and {@link #«name»(String)} should be used.
*/
«name»( ) {
}
/**
* Initialize object from real enumeration literal
*
* @param pLiteral Enumeration literal that should be used to initialize the extensible enumeration. The parameter must not be null.
*/
public «name»( «name»Type pLiteral ) {
«IF isTargetRuntimeJEAF()»
com.anaptecs.jeaf.xfun.api.checks.Check.checkInvalidParameterNull(pLiteral, "pLiteral");
«ENDIF»
literal = pLiteral;
unknownLiteralName = null;
}
/**
* Initialize object using the name of the literal.
*
* @param pLiteralName Literal name that should be used to initialize the extensible enumeration. If the parameter is null or has an unknown literal name then a "unknown" version will be created.
*
* @see «name»#isUnknownLiteral()
*/
public «name»( String pLiteralName ) {
try {
literal = Enum.valueOf(«name»Type.class, pLiteralName);
unknownLiteralName = null;
}
// Literal is unknown
catch (IllegalArgumentException e) {
literal = «name»Type.UNKNOWN;
unknownLiteralName = pLiteralName;
}
}
/**
* Method returns the literal that is represented by this object.
*
* @return {@link «name»} Literal that is represented by this object. The method never returns null.
*/
public «name»Type getLiteral( ) {
return literal;
}
/**
* Method checks if the represented literal is actually unknown or not.
*
* @return boolean Method returns true if this object represents an unknown literal.
*/
public boolean isUnknownLiteral( ) {
return literal == «name»Type.UNKNOWN;
}
/**
* Method returns the actual name of the unknown literal
*
* @return {@link String} Name of the unknown literal or null in case that the literal is known.
*/
public String getUnknownLiteralName( ) {
return unknownLiteralName;
}
/**
* {@link Object#hashCode()}
*/
@Override
public int hashCode( ) {
int lHashCode;
if (unknownLiteralName != null && this.isUnknownLiteral() == true) {
lHashCode = unknownLiteralName.hashCode();
}
else {
lHashCode = literal.hashCode();
}
return lHashCode;
}
/**
* {@link Object#equals(Object)}
*/
@Override
public boolean equals( Object pObject ) {
boolean lEquals;
if (pObject != null) {
if (this == pObject) {
lEquals = true;
}
// Passed object is of same type
else if (this.getClass() == pObject.getClass()) {
«name» lEnum = («name») pObject;
// Compare if unknown literal is the same
if (this.isUnknownLiteral() && lEnum.isUnknownLiteral()) {
if (this.unknownLiteralName != null) {
lEquals = this.unknownLiteralName.equals(lEnum.unknownLiteralName);
}
else if (lEnum.unknownLiteralName == null) {
lEquals = true;
}
else {
lEquals = false;
}
}
// Compare based on literals
else {
lEquals = this.literal == lEnum.literal;
}
}
// Passed object is of different type
else {
lEquals = false;
}
}
// Passed object is null.
else {
lEquals = false;
}
return lEquals;
}
/**
* {@link Object#toString()}
*/
@Override
public String toString( ) {
String lLiteralName;
if (this.isUnknownLiteral() == false) {
lLiteralName = this.getLiteral().name();
}
// Object represents unknown literal.
else {
String lUnknownLiteralName = this.getUnknownLiteralName();
if (lUnknownLiteralName != null) {
lLiteralName = lUnknownLiteralName;
}
else {
lLiteralName = this.getLiteral().name();
}
}
return lLiteralName;
}
«ENDIF»
}
«ENDFILE»
«ENDDEFINE»
«DEFINE GenerateExtensibleEnumSerializer FOR JEAFEnumeration -»
«FILE packagePath() + "/serializers/" + name +"Serializer.java" src_gen»
«getFileHeader()»
package «this.packageName()».serializers;
«EXPAND java::Helper::GenerateDeprecationAnnotation-»
/**
* Class implements a JSON / Jackson serializer for class «name».
*/
public class «name»Serializer extends com.fasterxml.jackson.databind.JsonSerializer<«this.fqn()»> {
@Override
public void serialize( «this.fqn()» pObject, com.fasterxml.jackson.core.JsonGenerator pGenerator, com.fasterxml.jackson.databind.SerializerProvider pSerializers ) throws java.io.IOException {
// Write value directly to JSON and avoid nesting object structures. Existing toString() operation is exactly what we need.
pGenerator.writeString(pObject.toString());
}
}
«ENDFILE»
«ENDDEFINE»
«DEFINE GenerateExtensibleEnumDeserializer FOR JEAFEnumeration -»
«FILE packagePath() + "/serializers/" + name +"Deserializer.java" src_gen»
«getFileHeader()»
package «this.packageName()».serializers;
«EXPAND java::Helper::GenerateDeprecationAnnotation-»
/**
* Class implements a JSON / Jackson deserializer for class «name».
*/
public class «name»Deserializer extends com.fasterxml.jackson.databind.JsonDeserializer<«this.fqn()»> {
@Override
public «this.fqn()» deserialize( com.fasterxml.jackson.core.JsonParser pParser, com.fasterxml.jackson.databind.DeserializationContext pContext ) throws java.io.IOException {
// Parse JSON content.
com.fasterxml.jackson.databind.JsonNode lNode = pParser.getCodec().readTree(pParser);
// We expect that enumerations are always serialized as plain text which will result in a TextNode.
if (lNode instanceof com.fasterxml.jackson.databind.node.TextNode) {
«IF generateHeavyStyleExtensibleEnums()»
String lLiteralName = lNode.asText();
return «this.fqn()».valueOf(lLiteralName);
«ELSE»
«this.fqn()» lLiteral;
try {
String lLiteralName = lNode.asText();
lLiteral = «this.fqn()».valueOf(lLiteralName);
}
// Literal is unknown.
catch (IllegalArgumentException e) {
lLiteral = «this.fqn()».UNKNOWN;
}
return lLiteral;
«ENDIF»
}
// Node is not a TextNode
else {
«IF isTargetRuntimeJEAF()»
throw new com.anaptecs.jeaf.xfun.api.errorhandling.JEAFSystemException(com.anaptecs.jeaf.json.api.JSONMessages.UNEXPECTED_NODE_TYPE_FOR_DESERIALIZATION, «this.fqn()».class.getName(), lNode.toString(), lNode.getClass().getName());
«ELSE»
throw new java.io.IOException("Unable to deserialize object of type ''«this.fqn()»''. Expected text node but received other type of JSON content. Current JSON node ''" + lNode.toString() + "'' is of type ''"+ lNode.getClass().getName() + "''.");
«ENDIF»
}
}
}
«ENDFILE»
«ENDDEFINE»