From 134080d42fee4192038bfaeb3353316d48cce21c Mon Sep 17 00:00:00 2001 From: Csaba Tenkes Date: Mon, 28 Jan 2019 18:42:13 +0100 Subject: [PATCH 1/6] Add files via upload My extentions for jaxb basics (plugins): * No unnecessary block in methods like toString(), equals(), hashCode(), append(), copyTo() * No unnecessary declaraction line and assignment lines for a given varaible in method like above * @Override everywhere where necessary --- CopyablePlugin.java | 343 ++++++++++++++++++++++++++++++++++++++ MergeablePlugin.java | 325 ++++++++++++++++++++++++++++++++++++ SimpleEqualsPlugin.java | 148 ++++++++++++++++ SimpleHashCodePlugin.java | 131 +++++++++++++++ ToStringPlugin.java | 234 ++++++++++++++++++++++++++ 5 files changed, 1181 insertions(+) create mode 100644 CopyablePlugin.java create mode 100644 MergeablePlugin.java create mode 100644 SimpleEqualsPlugin.java create mode 100644 SimpleHashCodePlugin.java create mode 100644 ToStringPlugin.java diff --git a/CopyablePlugin.java b/CopyablePlugin.java new file mode 100644 index 00000000..3064f453 --- /dev/null +++ b/CopyablePlugin.java @@ -0,0 +1,343 @@ +package org.jvnet.jaxb2_commons.plugin.copyable; + +import java.util.Arrays; +import java.util.Collection; + +import javax.xml.namespace.QName; + +import org.jvnet.jaxb2_commons.lang.CopyStrategy2; +import org.jvnet.jaxb2_commons.lang.CopyTo2; +import org.jvnet.jaxb2_commons.lang.JAXBCopyStrategy; +import org.jvnet.jaxb2_commons.locator.ObjectLocator; +import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; +import org.jvnet.jaxb2_commons.plugin.AbstractParameterizablePlugin; +import org.jvnet.jaxb2_commons.plugin.Customizations; +import org.jvnet.jaxb2_commons.plugin.CustomizedIgnoring; +import org.jvnet.jaxb2_commons.plugin.Ignoring; +import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; +import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; +import org.jvnet.jaxb2_commons.util.ClassUtils; +import org.jvnet.jaxb2_commons.util.FieldAccessorFactory; +import org.jvnet.jaxb2_commons.util.PropertyFieldAccessorFactory; +import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; +import org.xml.sax.ErrorHandler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JClass; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JConditional; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JOp; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; +import com.sun.tools.xjc.Options; +import com.sun.tools.xjc.outline.ClassOutline; +import com.sun.tools.xjc.outline.FieldOutline; +import com.sun.tools.xjc.outline.Outline; + +public class CopyablePlugin extends AbstractParameterizablePlugin { + + @Override + public String getOptionName() { + return "Xcopyable"; + } + + @Override + public String getUsage() { + return "TBD"; + } + + private FieldAccessorFactory fieldAccessorFactory = PropertyFieldAccessorFactory.INSTANCE; + + public FieldAccessorFactory getFieldAccessorFactory() { + return fieldAccessorFactory; + } + + public void setFieldAccessorFactory( + FieldAccessorFactory fieldAccessorFactory) { + this.fieldAccessorFactory = fieldAccessorFactory; + } + + private String copyStrategyClass = JAXBCopyStrategy.class.getName(); + + public void setCopyStrategyClass(final String copyStrategy) { + this.copyStrategyClass = copyStrategy; + } + + public String getCopyStrategyClass() { + return copyStrategyClass; + } + + public JExpression createCopyStrategy(JCodeModel codeModel) { + return StrategyClassUtils.createStrategyInstanceExpression(codeModel, + CopyStrategy2.class, getCopyStrategyClass()); + } + + private Ignoring ignoring = new CustomizedIgnoring( + org.jvnet.jaxb2_commons.plugin.copyable.Customizations.IGNORED_ELEMENT_NAME, + Customizations.IGNORED_ELEMENT_NAME, + Customizations.GENERATED_ELEMENT_NAME); + + public Ignoring getIgnoring() { + return ignoring; + } + + public void setIgnoring(Ignoring ignoring) { + this.ignoring = ignoring; + } + + @Override + public Collection getCustomizationElementNames() { + return Arrays + .asList(org.jvnet.jaxb2_commons.plugin.copyable.Customizations.IGNORED_ELEMENT_NAME, + Customizations.IGNORED_ELEMENT_NAME, + Customizations.GENERATED_ELEMENT_NAME); + } + + @Override + public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) { + for (final ClassOutline classOutline : outline.getClasses()) + if (!getIgnoring().isIgnored(classOutline)) { + + processClassOutline(classOutline); + } + return true; + } + + protected void processClassOutline(ClassOutline classOutline) { + final JDefinedClass theClass = classOutline.implClass; + + ClassUtils._implements(theClass, theClass.owner().ref(Cloneable.class)); + @SuppressWarnings("unused") + final JMethod object$clone = generateObject$clone(classOutline, + theClass); + ClassUtils._implements(theClass, theClass.owner().ref(CopyTo2.class)); + + @SuppressWarnings("unused") + final JMethod copyTo$copyTo = generateCopyTo$copyTo(classOutline, + theClass); + @SuppressWarnings("unused") + final JMethod copyTo$copyTo1 = generateCopyTo$copyTo1(classOutline, + theClass); + // @SuppressWarnings("unused") + // final JMethod copyable$copyTo = generateCopyable$CopyTo(classOutline, + // theClass); + // @SuppressWarnings("unused") + // final JMethod copyable$copyTo1 = + // generateCopyable$CopyTo1(classOutline, + // theClass); + + // @SuppressWarnings("unused") + // final JMethod copyFrom$copyFrom = generateCopyFrom$CopyFrom( + // classOutline, theClass); + // @SuppressWarnings("unused") + // final JMethod copyable$copyFrom = generateCopyable$CopyFrom( + // classOutline, theClass); + if (!classOutline.target.isAbstract()) { + @SuppressWarnings("unused") + final JMethod createCopy = generateCopyTo$createNewInstance( + classOutline, theClass); + + } + } + + protected JMethod generateCopyTo$createNewInstance( + final ClassOutline classOutline, final JDefinedClass theClass) { + + final JMethod existingMethod = theClass.getMethod("createNewInstance", + new JType[0]); + if (existingMethod == null) { + + final JMethod newMethod = theClass.method(JMod.PUBLIC, theClass + .owner().ref(Object.class), "createNewInstance"); + newMethod.annotate(Override.class); // DEMATIC + final JBlock body = newMethod.body(); + body._return(JExpr._new(theClass)); + return newMethod; + } else { + return existingMethod; + } + } + + protected JMethod generateObject$clone(final ClassOutline classOutline, + final JDefinedClass theClass) { + final JMethod clone = theClass.method(JMod.PUBLIC, theClass.owner() + .ref(Object.class), "clone"); + clone.annotate(Override.class); // DEMATIC + final JBlock body = clone.body(); + body._return(JExpr.invoke("copyTo").arg( + JExpr.invoke("createNewInstance"))); + return clone; + } + + protected JMethod generateCopyTo$copyTo(final ClassOutline classOutline, + final JDefinedClass theClass) { + + final JCodeModel codeModel = theClass.owner(); + final JMethod copyTo$copyTo = theClass.method(JMod.PUBLIC, + codeModel.ref(Object.class), "copyTo"); + copyTo$copyTo.annotate(Override.class); // DEMATIC + final JVar target = copyTo$copyTo.param(Object.class, "target"); + + final JBlock body = copyTo$copyTo.body(); + final JVar copyStrategy = body.decl(JMod.FINAL, + codeModel.ref(CopyStrategy2.class), "strategy2", + createCopyStrategy(codeModel)); + + body._return(JExpr.invoke("copyTo").arg(JExpr._null()).arg(target) + .arg(copyStrategy)); + + return copyTo$copyTo; + } + + protected JMethod generateCopyTo$copyTo1(ClassOutline classOutline, + final JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + ClassUtils._implements(theClass, codeModel.ref(CopyTo2.class)); + + final JMethod copyTo = theClass.method(JMod.PUBLIC, + codeModel.ref(Object.class), "copyTo"); + copyTo.annotate(Override.class); // DEMATIC + final JVar locator = copyTo.param(ObjectLocator.class, "locator"); + final JVar target = copyTo.param(Object.class, "target"); + final JVar copyStrategy = copyTo.param(CopyStrategy2.class, + "strategy2"); + + final JBlock body = copyTo.body(); + + final JVar draftCopy; + if (!classOutline.target.isAbstract()) { + draftCopy = body.decl( + JMod.FINAL, + codeModel.ref(Object.class), + "draftCopy", + + JOp.cond(JOp.eq(target, JExpr._null()), + JExpr.invoke("createNewInstance"), target)); + } else { + body._if(JExpr._null().eq(target)) + ._then() + ._throw(JExpr + ._new(codeModel + .ref(IllegalArgumentException.class)) + .arg("Target argument must not be null for abstract copyable classes.")); + draftCopy = target; + } + + Boolean superClassImplementsCopyTo = StrategyClassUtils + .superClassImplements(classOutline, getIgnoring(), + CopyTo2.class); + + if (superClassImplementsCopyTo == null) { + + } else if (superClassImplementsCopyTo.booleanValue()) { + body.invoke(JExpr._super(), "copyTo").arg(locator) + .arg(draftCopy).arg(copyStrategy); + + } else { + + } + + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (declaredFields.length > 0) { + + final JBlock bl = body._if(draftCopy._instanceof(theClass)) + ._then(); + + final JVar copy = bl.decl(JMod.FINAL, theClass, "copy", + JExpr.cast(theClass, draftCopy)); + + for (final FieldOutline fieldOutline : declaredFields) { + + final FieldAccessorEx sourceFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, JExpr._this()); + final FieldAccessorEx copyFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, copy); + + if (sourceFieldAccessor.isConstant()) { + continue; + } + + final JBlock block = bl; // DEMATIC + + final JExpression valueIsSet = (sourceFieldAccessor + .isAlwaysSet() || sourceFieldAccessor.hasSetValue() == null) ? JExpr.TRUE + : sourceFieldAccessor.hasSetValue(); + + final JVar shouldBeCopied = block.decl(codeModel + .ref(Boolean.class), fieldOutline.getPropertyInfo() + .getName(false) + "ShouldBeCopiedAndSet", + copyStrategy.invoke("shouldBeCopiedAndSet").arg(locator) + .arg(valueIsSet)); + + final JConditional ifShouldBeSetConditional = block._if(JOp + .eq(shouldBeCopied, codeModel.ref(Boolean.class) + .staticRef("TRUE"))); + + final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional + ._then(); + final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional + ._elseif(JOp.eq( + shouldBeCopied, + codeModel.ref(Boolean.class).staticRef( + "FALSE"))); + final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional + ._then(); + + final JType copyFieldType = sourceFieldAccessor.getType(); + + //final JVar sourceField = ifShouldBeSetBlock.decl( copyFieldType, "source" + fieldOutline.getPropertyInfo().getName(true)); + //sourceFieldAccessor.toRawValue(ifShouldBeSetBlock, sourceField); + + String propertyName = fieldOutline.getPropertyInfo().getName(true);// DEMATIC + final JVar sourceField = ifShouldBeSetBlock.decl(copyFieldType, "source" + propertyName, JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + + final JExpression builtCopy = JExpr + .invoke(copyStrategy, "copy") + .arg(codeModel + .ref(LocatorUtils.class) + .staticInvoke("property") + .arg(locator) + .arg(fieldOutline.getPropertyInfo() + .getName(false)).arg(sourceField)) + .arg(sourceField).arg(valueIsSet); + final JVar copyField = ifShouldBeSetBlock.decl( + copyFieldType, + "copy" + + fieldOutline.getPropertyInfo().getName( + true), + copyFieldType.isPrimitive() ? builtCopy : + + JExpr.cast(copyFieldType, builtCopy)); + if (copyFieldType instanceof JClass + && ((JClass) copyFieldType).isParameterized()) { + copyField.annotate(SuppressWarnings.class).param( + "value", "unchecked"); + } + copyFieldAccessor.fromRawValue(ifShouldBeSetBlock, "unique" + + fieldOutline.getPropertyInfo().getName(true), + copyField); + + copyFieldAccessor.unsetValues(ifShouldBeUnsetBlock); + } + } + + body._return(draftCopy); + return copyTo; + } + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } +} \ No newline at end of file diff --git a/MergeablePlugin.java b/MergeablePlugin.java new file mode 100644 index 00000000..c822d8d1 --- /dev/null +++ b/MergeablePlugin.java @@ -0,0 +1,325 @@ +package org.jvnet.jaxb2_commons.plugin.mergeable; + +import java.util.Arrays; +import java.util.Collection; + +import javax.xml.namespace.QName; + +import org.jvnet.jaxb2_commons.lang.JAXBMergeStrategy; +import org.jvnet.jaxb2_commons.lang.MergeFrom2; +import org.jvnet.jaxb2_commons.lang.MergeStrategy2; +import org.jvnet.jaxb2_commons.locator.ObjectLocator; +import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; +import org.jvnet.jaxb2_commons.plugin.AbstractParameterizablePlugin; +import org.jvnet.jaxb2_commons.plugin.Customizations; +import org.jvnet.jaxb2_commons.plugin.CustomizedIgnoring; +import org.jvnet.jaxb2_commons.plugin.Ignoring; +import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; +import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; +import org.jvnet.jaxb2_commons.util.ClassUtils; +import org.jvnet.jaxb2_commons.util.FieldAccessorFactory; +import org.jvnet.jaxb2_commons.util.PropertyFieldAccessorFactory; +import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; +import org.xml.sax.ErrorHandler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JConditional; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JOp; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; +import com.sun.tools.xjc.Options; +import com.sun.tools.xjc.outline.ClassOutline; +import com.sun.tools.xjc.outline.FieldOutline; +import com.sun.tools.xjc.outline.Outline; + +public class MergeablePlugin extends AbstractParameterizablePlugin { + + @Override + public String getOptionName() { + return "Xmergeable"; + } + + @Override + public String getUsage() { + return "TBD"; + } + + private FieldAccessorFactory fieldAccessorFactory = PropertyFieldAccessorFactory.INSTANCE; + + public FieldAccessorFactory getFieldAccessorFactory() { + return fieldAccessorFactory; + } + + public void setFieldAccessorFactory( + FieldAccessorFactory fieldAccessorFactory) { + this.fieldAccessorFactory = fieldAccessorFactory; + } + + private String mergeStrategyClass = JAXBMergeStrategy.class.getName(); + + public void setMergeStrategyClass(final String mergeStrategyClass) { + this.mergeStrategyClass = mergeStrategyClass; + } + + public String getMergeStrategyClass() { + return mergeStrategyClass; + } + + public JExpression createMergeStrategy(JCodeModel codeModel) { + return StrategyClassUtils.createStrategyInstanceExpression(codeModel, + MergeStrategy2.class, getMergeStrategyClass()); + } + + private Ignoring ignoring = new CustomizedIgnoring( + org.jvnet.jaxb2_commons.plugin.mergeable.Customizations.IGNORED_ELEMENT_NAME, + Customizations.IGNORED_ELEMENT_NAME, + Customizations.GENERATED_ELEMENT_NAME); + + public Ignoring getIgnoring() { + return ignoring; + } + + public void setIgnoring(Ignoring ignoring) { + this.ignoring = ignoring; + } + + @Override + public Collection getCustomizationElementNames() { + return Arrays + .asList(org.jvnet.jaxb2_commons.plugin.mergeable.Customizations.IGNORED_ELEMENT_NAME, + Customizations.IGNORED_ELEMENT_NAME, + Customizations.GENERATED_ELEMENT_NAME); + } + + @Override + public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) { + for (final ClassOutline classOutline : outline.getClasses()) + if (!getIgnoring().isIgnored(classOutline)) { + processClassOutline(classOutline); + } + return true; + } + + protected void processClassOutline(ClassOutline classOutline) { + final JDefinedClass theClass = classOutline.implClass; + ClassUtils + ._implements(theClass, theClass.owner().ref(MergeFrom2.class)); + + @SuppressWarnings("unused") + final JMethod mergeFrom$mergeFrom0 = generateMergeFrom$mergeFrom0( + classOutline, theClass); + @SuppressWarnings("unused") + final JMethod mergeFrom$mergeFrom = generateMergeFrom$mergeFrom( + classOutline, theClass); + + if (!classOutline.target.isAbstract()) { + @SuppressWarnings("unused") + final JMethod createCopy = generateMergeFrom$createNewInstance( + classOutline, theClass); + + } + } + + protected JMethod generateMergeFrom$mergeFrom0( + final ClassOutline classOutline, final JDefinedClass theClass) { + + JCodeModel codeModel = theClass.owner(); + final JMethod mergeFrom$mergeFrom = theClass.method(JMod.PUBLIC, + codeModel.VOID, "mergeFrom"); + mergeFrom$mergeFrom.annotate(Override.class); // DEMATIC + final JVar left = mergeFrom$mergeFrom.param(Object.class, "left"); + final JVar right = mergeFrom$mergeFrom.param(Object.class, "right"); + final JBlock body = mergeFrom$mergeFrom.body(); + + final JVar mergeStrategy = body.decl(JMod.FINAL, + codeModel.ref(MergeStrategy2.class), "strategy2", + createMergeStrategy(codeModel)); + + body.invoke("mergeFrom").arg(JExpr._null()).arg(JExpr._null()) + .arg(left).arg(right).arg(mergeStrategy); + return mergeFrom$mergeFrom; + } + + protected JMethod generateMergeFrom$mergeFrom(ClassOutline classOutline, + final JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + + final JMethod mergeFrom = theClass.method(JMod.PUBLIC, codeModel.VOID, + "mergeFrom"); + mergeFrom.annotate(Override.class); // DEMATIC + final JVar leftLocator = mergeFrom.param(ObjectLocator.class, + "leftLocator"); + final JVar rightLocator = mergeFrom.param(ObjectLocator.class, + "rightLocator"); + final JVar left = mergeFrom.param(Object.class, "left"); + final JVar right = mergeFrom.param(Object.class, "right"); + + final JVar mergeStrategy = mergeFrom.param(MergeStrategy2.class, + "strategy2"); + + final JBlock methodBody = mergeFrom.body(); + + Boolean superClassImplementsMergeFrom = StrategyClassUtils + .superClassImplements(classOutline, getIgnoring(), + MergeFrom2.class); + + if (superClassImplementsMergeFrom == null) { + + } else if (superClassImplementsMergeFrom.booleanValue()) { + methodBody.invoke(JExpr._super(), "mergeFrom").arg(leftLocator) + .arg(rightLocator).arg(left).arg(right) + .arg(mergeStrategy); + } else { + + } + + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (declaredFields.length > 0) { + + final JBlock body = methodBody._if(right._instanceof(theClass)) + ._then(); + + JVar target = body.decl(JMod.FINAL, theClass, "target", + JExpr._this()); + JVar leftObject = body.decl(JMod.FINAL, theClass, "leftObject", + JExpr.cast(theClass, left)); + JVar rightObject = body.decl(JMod.FINAL, theClass, + "rightObject", JExpr.cast(theClass, right)); + for (final FieldOutline fieldOutline : declaredFields) { + final FieldAccessorEx leftFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, leftObject); + final FieldAccessorEx rightFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, rightObject); + if (leftFieldAccessor.isConstant() + || rightFieldAccessor.isConstant()) { + continue; + } + + final JBlock block = body; // DEMATIC + + final JExpression leftFieldHasSetValue = (leftFieldAccessor + .isAlwaysSet() || leftFieldAccessor.hasSetValue() == null) ? JExpr.TRUE + : leftFieldAccessor.hasSetValue(); + + final JExpression rightFieldHasSetValue = (rightFieldAccessor + .isAlwaysSet() || rightFieldAccessor.hasSetValue() == null) ? JExpr.TRUE + : rightFieldAccessor.hasSetValue(); + + final JVar shouldBeSet = block.decl( + codeModel.ref(Boolean.class), + fieldOutline.getPropertyInfo().getName(false) + + "ShouldBeMergedAndSet", + mergeStrategy.invoke("shouldBeMergedAndSet") + .arg(leftLocator).arg(rightLocator) + .arg(leftFieldHasSetValue) + .arg(rightFieldHasSetValue)); + + final JConditional ifShouldBeSetConditional = block._if(JOp + .eq(shouldBeSet, codeModel.ref(Boolean.class) + .staticRef("TRUE"))); + + final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional + ._then(); + final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional + ._elseif(JOp.eq( + shouldBeSet, + codeModel.ref(Boolean.class).staticRef( + "FALSE"))); + final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional + ._then(); + // final JBlock ifShouldBeIgnoredBlock = + // ifShouldNotBeSetConditional + // ._else(); + + String propertyName = fieldOutline.getPropertyInfo().getName(true); + + //final JVar leftField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(),"lhs" + fieldOutline.getPropertyInfo().getName(true)); + //leftFieldAccessor.toRawValue(ifShouldBeSetBlock, leftField); + final JVar leftField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(), "lhs" + propertyName, leftObject.invoke(createMethodName(fieldOutline))); // DEMATIC + + //final JVar rightField = ifShouldBeSetBlock.decl(rightFieldAccessor.getType(),"rhs" + fieldOutline.getPropertyInfo().getName(true)); + //rightFieldAccessor.toRawValue(ifShouldBeSetBlock, rightField); + final JVar rightField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(), "rhs" + propertyName, rightObject.invoke(createMethodName(fieldOutline))); // DEMATIC + + final JExpression leftFieldLocator = codeModel + .ref(LocatorUtils.class).staticInvoke("property") + .arg(leftLocator) + .arg(fieldOutline.getPropertyInfo().getName(false)) + .arg(leftField); + final JExpression rightFieldLocator = codeModel + .ref(LocatorUtils.class).staticInvoke("property") + .arg(rightLocator) + .arg(fieldOutline.getPropertyInfo().getName(false)) + .arg(rightField); + + final FieldAccessorEx targetFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, target); + final JExpression mergedValue; + if (targetFieldAccessor.getType().name().equals("byte")|| + targetFieldAccessor.getType().name().equals("int")|| + targetFieldAccessor.getType().name().equals("float")|| + targetFieldAccessor.getType().name().equals("long")|| + targetFieldAccessor.getType().name().equals("short")|| + targetFieldAccessor.getType().name().equals("Object") + ) { + mergedValue = mergeStrategy.invoke("merge").arg(leftFieldLocator) + .arg(rightFieldLocator).arg(leftField) + .arg(rightField).arg(leftFieldHasSetValue) + .arg(rightFieldHasSetValue); + + } else { + mergedValue = JExpr.cast( + targetFieldAccessor.getType(), + mergeStrategy.invoke("merge").arg(leftFieldLocator) + .arg(rightFieldLocator).arg(leftField) + .arg(rightField).arg(leftFieldHasSetValue) + .arg(rightFieldHasSetValue)); + } + + final JVar merged = ifShouldBeSetBlock.decl( rightFieldAccessor.getType(), "merged" + fieldOutline.getPropertyInfo().getName(true), mergedValue); + + targetFieldAccessor.fromRawValue( ifShouldBeSetBlock, "unique" + fieldOutline.getPropertyInfo().getName(true), merged); + + targetFieldAccessor.unsetValues(ifShouldBeUnsetBlock); + } + } + return mergeFrom; + } + + protected JMethod generateMergeFrom$createNewInstance( + final ClassOutline classOutline, final JDefinedClass theClass) { + + final JMethod existingMethod = theClass.getMethod("createNewInstance", + new JType[0]); + if (existingMethod == null) { + + final JMethod newMethod = theClass.method(JMod.PUBLIC, theClass + .owner().ref(Object.class), "createNewInstance"); + newMethod.annotate(Override.class); // DEMATIC + final JBlock body = newMethod.body(); + body._return(JExpr._new(theClass)); + + return newMethod; + } else { + return existingMethod; + } + } + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + +} \ No newline at end of file diff --git a/SimpleEqualsPlugin.java b/SimpleEqualsPlugin.java new file mode 100644 index 00000000..be203a73 --- /dev/null +++ b/SimpleEqualsPlugin.java @@ -0,0 +1,148 @@ +package org.jvnet.jaxb2_commons.plugin.simpleequals; + +import java.util.Collection; + +import javax.xml.namespace.QName; + +import org.jvnet.jaxb2_commons.plugin.codegenerator.AbstractCodeGeneratorPlugin; +import org.jvnet.jaxb2_commons.plugin.codegenerator.CodeGenerator; +import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; +import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; +import org.jvnet.jaxb2_commons.util.FieldUtils; +import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JOp; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; +import com.sun.tools.xjc.outline.Aspect; +import com.sun.tools.xjc.outline.ClassOutline; +import com.sun.tools.xjc.outline.FieldOutline; + +public class SimpleEqualsPlugin extends + AbstractCodeGeneratorPlugin { + + @Override + public String getOptionName() { + return "XsimpleEquals"; + } + + @Override + public String getUsage() { + return " -XsimpleEquals : Generate reflection-free runtime-free equals(Object that) methods.\n" + + " See https://github.com/highsource/jaxb2-basics/wiki/JAXB2-SimpleEquals-Plugin"; + } + + @Override + protected QName getSpecialIgnoredElementName() { + return org.jvnet.jaxb2_commons.plugin.equals.Customizations.IGNORED_ELEMENT_NAME; + } + + @Override + protected CodeGenerator createCodeGenerator( + JCodeModel codeModel) { + return new EqualsCodeGenerator(codeModel); + } + + @Override + protected void generate(ClassOutline classOutline, JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + final JMethod objectEquals = theClass.method(JMod.PUBLIC, + codeModel.BOOLEAN, "equals"); + objectEquals.annotate(Override.class); // DEMATIC + + final JVar object = objectEquals.param(Object.class, "object"); + + final JBlock body = objectEquals.body(); + + JExpression objectIsNull = object.eq(JExpr._null()); + JExpression notTheSameType = JExpr._this().invoke("getClass").ne(object.invoke("getClass")); + body._if(JOp.cor(objectIsNull, notTheSameType)) + ._then()._return(JExpr.FALSE); + + body._if(JExpr._this().eq(object))._then()._return(JExpr.TRUE); + final Boolean superClassNotIgnored = StrategyClassUtils + .superClassNotIgnored(classOutline, getIgnoring()); + + if (superClassNotIgnored != null) { + body._if(JOp.not(JExpr._super().invoke("equals").arg(object))) + ._then()._return(JExpr.FALSE); + } + final JExpression _this = JExpr._this(); + + final FieldOutline[] fields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (fields.length > 0) { + + final JVar _that = body.decl(JMod.FINAL, theClass, "that", + JExpr.cast(theClass, object)); + + for (final FieldOutline fieldOutline : fields) { + + final FieldAccessorEx leftFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, _this); + final FieldAccessorEx rightFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, _that); + + if (leftFieldAccessor.isConstant() + || rightFieldAccessor.isConstant()) { + continue; + } + + final JBlock block = body; // DEMATIC + + final String name = fieldOutline.getPropertyInfo().getName(true); + final JType type = leftFieldAccessor.getType(); + + final JVar leftValue = block.decl(type, "left" + name, JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + final JVar rightValue = block.decl( rightFieldAccessor.getType(), "right" + name,_that.invoke(createMethodName(fieldOutline))); // DEMATIC + + final JType exposedType = leftFieldAccessor.getType(); + + final Collection possibleTypes = FieldUtils + .getPossibleTypes(fieldOutline, Aspect.EXPOSED); + final boolean isAlwaysSet = leftFieldAccessor.isAlwaysSet(); +// final JExpression leftHasSetValue = exposedType.isPrimitive() ? JExpr.TRUE +// : leftValue.ne(JExpr._null()); + final JExpression leftHasSetValue = (leftFieldAccessor.isAlwaysSet() || leftFieldAccessor + .hasSetValue() == null) ? JExpr.TRUE + : leftFieldAccessor.hasSetValue(); + +// final JExpression rightHasSetValue = exposedType.isPrimitive() ? JExpr.TRUE +// : rightValue.ne(JExpr._null()); + + final JExpression rightHasSetValue = (rightFieldAccessor.isAlwaysSet() || rightFieldAccessor + .hasSetValue() == null) ? JExpr.TRUE + : rightFieldAccessor.hasSetValue(); + + getCodeGenerator().generate( + block, + exposedType, + possibleTypes, + isAlwaysSet, + new EqualsArguments(codeModel, leftValue, + leftHasSetValue, rightValue, rightHasSetValue)); + } + } + body._return(JExpr.TRUE); + + } + + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + +} diff --git a/SimpleHashCodePlugin.java b/SimpleHashCodePlugin.java new file mode 100644 index 00000000..bb101d1d --- /dev/null +++ b/SimpleHashCodePlugin.java @@ -0,0 +1,131 @@ +package org.jvnet.jaxb2_commons.plugin.simplehashcode; + +import java.util.Collection; + +import javax.xml.namespace.QName; + +import org.jvnet.jaxb2_commons.plugin.codegenerator.AbstractCodeGeneratorPlugin; +import org.jvnet.jaxb2_commons.plugin.codegenerator.CodeGenerator; +import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; +import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; +import org.jvnet.jaxb2_commons.util.FieldUtils; +import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JType; +import com.sun.codemodel.JVar; +import com.sun.tools.xjc.outline.Aspect; +import com.sun.tools.xjc.outline.ClassOutline; +import com.sun.tools.xjc.outline.FieldOutline; + +public class SimpleHashCodePlugin extends + AbstractCodeGeneratorPlugin { + + @Override + public String getOptionName() { + return "XsimpleHashCode"; + } + + @Override + public String getUsage() { + return " -XsimpleEquals : Generate reflection-free runtime-free hashCode() methods.\n" + + " See https://github.com/highsource/jaxb2-basics/wiki/JAXB2-SimpleHashCode-Plugin"; + } + + @Override + protected QName getSpecialIgnoredElementName() { + return org.jvnet.jaxb2_commons.plugin.hashcode.Customizations.IGNORED_ELEMENT_NAME; + } + + private int multiplier = 31; + + private int getMultiplier() { + return multiplier; + } + + @Override + protected CodeGenerator createCodeGenerator( + JCodeModel codeModel) { + return new HashCodeCodeGenerator(codeModel); + } + + @Override + protected void generate(ClassOutline classOutline, JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + final JMethod object$hashCode = theClass.method(JMod.PUBLIC, codeModel.INT, "hashCode"); + object$hashCode.annotate(Override.class); // DEMATIC + + final JBlock body = object$hashCode.body(); + + final JExpression currentHashCodeExpression = JExpr.lit(1); + + final JVar currentHashCode = body.decl(codeModel.INT, + "currentHashCode", currentHashCodeExpression); + + final Boolean superClassImplementsHashCode = StrategyClassUtils + .superClassNotIgnored(classOutline, getIgnoring()); + + if (superClassImplementsHashCode != null) { + body.assign( + currentHashCode, + currentHashCode.mul(JExpr.lit(getMultiplier())).plus( + JExpr._super().invoke("hashCode"))); + } + + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (declaredFields.length > 0) { + + for (final FieldOutline fieldOutline : declaredFields) { + final FieldAccessorEx fieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, JExpr._this()); + if (fieldAccessor.isConstant()) { + continue; + } + final JBlock block = body; // DEMATIC + block.assign(currentHashCode, + currentHashCode.mul(JExpr.lit(getMultiplier()))); + + String propertyName = fieldOutline.getPropertyInfo().getName(true);// DEMATIC + final JVar value = block.decl(fieldAccessor.getType(), "the" + propertyName,JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + + final JType exposedType = fieldAccessor.getType(); + + final Collection possibleTypes = FieldUtils + .getPossibleTypes(fieldOutline, Aspect.EXPOSED); + final boolean isAlwaysSet = fieldAccessor.isAlwaysSet(); +// final JExpression hasSetValue = exposedType.isPrimitive() ? JExpr.TRUE +// : value.ne(JExpr._null()); + + final JExpression hasSetValue = (fieldAccessor.isAlwaysSet() || fieldAccessor + .hasSetValue() == null) ? JExpr.TRUE + : fieldAccessor.hasSetValue(); + getCodeGenerator().generate( + block, + exposedType, + possibleTypes, + isAlwaysSet, + new HashCodeArguments(codeModel, currentHashCode, + getMultiplier(), value, hasSetValue)); + } + } + body._return(currentHashCode); + } + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + +} diff --git a/ToStringPlugin.java b/ToStringPlugin.java new file mode 100644 index 00000000..333f9a58 --- /dev/null +++ b/ToStringPlugin.java @@ -0,0 +1,234 @@ +package org.jvnet.jaxb2_commons.plugin.tostring; + +import java.util.Arrays; +import java.util.Collection; + +import javax.xml.namespace.QName; + +import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; +import org.jvnet.jaxb2_commons.lang.ToString2; +import org.jvnet.jaxb2_commons.lang.ToStringStrategy2; +import org.jvnet.jaxb2_commons.locator.ObjectLocator; +import org.jvnet.jaxb2_commons.plugin.AbstractParameterizablePlugin; +import org.jvnet.jaxb2_commons.plugin.Customizations; +import org.jvnet.jaxb2_commons.plugin.CustomizedIgnoring; +import org.jvnet.jaxb2_commons.plugin.Ignoring; +import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; +import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; +import org.jvnet.jaxb2_commons.util.ClassUtils; +import org.jvnet.jaxb2_commons.util.FieldAccessorFactory; +import org.jvnet.jaxb2_commons.util.PropertyFieldAccessorFactory; +import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; +import org.xml.sax.ErrorHandler; + +import com.sun.codemodel.JBlock; +import com.sun.codemodel.JCodeModel; +import com.sun.codemodel.JDefinedClass; +import com.sun.codemodel.JExpr; +import com.sun.codemodel.JExpression; +import com.sun.codemodel.JMethod; +import com.sun.codemodel.JMod; +import com.sun.codemodel.JVar; +import com.sun.tools.xjc.Options; +import com.sun.tools.xjc.outline.ClassOutline; +import com.sun.tools.xjc.outline.FieldOutline; +import com.sun.tools.xjc.outline.Outline; + +public class ToStringPlugin extends AbstractParameterizablePlugin { + + @Override + public String getOptionName() { + return "XtoString"; + } + + @Override + public String getUsage() { + return "TBD"; + } + + private FieldAccessorFactory fieldAccessorFactory = PropertyFieldAccessorFactory.INSTANCE; + + public FieldAccessorFactory getFieldAccessorFactory() { + return fieldAccessorFactory; + } + + public void setFieldAccessorFactory( + FieldAccessorFactory fieldAccessorFactory) { + this.fieldAccessorFactory = fieldAccessorFactory; + } + + private String toStringStrategyClass = JAXBToStringStrategy.class.getName(); + + public void setToStringStrategyClass(String toStringStrategy) { + this.toStringStrategyClass = toStringStrategy; + } + + public String getToStringStrategyClass() { + return toStringStrategyClass; + } + + public JExpression createToStringStrategy(JCodeModel codeModel) { + return StrategyClassUtils.createStrategyInstanceExpression(codeModel, + ToStringStrategy2.class, getToStringStrategyClass()); + } + + private Ignoring ignoring = new CustomizedIgnoring( + org.jvnet.jaxb2_commons.plugin.tostring.Customizations.IGNORED_ELEMENT_NAME, + Customizations.IGNORED_ELEMENT_NAME, + Customizations.GENERATED_ELEMENT_NAME); + + public Ignoring getIgnoring() { + return ignoring; + } + + public void setIgnoring(Ignoring ignoring) { + this.ignoring = ignoring; + } + + @Override + public Collection getCustomizationElementNames() { + return Arrays + .asList(org.jvnet.jaxb2_commons.plugin.tostring.Customizations.IGNORED_ELEMENT_NAME, + Customizations.IGNORED_ELEMENT_NAME, + Customizations.GENERATED_ELEMENT_NAME); + } + + @Override + public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) { + for (final ClassOutline classOutline : outline.getClasses()) + if (!getIgnoring().isIgnored(classOutline)) { + processClassOutline(classOutline); + } + return true; + } + + protected void processClassOutline(ClassOutline classOutline) { + final JDefinedClass theClass = classOutline.implClass; + ClassUtils._implements(theClass, theClass.owner().ref(ToString2.class)); + + @SuppressWarnings("unused") + final JMethod object$toString = generateObject$toString(classOutline, + theClass); + @SuppressWarnings("unused") + final JMethod toString$append = generateToString$append(classOutline, + theClass); + @SuppressWarnings("unused") + final JMethod toString$appendFields = generateToString$appendFields( + classOutline, theClass); + } + + protected JMethod generateObject$toString(final ClassOutline classOutline, + final JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + final JMethod object$toString = theClass.method(JMod.PUBLIC, + codeModel.ref(String.class), "toString"); + object$toString.annotate(Override.class); // DEMATIC + + final JBlock body = object$toString.body(); + + final JVar toStringStrategy = body.decl(JMod.FINAL, codeModel.ref(ToStringStrategy2.class), + "strategy2", createToStringStrategy(codeModel)); + + final JVar buffer = body.decl(JMod.FINAL, + codeModel.ref(StringBuilder.class), "buffer", + JExpr._new(codeModel.ref(StringBuilder.class))); + body.invoke("append").arg(JExpr._null()).arg(buffer).arg(toStringStrategy); + body._return(buffer.invoke("toString")); + + return object$toString; + } + + protected JMethod generateToString$append(final ClassOutline classOutline, + final JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + final JMethod toString$append = theClass.method(JMod.PUBLIC, + codeModel.ref(StringBuilder.class), "append"); + toString$append.annotate(Override.class); // DEMATIC + + final JVar locator = toString$append.param(ObjectLocator.class, "locator"); + final JVar buffer = toString$append.param(StringBuilder.class, "buffer"); + final JVar toStringStrategy = toString$append.param( + ToStringStrategy2.class, "strategy2"); + + final JBlock body = toString$append.body(); + + body.invoke(toStringStrategy, "appendStart").arg(locator) + .arg(JExpr._this()).arg(buffer); + body.invoke("appendFields").arg(locator).arg(buffer) + .arg(toStringStrategy); + body.invoke(toStringStrategy, "appendEnd").arg(locator) + .arg(JExpr._this()).arg(buffer); + body._return(buffer); + + return toString$append; + } + + protected JMethod generateToString$appendFields(ClassOutline classOutline, final JDefinedClass theClass) { + final JCodeModel codeModel = theClass.owner(); + + final JMethod toString$appendFields = theClass.method(JMod.PUBLIC, + codeModel.ref(StringBuilder.class), "appendFields"); + toString$appendFields.annotate(Override.class); // DEMATIC + + final JVar locator = toString$appendFields.param( + ObjectLocator.class, "locator"); + final JVar buffer = toString$appendFields.param( + StringBuilder.class, "buffer"); + final JVar toStringStrategy = toString$appendFields.param( + ToStringStrategy2.class, "strategy2"); + final JBlock body = toString$appendFields.body(); + + final Boolean superClassImplementsToString = StrategyClassUtils + .superClassImplements(classOutline, ignoring, + ToString2.class); + + if (superClassImplementsToString == null) { + // No superclass + } else if (superClassImplementsToString.booleanValue()) { + body.invoke(JExpr._super(), "appendFields").arg(locator) + .arg(buffer).arg(toStringStrategy); + } else { + // Superclass does not implement ToString + } + + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (declaredFields.length > 0) { + + for (final FieldOutline fieldOutline : declaredFields) { + final JBlock block = body; //DEMATIC + final FieldAccessorEx fieldAccessor = getFieldAccessorFactory().createFieldAccessor(fieldOutline, JExpr._this()); + + //final JVar theValue = block.decl(fieldAccessor.getType(),"the"+ fieldOutline.getPropertyInfo().getName(true)); + //fieldAccessor.toRawValue(block, theValue); + + String propertyName = fieldOutline.getPropertyInfo().getName(true); + final JVar theValue = block.decl(fieldAccessor.getType(), "the" + propertyName,JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + + final JExpression valueIsSet = (fieldAccessor.isAlwaysSet() || fieldAccessor + .hasSetValue() == null) ? JExpr.TRUE + : fieldAccessor.hasSetValue(); + + block.invoke(toStringStrategy, "appendField") + .arg(locator) + .arg(JExpr._this()) + .arg(JExpr.lit(fieldOutline.getPropertyInfo() + .getName(false))).arg(buffer).arg(theValue) + .arg(valueIsSet); + } + } + body._return(buffer); + return toString$appendFields; + } + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + +} \ No newline at end of file From fe9893597fa080badfac01443fe4cc5418ea6934 Mon Sep 17 00:00:00 2001 From: Csaba Tenkes Date: Fri, 1 Feb 2019 12:33:56 +0100 Subject: [PATCH 2/6] Less SuppressWarnings are used Less SuppressWarnings are used when this is not necessary (at Eclipse,Java 8 default compiler options) --- CopyablePlugin.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/CopyablePlugin.java b/CopyablePlugin.java index 3064f453..3def0345 100644 --- a/CopyablePlugin.java +++ b/CopyablePlugin.java @@ -23,7 +23,7 @@ import org.xml.sax.ErrorHandler; import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; +//import com.sun.codemodel.JClass; import com.sun.codemodel.JCodeModel; import com.sun.codemodel.JConditional; import com.sun.codemodel.JDefinedClass; @@ -315,11 +315,11 @@ protected void processClassOutline(ClassOutline classOutline) { copyFieldType.isPrimitive() ? builtCopy : JExpr.cast(copyFieldType, builtCopy)); - if (copyFieldType instanceof JClass - && ((JClass) copyFieldType).isParameterized()) { - copyField.annotate(SuppressWarnings.class).param( - "value", "unchecked"); - } +// if (copyFieldType instanceof JClass +// && ((JClass) copyFieldType).isParameterized()) { +// copyField.annotate(SuppressWarnings.class).param( +// "value", "unchecked"); +// } copyFieldAccessor.fromRawValue(ifShouldBeSetBlock, "unique" + fieldOutline.getPropertyInfo().getName(true), copyField); From a9c7a318dd5af08a89c6351c32092750e89afca1 Mon Sep 17 00:00:00 2001 From: cstenkes Date: Fri, 1 Feb 2019 23:25:46 +0100 Subject: [PATCH 3/6] Revert "Less SuppressWarnings are used " This reverts commit fe9893597fa080badfac01443fe4cc5418ea6934. --- CopyablePlugin.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/CopyablePlugin.java b/CopyablePlugin.java index 3def0345..3064f453 100644 --- a/CopyablePlugin.java +++ b/CopyablePlugin.java @@ -23,7 +23,7 @@ import org.xml.sax.ErrorHandler; import com.sun.codemodel.JBlock; -//import com.sun.codemodel.JClass; +import com.sun.codemodel.JClass; import com.sun.codemodel.JCodeModel; import com.sun.codemodel.JConditional; import com.sun.codemodel.JDefinedClass; @@ -315,11 +315,11 @@ protected void processClassOutline(ClassOutline classOutline) { copyFieldType.isPrimitive() ? builtCopy : JExpr.cast(copyFieldType, builtCopy)); -// if (copyFieldType instanceof JClass -// && ((JClass) copyFieldType).isParameterized()) { -// copyField.annotate(SuppressWarnings.class).param( -// "value", "unchecked"); -// } + if (copyFieldType instanceof JClass + && ((JClass) copyFieldType).isParameterized()) { + copyField.annotate(SuppressWarnings.class).param( + "value", "unchecked"); + } copyFieldAccessor.fromRawValue(ifShouldBeSetBlock, "unique" + fieldOutline.getPropertyInfo().getName(true), copyField); From 314e1fe367f236df601d3e3d5582a40b49c862c3 Mon Sep 17 00:00:00 2001 From: cstenkes Date: Fri, 1 Feb 2019 23:25:58 +0100 Subject: [PATCH 4/6] Revert "Add files via upload" This reverts commit 134080d42fee4192038bfaeb3353316d48cce21c. --- CopyablePlugin.java | 343 -------------------------------------- MergeablePlugin.java | 325 ------------------------------------ SimpleEqualsPlugin.java | 148 ---------------- SimpleHashCodePlugin.java | 131 --------------- ToStringPlugin.java | 234 -------------------------- 5 files changed, 1181 deletions(-) delete mode 100644 CopyablePlugin.java delete mode 100644 MergeablePlugin.java delete mode 100644 SimpleEqualsPlugin.java delete mode 100644 SimpleHashCodePlugin.java delete mode 100644 ToStringPlugin.java diff --git a/CopyablePlugin.java b/CopyablePlugin.java deleted file mode 100644 index 3064f453..00000000 --- a/CopyablePlugin.java +++ /dev/null @@ -1,343 +0,0 @@ -package org.jvnet.jaxb2_commons.plugin.copyable; - -import java.util.Arrays; -import java.util.Collection; - -import javax.xml.namespace.QName; - -import org.jvnet.jaxb2_commons.lang.CopyStrategy2; -import org.jvnet.jaxb2_commons.lang.CopyTo2; -import org.jvnet.jaxb2_commons.lang.JAXBCopyStrategy; -import org.jvnet.jaxb2_commons.locator.ObjectLocator; -import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; -import org.jvnet.jaxb2_commons.plugin.AbstractParameterizablePlugin; -import org.jvnet.jaxb2_commons.plugin.Customizations; -import org.jvnet.jaxb2_commons.plugin.CustomizedIgnoring; -import org.jvnet.jaxb2_commons.plugin.Ignoring; -import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; -import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; -import org.jvnet.jaxb2_commons.util.ClassUtils; -import org.jvnet.jaxb2_commons.util.FieldAccessorFactory; -import org.jvnet.jaxb2_commons.util.PropertyFieldAccessorFactory; -import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; -import org.xml.sax.ErrorHandler; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JConditional; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JOp; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; -import com.sun.tools.xjc.Options; -import com.sun.tools.xjc.outline.ClassOutline; -import com.sun.tools.xjc.outline.FieldOutline; -import com.sun.tools.xjc.outline.Outline; - -public class CopyablePlugin extends AbstractParameterizablePlugin { - - @Override - public String getOptionName() { - return "Xcopyable"; - } - - @Override - public String getUsage() { - return "TBD"; - } - - private FieldAccessorFactory fieldAccessorFactory = PropertyFieldAccessorFactory.INSTANCE; - - public FieldAccessorFactory getFieldAccessorFactory() { - return fieldAccessorFactory; - } - - public void setFieldAccessorFactory( - FieldAccessorFactory fieldAccessorFactory) { - this.fieldAccessorFactory = fieldAccessorFactory; - } - - private String copyStrategyClass = JAXBCopyStrategy.class.getName(); - - public void setCopyStrategyClass(final String copyStrategy) { - this.copyStrategyClass = copyStrategy; - } - - public String getCopyStrategyClass() { - return copyStrategyClass; - } - - public JExpression createCopyStrategy(JCodeModel codeModel) { - return StrategyClassUtils.createStrategyInstanceExpression(codeModel, - CopyStrategy2.class, getCopyStrategyClass()); - } - - private Ignoring ignoring = new CustomizedIgnoring( - org.jvnet.jaxb2_commons.plugin.copyable.Customizations.IGNORED_ELEMENT_NAME, - Customizations.IGNORED_ELEMENT_NAME, - Customizations.GENERATED_ELEMENT_NAME); - - public Ignoring getIgnoring() { - return ignoring; - } - - public void setIgnoring(Ignoring ignoring) { - this.ignoring = ignoring; - } - - @Override - public Collection getCustomizationElementNames() { - return Arrays - .asList(org.jvnet.jaxb2_commons.plugin.copyable.Customizations.IGNORED_ELEMENT_NAME, - Customizations.IGNORED_ELEMENT_NAME, - Customizations.GENERATED_ELEMENT_NAME); - } - - @Override - public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) { - for (final ClassOutline classOutline : outline.getClasses()) - if (!getIgnoring().isIgnored(classOutline)) { - - processClassOutline(classOutline); - } - return true; - } - - protected void processClassOutline(ClassOutline classOutline) { - final JDefinedClass theClass = classOutline.implClass; - - ClassUtils._implements(theClass, theClass.owner().ref(Cloneable.class)); - @SuppressWarnings("unused") - final JMethod object$clone = generateObject$clone(classOutline, - theClass); - ClassUtils._implements(theClass, theClass.owner().ref(CopyTo2.class)); - - @SuppressWarnings("unused") - final JMethod copyTo$copyTo = generateCopyTo$copyTo(classOutline, - theClass); - @SuppressWarnings("unused") - final JMethod copyTo$copyTo1 = generateCopyTo$copyTo1(classOutline, - theClass); - // @SuppressWarnings("unused") - // final JMethod copyable$copyTo = generateCopyable$CopyTo(classOutline, - // theClass); - // @SuppressWarnings("unused") - // final JMethod copyable$copyTo1 = - // generateCopyable$CopyTo1(classOutline, - // theClass); - - // @SuppressWarnings("unused") - // final JMethod copyFrom$copyFrom = generateCopyFrom$CopyFrom( - // classOutline, theClass); - // @SuppressWarnings("unused") - // final JMethod copyable$copyFrom = generateCopyable$CopyFrom( - // classOutline, theClass); - if (!classOutline.target.isAbstract()) { - @SuppressWarnings("unused") - final JMethod createCopy = generateCopyTo$createNewInstance( - classOutline, theClass); - - } - } - - protected JMethod generateCopyTo$createNewInstance( - final ClassOutline classOutline, final JDefinedClass theClass) { - - final JMethod existingMethod = theClass.getMethod("createNewInstance", - new JType[0]); - if (existingMethod == null) { - - final JMethod newMethod = theClass.method(JMod.PUBLIC, theClass - .owner().ref(Object.class), "createNewInstance"); - newMethod.annotate(Override.class); // DEMATIC - final JBlock body = newMethod.body(); - body._return(JExpr._new(theClass)); - return newMethod; - } else { - return existingMethod; - } - } - - protected JMethod generateObject$clone(final ClassOutline classOutline, - final JDefinedClass theClass) { - final JMethod clone = theClass.method(JMod.PUBLIC, theClass.owner() - .ref(Object.class), "clone"); - clone.annotate(Override.class); // DEMATIC - final JBlock body = clone.body(); - body._return(JExpr.invoke("copyTo").arg( - JExpr.invoke("createNewInstance"))); - return clone; - } - - protected JMethod generateCopyTo$copyTo(final ClassOutline classOutline, - final JDefinedClass theClass) { - - final JCodeModel codeModel = theClass.owner(); - final JMethod copyTo$copyTo = theClass.method(JMod.PUBLIC, - codeModel.ref(Object.class), "copyTo"); - copyTo$copyTo.annotate(Override.class); // DEMATIC - final JVar target = copyTo$copyTo.param(Object.class, "target"); - - final JBlock body = copyTo$copyTo.body(); - final JVar copyStrategy = body.decl(JMod.FINAL, - codeModel.ref(CopyStrategy2.class), "strategy2", - createCopyStrategy(codeModel)); - - body._return(JExpr.invoke("copyTo").arg(JExpr._null()).arg(target) - .arg(copyStrategy)); - - return copyTo$copyTo; - } - - protected JMethod generateCopyTo$copyTo1(ClassOutline classOutline, - final JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - ClassUtils._implements(theClass, codeModel.ref(CopyTo2.class)); - - final JMethod copyTo = theClass.method(JMod.PUBLIC, - codeModel.ref(Object.class), "copyTo"); - copyTo.annotate(Override.class); // DEMATIC - final JVar locator = copyTo.param(ObjectLocator.class, "locator"); - final JVar target = copyTo.param(Object.class, "target"); - final JVar copyStrategy = copyTo.param(CopyStrategy2.class, - "strategy2"); - - final JBlock body = copyTo.body(); - - final JVar draftCopy; - if (!classOutline.target.isAbstract()) { - draftCopy = body.decl( - JMod.FINAL, - codeModel.ref(Object.class), - "draftCopy", - - JOp.cond(JOp.eq(target, JExpr._null()), - JExpr.invoke("createNewInstance"), target)); - } else { - body._if(JExpr._null().eq(target)) - ._then() - ._throw(JExpr - ._new(codeModel - .ref(IllegalArgumentException.class)) - .arg("Target argument must not be null for abstract copyable classes.")); - draftCopy = target; - } - - Boolean superClassImplementsCopyTo = StrategyClassUtils - .superClassImplements(classOutline, getIgnoring(), - CopyTo2.class); - - if (superClassImplementsCopyTo == null) { - - } else if (superClassImplementsCopyTo.booleanValue()) { - body.invoke(JExpr._super(), "copyTo").arg(locator) - .arg(draftCopy).arg(copyStrategy); - - } else { - - } - - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); - - if (declaredFields.length > 0) { - - final JBlock bl = body._if(draftCopy._instanceof(theClass)) - ._then(); - - final JVar copy = bl.decl(JMod.FINAL, theClass, "copy", - JExpr.cast(theClass, draftCopy)); - - for (final FieldOutline fieldOutline : declaredFields) { - - final FieldAccessorEx sourceFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, JExpr._this()); - final FieldAccessorEx copyFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, copy); - - if (sourceFieldAccessor.isConstant()) { - continue; - } - - final JBlock block = bl; // DEMATIC - - final JExpression valueIsSet = (sourceFieldAccessor - .isAlwaysSet() || sourceFieldAccessor.hasSetValue() == null) ? JExpr.TRUE - : sourceFieldAccessor.hasSetValue(); - - final JVar shouldBeCopied = block.decl(codeModel - .ref(Boolean.class), fieldOutline.getPropertyInfo() - .getName(false) + "ShouldBeCopiedAndSet", - copyStrategy.invoke("shouldBeCopiedAndSet").arg(locator) - .arg(valueIsSet)); - - final JConditional ifShouldBeSetConditional = block._if(JOp - .eq(shouldBeCopied, codeModel.ref(Boolean.class) - .staticRef("TRUE"))); - - final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional - ._then(); - final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional - ._elseif(JOp.eq( - shouldBeCopied, - codeModel.ref(Boolean.class).staticRef( - "FALSE"))); - final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional - ._then(); - - final JType copyFieldType = sourceFieldAccessor.getType(); - - //final JVar sourceField = ifShouldBeSetBlock.decl( copyFieldType, "source" + fieldOutline.getPropertyInfo().getName(true)); - //sourceFieldAccessor.toRawValue(ifShouldBeSetBlock, sourceField); - - String propertyName = fieldOutline.getPropertyInfo().getName(true);// DEMATIC - final JVar sourceField = ifShouldBeSetBlock.decl(copyFieldType, "source" + propertyName, JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC - - final JExpression builtCopy = JExpr - .invoke(copyStrategy, "copy") - .arg(codeModel - .ref(LocatorUtils.class) - .staticInvoke("property") - .arg(locator) - .arg(fieldOutline.getPropertyInfo() - .getName(false)).arg(sourceField)) - .arg(sourceField).arg(valueIsSet); - final JVar copyField = ifShouldBeSetBlock.decl( - copyFieldType, - "copy" - + fieldOutline.getPropertyInfo().getName( - true), - copyFieldType.isPrimitive() ? builtCopy : - - JExpr.cast(copyFieldType, builtCopy)); - if (copyFieldType instanceof JClass - && ((JClass) copyFieldType).isParameterized()) { - copyField.annotate(SuppressWarnings.class).param( - "value", "unchecked"); - } - copyFieldAccessor.fromRawValue(ifShouldBeSetBlock, "unique" - + fieldOutline.getPropertyInfo().getName(true), - copyField); - - copyFieldAccessor.unsetValues(ifShouldBeUnsetBlock); - } - } - - body._return(draftCopy); - return copyTo; - } - - private String createMethodName(FieldOutline fieldOutline) { - String name = fieldOutline.getPropertyInfo().getName(true); - String type = fieldOutline.getRawType().name(); - if (type.toLowerCase().equals("boolean")) { - return "is" + name; - } - return "get" + name; - } -} \ No newline at end of file diff --git a/MergeablePlugin.java b/MergeablePlugin.java deleted file mode 100644 index c822d8d1..00000000 --- a/MergeablePlugin.java +++ /dev/null @@ -1,325 +0,0 @@ -package org.jvnet.jaxb2_commons.plugin.mergeable; - -import java.util.Arrays; -import java.util.Collection; - -import javax.xml.namespace.QName; - -import org.jvnet.jaxb2_commons.lang.JAXBMergeStrategy; -import org.jvnet.jaxb2_commons.lang.MergeFrom2; -import org.jvnet.jaxb2_commons.lang.MergeStrategy2; -import org.jvnet.jaxb2_commons.locator.ObjectLocator; -import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; -import org.jvnet.jaxb2_commons.plugin.AbstractParameterizablePlugin; -import org.jvnet.jaxb2_commons.plugin.Customizations; -import org.jvnet.jaxb2_commons.plugin.CustomizedIgnoring; -import org.jvnet.jaxb2_commons.plugin.Ignoring; -import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; -import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; -import org.jvnet.jaxb2_commons.util.ClassUtils; -import org.jvnet.jaxb2_commons.util.FieldAccessorFactory; -import org.jvnet.jaxb2_commons.util.PropertyFieldAccessorFactory; -import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; -import org.xml.sax.ErrorHandler; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JConditional; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JOp; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; -import com.sun.tools.xjc.Options; -import com.sun.tools.xjc.outline.ClassOutline; -import com.sun.tools.xjc.outline.FieldOutline; -import com.sun.tools.xjc.outline.Outline; - -public class MergeablePlugin extends AbstractParameterizablePlugin { - - @Override - public String getOptionName() { - return "Xmergeable"; - } - - @Override - public String getUsage() { - return "TBD"; - } - - private FieldAccessorFactory fieldAccessorFactory = PropertyFieldAccessorFactory.INSTANCE; - - public FieldAccessorFactory getFieldAccessorFactory() { - return fieldAccessorFactory; - } - - public void setFieldAccessorFactory( - FieldAccessorFactory fieldAccessorFactory) { - this.fieldAccessorFactory = fieldAccessorFactory; - } - - private String mergeStrategyClass = JAXBMergeStrategy.class.getName(); - - public void setMergeStrategyClass(final String mergeStrategyClass) { - this.mergeStrategyClass = mergeStrategyClass; - } - - public String getMergeStrategyClass() { - return mergeStrategyClass; - } - - public JExpression createMergeStrategy(JCodeModel codeModel) { - return StrategyClassUtils.createStrategyInstanceExpression(codeModel, - MergeStrategy2.class, getMergeStrategyClass()); - } - - private Ignoring ignoring = new CustomizedIgnoring( - org.jvnet.jaxb2_commons.plugin.mergeable.Customizations.IGNORED_ELEMENT_NAME, - Customizations.IGNORED_ELEMENT_NAME, - Customizations.GENERATED_ELEMENT_NAME); - - public Ignoring getIgnoring() { - return ignoring; - } - - public void setIgnoring(Ignoring ignoring) { - this.ignoring = ignoring; - } - - @Override - public Collection getCustomizationElementNames() { - return Arrays - .asList(org.jvnet.jaxb2_commons.plugin.mergeable.Customizations.IGNORED_ELEMENT_NAME, - Customizations.IGNORED_ELEMENT_NAME, - Customizations.GENERATED_ELEMENT_NAME); - } - - @Override - public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) { - for (final ClassOutline classOutline : outline.getClasses()) - if (!getIgnoring().isIgnored(classOutline)) { - processClassOutline(classOutline); - } - return true; - } - - protected void processClassOutline(ClassOutline classOutline) { - final JDefinedClass theClass = classOutline.implClass; - ClassUtils - ._implements(theClass, theClass.owner().ref(MergeFrom2.class)); - - @SuppressWarnings("unused") - final JMethod mergeFrom$mergeFrom0 = generateMergeFrom$mergeFrom0( - classOutline, theClass); - @SuppressWarnings("unused") - final JMethod mergeFrom$mergeFrom = generateMergeFrom$mergeFrom( - classOutline, theClass); - - if (!classOutline.target.isAbstract()) { - @SuppressWarnings("unused") - final JMethod createCopy = generateMergeFrom$createNewInstance( - classOutline, theClass); - - } - } - - protected JMethod generateMergeFrom$mergeFrom0( - final ClassOutline classOutline, final JDefinedClass theClass) { - - JCodeModel codeModel = theClass.owner(); - final JMethod mergeFrom$mergeFrom = theClass.method(JMod.PUBLIC, - codeModel.VOID, "mergeFrom"); - mergeFrom$mergeFrom.annotate(Override.class); // DEMATIC - final JVar left = mergeFrom$mergeFrom.param(Object.class, "left"); - final JVar right = mergeFrom$mergeFrom.param(Object.class, "right"); - final JBlock body = mergeFrom$mergeFrom.body(); - - final JVar mergeStrategy = body.decl(JMod.FINAL, - codeModel.ref(MergeStrategy2.class), "strategy2", - createMergeStrategy(codeModel)); - - body.invoke("mergeFrom").arg(JExpr._null()).arg(JExpr._null()) - .arg(left).arg(right).arg(mergeStrategy); - return mergeFrom$mergeFrom; - } - - protected JMethod generateMergeFrom$mergeFrom(ClassOutline classOutline, - final JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - - final JMethod mergeFrom = theClass.method(JMod.PUBLIC, codeModel.VOID, - "mergeFrom"); - mergeFrom.annotate(Override.class); // DEMATIC - final JVar leftLocator = mergeFrom.param(ObjectLocator.class, - "leftLocator"); - final JVar rightLocator = mergeFrom.param(ObjectLocator.class, - "rightLocator"); - final JVar left = mergeFrom.param(Object.class, "left"); - final JVar right = mergeFrom.param(Object.class, "right"); - - final JVar mergeStrategy = mergeFrom.param(MergeStrategy2.class, - "strategy2"); - - final JBlock methodBody = mergeFrom.body(); - - Boolean superClassImplementsMergeFrom = StrategyClassUtils - .superClassImplements(classOutline, getIgnoring(), - MergeFrom2.class); - - if (superClassImplementsMergeFrom == null) { - - } else if (superClassImplementsMergeFrom.booleanValue()) { - methodBody.invoke(JExpr._super(), "mergeFrom").arg(leftLocator) - .arg(rightLocator).arg(left).arg(right) - .arg(mergeStrategy); - } else { - - } - - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); - - if (declaredFields.length > 0) { - - final JBlock body = methodBody._if(right._instanceof(theClass)) - ._then(); - - JVar target = body.decl(JMod.FINAL, theClass, "target", - JExpr._this()); - JVar leftObject = body.decl(JMod.FINAL, theClass, "leftObject", - JExpr.cast(theClass, left)); - JVar rightObject = body.decl(JMod.FINAL, theClass, - "rightObject", JExpr.cast(theClass, right)); - for (final FieldOutline fieldOutline : declaredFields) { - final FieldAccessorEx leftFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, leftObject); - final FieldAccessorEx rightFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, rightObject); - if (leftFieldAccessor.isConstant() - || rightFieldAccessor.isConstant()) { - continue; - } - - final JBlock block = body; // DEMATIC - - final JExpression leftFieldHasSetValue = (leftFieldAccessor - .isAlwaysSet() || leftFieldAccessor.hasSetValue() == null) ? JExpr.TRUE - : leftFieldAccessor.hasSetValue(); - - final JExpression rightFieldHasSetValue = (rightFieldAccessor - .isAlwaysSet() || rightFieldAccessor.hasSetValue() == null) ? JExpr.TRUE - : rightFieldAccessor.hasSetValue(); - - final JVar shouldBeSet = block.decl( - codeModel.ref(Boolean.class), - fieldOutline.getPropertyInfo().getName(false) - + "ShouldBeMergedAndSet", - mergeStrategy.invoke("shouldBeMergedAndSet") - .arg(leftLocator).arg(rightLocator) - .arg(leftFieldHasSetValue) - .arg(rightFieldHasSetValue)); - - final JConditional ifShouldBeSetConditional = block._if(JOp - .eq(shouldBeSet, codeModel.ref(Boolean.class) - .staticRef("TRUE"))); - - final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional - ._then(); - final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional - ._elseif(JOp.eq( - shouldBeSet, - codeModel.ref(Boolean.class).staticRef( - "FALSE"))); - final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional - ._then(); - // final JBlock ifShouldBeIgnoredBlock = - // ifShouldNotBeSetConditional - // ._else(); - - String propertyName = fieldOutline.getPropertyInfo().getName(true); - - //final JVar leftField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(),"lhs" + fieldOutline.getPropertyInfo().getName(true)); - //leftFieldAccessor.toRawValue(ifShouldBeSetBlock, leftField); - final JVar leftField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(), "lhs" + propertyName, leftObject.invoke(createMethodName(fieldOutline))); // DEMATIC - - //final JVar rightField = ifShouldBeSetBlock.decl(rightFieldAccessor.getType(),"rhs" + fieldOutline.getPropertyInfo().getName(true)); - //rightFieldAccessor.toRawValue(ifShouldBeSetBlock, rightField); - final JVar rightField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(), "rhs" + propertyName, rightObject.invoke(createMethodName(fieldOutline))); // DEMATIC - - final JExpression leftFieldLocator = codeModel - .ref(LocatorUtils.class).staticInvoke("property") - .arg(leftLocator) - .arg(fieldOutline.getPropertyInfo().getName(false)) - .arg(leftField); - final JExpression rightFieldLocator = codeModel - .ref(LocatorUtils.class).staticInvoke("property") - .arg(rightLocator) - .arg(fieldOutline.getPropertyInfo().getName(false)) - .arg(rightField); - - final FieldAccessorEx targetFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, target); - final JExpression mergedValue; - if (targetFieldAccessor.getType().name().equals("byte")|| - targetFieldAccessor.getType().name().equals("int")|| - targetFieldAccessor.getType().name().equals("float")|| - targetFieldAccessor.getType().name().equals("long")|| - targetFieldAccessor.getType().name().equals("short")|| - targetFieldAccessor.getType().name().equals("Object") - ) { - mergedValue = mergeStrategy.invoke("merge").arg(leftFieldLocator) - .arg(rightFieldLocator).arg(leftField) - .arg(rightField).arg(leftFieldHasSetValue) - .arg(rightFieldHasSetValue); - - } else { - mergedValue = JExpr.cast( - targetFieldAccessor.getType(), - mergeStrategy.invoke("merge").arg(leftFieldLocator) - .arg(rightFieldLocator).arg(leftField) - .arg(rightField).arg(leftFieldHasSetValue) - .arg(rightFieldHasSetValue)); - } - - final JVar merged = ifShouldBeSetBlock.decl( rightFieldAccessor.getType(), "merged" + fieldOutline.getPropertyInfo().getName(true), mergedValue); - - targetFieldAccessor.fromRawValue( ifShouldBeSetBlock, "unique" + fieldOutline.getPropertyInfo().getName(true), merged); - - targetFieldAccessor.unsetValues(ifShouldBeUnsetBlock); - } - } - return mergeFrom; - } - - protected JMethod generateMergeFrom$createNewInstance( - final ClassOutline classOutline, final JDefinedClass theClass) { - - final JMethod existingMethod = theClass.getMethod("createNewInstance", - new JType[0]); - if (existingMethod == null) { - - final JMethod newMethod = theClass.method(JMod.PUBLIC, theClass - .owner().ref(Object.class), "createNewInstance"); - newMethod.annotate(Override.class); // DEMATIC - final JBlock body = newMethod.body(); - body._return(JExpr._new(theClass)); - - return newMethod; - } else { - return existingMethod; - } - } - - private String createMethodName(FieldOutline fieldOutline) { - String name = fieldOutline.getPropertyInfo().getName(true); - String type = fieldOutline.getRawType().name(); - if (type.toLowerCase().equals("boolean")) { - return "is" + name; - } - return "get" + name; - } - -} \ No newline at end of file diff --git a/SimpleEqualsPlugin.java b/SimpleEqualsPlugin.java deleted file mode 100644 index be203a73..00000000 --- a/SimpleEqualsPlugin.java +++ /dev/null @@ -1,148 +0,0 @@ -package org.jvnet.jaxb2_commons.plugin.simpleequals; - -import java.util.Collection; - -import javax.xml.namespace.QName; - -import org.jvnet.jaxb2_commons.plugin.codegenerator.AbstractCodeGeneratorPlugin; -import org.jvnet.jaxb2_commons.plugin.codegenerator.CodeGenerator; -import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; -import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; -import org.jvnet.jaxb2_commons.util.FieldUtils; -import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JOp; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; -import com.sun.tools.xjc.outline.Aspect; -import com.sun.tools.xjc.outline.ClassOutline; -import com.sun.tools.xjc.outline.FieldOutline; - -public class SimpleEqualsPlugin extends - AbstractCodeGeneratorPlugin { - - @Override - public String getOptionName() { - return "XsimpleEquals"; - } - - @Override - public String getUsage() { - return " -XsimpleEquals : Generate reflection-free runtime-free equals(Object that) methods.\n" + - " See https://github.com/highsource/jaxb2-basics/wiki/JAXB2-SimpleEquals-Plugin"; - } - - @Override - protected QName getSpecialIgnoredElementName() { - return org.jvnet.jaxb2_commons.plugin.equals.Customizations.IGNORED_ELEMENT_NAME; - } - - @Override - protected CodeGenerator createCodeGenerator( - JCodeModel codeModel) { - return new EqualsCodeGenerator(codeModel); - } - - @Override - protected void generate(ClassOutline classOutline, JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - final JMethod objectEquals = theClass.method(JMod.PUBLIC, - codeModel.BOOLEAN, "equals"); - objectEquals.annotate(Override.class); // DEMATIC - - final JVar object = objectEquals.param(Object.class, "object"); - - final JBlock body = objectEquals.body(); - - JExpression objectIsNull = object.eq(JExpr._null()); - JExpression notTheSameType = JExpr._this().invoke("getClass").ne(object.invoke("getClass")); - body._if(JOp.cor(objectIsNull, notTheSameType)) - ._then()._return(JExpr.FALSE); - - body._if(JExpr._this().eq(object))._then()._return(JExpr.TRUE); - final Boolean superClassNotIgnored = StrategyClassUtils - .superClassNotIgnored(classOutline, getIgnoring()); - - if (superClassNotIgnored != null) { - body._if(JOp.not(JExpr._super().invoke("equals").arg(object))) - ._then()._return(JExpr.FALSE); - } - final JExpression _this = JExpr._this(); - - final FieldOutline[] fields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); - - if (fields.length > 0) { - - final JVar _that = body.decl(JMod.FINAL, theClass, "that", - JExpr.cast(theClass, object)); - - for (final FieldOutline fieldOutline : fields) { - - final FieldAccessorEx leftFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, _this); - final FieldAccessorEx rightFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, _that); - - if (leftFieldAccessor.isConstant() - || rightFieldAccessor.isConstant()) { - continue; - } - - final JBlock block = body; // DEMATIC - - final String name = fieldOutline.getPropertyInfo().getName(true); - final JType type = leftFieldAccessor.getType(); - - final JVar leftValue = block.decl(type, "left" + name, JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC - final JVar rightValue = block.decl( rightFieldAccessor.getType(), "right" + name,_that.invoke(createMethodName(fieldOutline))); // DEMATIC - - final JType exposedType = leftFieldAccessor.getType(); - - final Collection possibleTypes = FieldUtils - .getPossibleTypes(fieldOutline, Aspect.EXPOSED); - final boolean isAlwaysSet = leftFieldAccessor.isAlwaysSet(); -// final JExpression leftHasSetValue = exposedType.isPrimitive() ? JExpr.TRUE -// : leftValue.ne(JExpr._null()); - final JExpression leftHasSetValue = (leftFieldAccessor.isAlwaysSet() || leftFieldAccessor - .hasSetValue() == null) ? JExpr.TRUE - : leftFieldAccessor.hasSetValue(); - -// final JExpression rightHasSetValue = exposedType.isPrimitive() ? JExpr.TRUE -// : rightValue.ne(JExpr._null()); - - final JExpression rightHasSetValue = (rightFieldAccessor.isAlwaysSet() || rightFieldAccessor - .hasSetValue() == null) ? JExpr.TRUE - : rightFieldAccessor.hasSetValue(); - - getCodeGenerator().generate( - block, - exposedType, - possibleTypes, - isAlwaysSet, - new EqualsArguments(codeModel, leftValue, - leftHasSetValue, rightValue, rightHasSetValue)); - } - } - body._return(JExpr.TRUE); - - } - - - private String createMethodName(FieldOutline fieldOutline) { - String name = fieldOutline.getPropertyInfo().getName(true); - String type = fieldOutline.getRawType().name(); - if (type.toLowerCase().equals("boolean")) { - return "is" + name; - } - return "get" + name; - } - -} diff --git a/SimpleHashCodePlugin.java b/SimpleHashCodePlugin.java deleted file mode 100644 index bb101d1d..00000000 --- a/SimpleHashCodePlugin.java +++ /dev/null @@ -1,131 +0,0 @@ -package org.jvnet.jaxb2_commons.plugin.simplehashcode; - -import java.util.Collection; - -import javax.xml.namespace.QName; - -import org.jvnet.jaxb2_commons.plugin.codegenerator.AbstractCodeGeneratorPlugin; -import org.jvnet.jaxb2_commons.plugin.codegenerator.CodeGenerator; -import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; -import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; -import org.jvnet.jaxb2_commons.util.FieldUtils; -import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JType; -import com.sun.codemodel.JVar; -import com.sun.tools.xjc.outline.Aspect; -import com.sun.tools.xjc.outline.ClassOutline; -import com.sun.tools.xjc.outline.FieldOutline; - -public class SimpleHashCodePlugin extends - AbstractCodeGeneratorPlugin { - - @Override - public String getOptionName() { - return "XsimpleHashCode"; - } - - @Override - public String getUsage() { - return " -XsimpleEquals : Generate reflection-free runtime-free hashCode() methods.\n" + - " See https://github.com/highsource/jaxb2-basics/wiki/JAXB2-SimpleHashCode-Plugin"; - } - - @Override - protected QName getSpecialIgnoredElementName() { - return org.jvnet.jaxb2_commons.plugin.hashcode.Customizations.IGNORED_ELEMENT_NAME; - } - - private int multiplier = 31; - - private int getMultiplier() { - return multiplier; - } - - @Override - protected CodeGenerator createCodeGenerator( - JCodeModel codeModel) { - return new HashCodeCodeGenerator(codeModel); - } - - @Override - protected void generate(ClassOutline classOutline, JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - final JMethod object$hashCode = theClass.method(JMod.PUBLIC, codeModel.INT, "hashCode"); - object$hashCode.annotate(Override.class); // DEMATIC - - final JBlock body = object$hashCode.body(); - - final JExpression currentHashCodeExpression = JExpr.lit(1); - - final JVar currentHashCode = body.decl(codeModel.INT, - "currentHashCode", currentHashCodeExpression); - - final Boolean superClassImplementsHashCode = StrategyClassUtils - .superClassNotIgnored(classOutline, getIgnoring()); - - if (superClassImplementsHashCode != null) { - body.assign( - currentHashCode, - currentHashCode.mul(JExpr.lit(getMultiplier())).plus( - JExpr._super().invoke("hashCode"))); - } - - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); - - if (declaredFields.length > 0) { - - for (final FieldOutline fieldOutline : declaredFields) { - final FieldAccessorEx fieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, JExpr._this()); - if (fieldAccessor.isConstant()) { - continue; - } - final JBlock block = body; // DEMATIC - block.assign(currentHashCode, - currentHashCode.mul(JExpr.lit(getMultiplier()))); - - String propertyName = fieldOutline.getPropertyInfo().getName(true);// DEMATIC - final JVar value = block.decl(fieldAccessor.getType(), "the" + propertyName,JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC - - final JType exposedType = fieldAccessor.getType(); - - final Collection possibleTypes = FieldUtils - .getPossibleTypes(fieldOutline, Aspect.EXPOSED); - final boolean isAlwaysSet = fieldAccessor.isAlwaysSet(); -// final JExpression hasSetValue = exposedType.isPrimitive() ? JExpr.TRUE -// : value.ne(JExpr._null()); - - final JExpression hasSetValue = (fieldAccessor.isAlwaysSet() || fieldAccessor - .hasSetValue() == null) ? JExpr.TRUE - : fieldAccessor.hasSetValue(); - getCodeGenerator().generate( - block, - exposedType, - possibleTypes, - isAlwaysSet, - new HashCodeArguments(codeModel, currentHashCode, - getMultiplier(), value, hasSetValue)); - } - } - body._return(currentHashCode); - } - - private String createMethodName(FieldOutline fieldOutline) { - String name = fieldOutline.getPropertyInfo().getName(true); - String type = fieldOutline.getRawType().name(); - if (type.toLowerCase().equals("boolean")) { - return "is" + name; - } - return "get" + name; - } - -} diff --git a/ToStringPlugin.java b/ToStringPlugin.java deleted file mode 100644 index 333f9a58..00000000 --- a/ToStringPlugin.java +++ /dev/null @@ -1,234 +0,0 @@ -package org.jvnet.jaxb2_commons.plugin.tostring; - -import java.util.Arrays; -import java.util.Collection; - -import javax.xml.namespace.QName; - -import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; -import org.jvnet.jaxb2_commons.lang.ToString2; -import org.jvnet.jaxb2_commons.lang.ToStringStrategy2; -import org.jvnet.jaxb2_commons.locator.ObjectLocator; -import org.jvnet.jaxb2_commons.plugin.AbstractParameterizablePlugin; -import org.jvnet.jaxb2_commons.plugin.Customizations; -import org.jvnet.jaxb2_commons.plugin.CustomizedIgnoring; -import org.jvnet.jaxb2_commons.plugin.Ignoring; -import org.jvnet.jaxb2_commons.plugin.util.FieldOutlineUtils; -import org.jvnet.jaxb2_commons.plugin.util.StrategyClassUtils; -import org.jvnet.jaxb2_commons.util.ClassUtils; -import org.jvnet.jaxb2_commons.util.FieldAccessorFactory; -import org.jvnet.jaxb2_commons.util.PropertyFieldAccessorFactory; -import org.jvnet.jaxb2_commons.xjc.outline.FieldAccessorEx; -import org.xml.sax.ErrorHandler; - -import com.sun.codemodel.JBlock; -import com.sun.codemodel.JCodeModel; -import com.sun.codemodel.JDefinedClass; -import com.sun.codemodel.JExpr; -import com.sun.codemodel.JExpression; -import com.sun.codemodel.JMethod; -import com.sun.codemodel.JMod; -import com.sun.codemodel.JVar; -import com.sun.tools.xjc.Options; -import com.sun.tools.xjc.outline.ClassOutline; -import com.sun.tools.xjc.outline.FieldOutline; -import com.sun.tools.xjc.outline.Outline; - -public class ToStringPlugin extends AbstractParameterizablePlugin { - - @Override - public String getOptionName() { - return "XtoString"; - } - - @Override - public String getUsage() { - return "TBD"; - } - - private FieldAccessorFactory fieldAccessorFactory = PropertyFieldAccessorFactory.INSTANCE; - - public FieldAccessorFactory getFieldAccessorFactory() { - return fieldAccessorFactory; - } - - public void setFieldAccessorFactory( - FieldAccessorFactory fieldAccessorFactory) { - this.fieldAccessorFactory = fieldAccessorFactory; - } - - private String toStringStrategyClass = JAXBToStringStrategy.class.getName(); - - public void setToStringStrategyClass(String toStringStrategy) { - this.toStringStrategyClass = toStringStrategy; - } - - public String getToStringStrategyClass() { - return toStringStrategyClass; - } - - public JExpression createToStringStrategy(JCodeModel codeModel) { - return StrategyClassUtils.createStrategyInstanceExpression(codeModel, - ToStringStrategy2.class, getToStringStrategyClass()); - } - - private Ignoring ignoring = new CustomizedIgnoring( - org.jvnet.jaxb2_commons.plugin.tostring.Customizations.IGNORED_ELEMENT_NAME, - Customizations.IGNORED_ELEMENT_NAME, - Customizations.GENERATED_ELEMENT_NAME); - - public Ignoring getIgnoring() { - return ignoring; - } - - public void setIgnoring(Ignoring ignoring) { - this.ignoring = ignoring; - } - - @Override - public Collection getCustomizationElementNames() { - return Arrays - .asList(org.jvnet.jaxb2_commons.plugin.tostring.Customizations.IGNORED_ELEMENT_NAME, - Customizations.IGNORED_ELEMENT_NAME, - Customizations.GENERATED_ELEMENT_NAME); - } - - @Override - public boolean run(Outline outline, Options opt, ErrorHandler errorHandler) { - for (final ClassOutline classOutline : outline.getClasses()) - if (!getIgnoring().isIgnored(classOutline)) { - processClassOutline(classOutline); - } - return true; - } - - protected void processClassOutline(ClassOutline classOutline) { - final JDefinedClass theClass = classOutline.implClass; - ClassUtils._implements(theClass, theClass.owner().ref(ToString2.class)); - - @SuppressWarnings("unused") - final JMethod object$toString = generateObject$toString(classOutline, - theClass); - @SuppressWarnings("unused") - final JMethod toString$append = generateToString$append(classOutline, - theClass); - @SuppressWarnings("unused") - final JMethod toString$appendFields = generateToString$appendFields( - classOutline, theClass); - } - - protected JMethod generateObject$toString(final ClassOutline classOutline, - final JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - final JMethod object$toString = theClass.method(JMod.PUBLIC, - codeModel.ref(String.class), "toString"); - object$toString.annotate(Override.class); // DEMATIC - - final JBlock body = object$toString.body(); - - final JVar toStringStrategy = body.decl(JMod.FINAL, codeModel.ref(ToStringStrategy2.class), - "strategy2", createToStringStrategy(codeModel)); - - final JVar buffer = body.decl(JMod.FINAL, - codeModel.ref(StringBuilder.class), "buffer", - JExpr._new(codeModel.ref(StringBuilder.class))); - body.invoke("append").arg(JExpr._null()).arg(buffer).arg(toStringStrategy); - body._return(buffer.invoke("toString")); - - return object$toString; - } - - protected JMethod generateToString$append(final ClassOutline classOutline, - final JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - final JMethod toString$append = theClass.method(JMod.PUBLIC, - codeModel.ref(StringBuilder.class), "append"); - toString$append.annotate(Override.class); // DEMATIC - - final JVar locator = toString$append.param(ObjectLocator.class, "locator"); - final JVar buffer = toString$append.param(StringBuilder.class, "buffer"); - final JVar toStringStrategy = toString$append.param( - ToStringStrategy2.class, "strategy2"); - - final JBlock body = toString$append.body(); - - body.invoke(toStringStrategy, "appendStart").arg(locator) - .arg(JExpr._this()).arg(buffer); - body.invoke("appendFields").arg(locator).arg(buffer) - .arg(toStringStrategy); - body.invoke(toStringStrategy, "appendEnd").arg(locator) - .arg(JExpr._this()).arg(buffer); - body._return(buffer); - - return toString$append; - } - - protected JMethod generateToString$appendFields(ClassOutline classOutline, final JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - - final JMethod toString$appendFields = theClass.method(JMod.PUBLIC, - codeModel.ref(StringBuilder.class), "appendFields"); - toString$appendFields.annotate(Override.class); // DEMATIC - - final JVar locator = toString$appendFields.param( - ObjectLocator.class, "locator"); - final JVar buffer = toString$appendFields.param( - StringBuilder.class, "buffer"); - final JVar toStringStrategy = toString$appendFields.param( - ToStringStrategy2.class, "strategy2"); - final JBlock body = toString$appendFields.body(); - - final Boolean superClassImplementsToString = StrategyClassUtils - .superClassImplements(classOutline, ignoring, - ToString2.class); - - if (superClassImplementsToString == null) { - // No superclass - } else if (superClassImplementsToString.booleanValue()) { - body.invoke(JExpr._super(), "appendFields").arg(locator) - .arg(buffer).arg(toStringStrategy); - } else { - // Superclass does not implement ToString - } - - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); - - if (declaredFields.length > 0) { - - for (final FieldOutline fieldOutline : declaredFields) { - final JBlock block = body; //DEMATIC - final FieldAccessorEx fieldAccessor = getFieldAccessorFactory().createFieldAccessor(fieldOutline, JExpr._this()); - - //final JVar theValue = block.decl(fieldAccessor.getType(),"the"+ fieldOutline.getPropertyInfo().getName(true)); - //fieldAccessor.toRawValue(block, theValue); - - String propertyName = fieldOutline.getPropertyInfo().getName(true); - final JVar theValue = block.decl(fieldAccessor.getType(), "the" + propertyName,JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC - - final JExpression valueIsSet = (fieldAccessor.isAlwaysSet() || fieldAccessor - .hasSetValue() == null) ? JExpr.TRUE - : fieldAccessor.hasSetValue(); - - block.invoke(toStringStrategy, "appendField") - .arg(locator) - .arg(JExpr._this()) - .arg(JExpr.lit(fieldOutline.getPropertyInfo() - .getName(false))).arg(buffer).arg(theValue) - .arg(valueIsSet); - } - } - body._return(buffer); - return toString$appendFields; - } - - private String createMethodName(FieldOutline fieldOutline) { - String name = fieldOutline.getPropertyInfo().getName(true); - String type = fieldOutline.getRawType().name(); - if (type.toLowerCase().equals("boolean")) { - return "is" + name; - } - return "get" + name; - } - -} \ No newline at end of file From 0be43ebc4026cc0c97b74908632029f0b2c613f1 Mon Sep 17 00:00:00 2001 From: cstenkes Date: Fri, 1 Feb 2019 23:34:16 +0100 Subject: [PATCH 5/6] My extentions for jaxb basics (plugins): * No unnecessary block in methods like toString(), equals(), hashCode(), append(), copyTo() * No unnecessary declaraction line and assignment lines for a given varaible in method like above * @Override everywhere where necessary * Less SuppressWarnings are used when this is not necessary (at Eclipse,Java 8 default compiler options) --- .../plugin/copyable/CopyablePlugin.java | 286 +++++++++--------- .../plugin/mergeable/MergeablePlugin.java | 283 ++++++++--------- .../simpleequals/SimpleEqualsPlugin.java | 30 +- .../simplehashcode/SimpleHashCodePlugin.java | 110 +++---- .../plugin/tostring/ToStringPlugin.java | 171 ++++++----- 5 files changed, 449 insertions(+), 431 deletions(-) diff --git a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/copyable/CopyablePlugin.java b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/copyable/CopyablePlugin.java index 8b6f236c..34376920 100644 --- a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/copyable/CopyablePlugin.java +++ b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/copyable/CopyablePlugin.java @@ -23,7 +23,7 @@ import org.xml.sax.ErrorHandler; import com.sun.codemodel.JBlock; -import com.sun.codemodel.JClass; +//import com.sun.codemodel.JClass; import com.sun.codemodel.JCodeModel; import com.sun.codemodel.JConditional; import com.sun.codemodel.JDefinedClass; @@ -154,11 +154,9 @@ protected void processClassOutline(ClassOutline classOutline) { final JMethod newMethod = theClass.method(JMod.PUBLIC, theClass .owner().ref(Object.class), "createNewInstance"); - newMethod.annotate(Override.class); - { - final JBlock body = newMethod.body(); - body._return(JExpr._new(theClass)); - } + newMethod.annotate(Override.class); // DEMATIC + final JBlock body = newMethod.body(); + body._return(JExpr._new(theClass)); return newMethod; } else { return existingMethod; @@ -167,15 +165,12 @@ protected void processClassOutline(ClassOutline classOutline) { protected JMethod generateObject$clone(final ClassOutline classOutline, final JDefinedClass theClass) { - final JMethod clone = theClass.method(JMod.PUBLIC, theClass.owner() .ref(Object.class), "clone"); - clone.annotate(Override.class); - { - final JBlock body = clone.body(); - body._return(JExpr.invoke("copyTo").arg( - JExpr.invoke("createNewInstance"))); - } + clone.annotate(Override.class); // DEMATIC + final JBlock body = clone.body(); + body._return(JExpr.invoke("copyTo").arg( + JExpr.invoke("createNewInstance"))); return clone; } @@ -185,18 +180,17 @@ protected void processClassOutline(ClassOutline classOutline) { final JCodeModel codeModel = theClass.owner(); final JMethod copyTo$copyTo = theClass.method(JMod.PUBLIC, codeModel.ref(Object.class), "copyTo"); - copyTo$copyTo.annotate(Override.class); - { - final JVar target = copyTo$copyTo.param(Object.class, "target"); + copyTo$copyTo.annotate(Override.class); // DEMATIC + final JVar target = copyTo$copyTo.param(Object.class, "target"); - final JBlock body = copyTo$copyTo.body(); - final JVar copyStrategy = body.decl(JMod.FINAL, - codeModel.ref(CopyStrategy2.class), "strategy", - createCopyStrategy(codeModel)); + final JBlock body = copyTo$copyTo.body(); + final JVar copyStrategy = body.decl(JMod.FINAL, + codeModel.ref(CopyStrategy2.class), "strategy2", + createCopyStrategy(codeModel)); - body._return(JExpr.invoke("copyTo").arg(JExpr._null()).arg(target) - .arg(copyStrategy)); - } + body._return(JExpr.invoke("copyTo").arg(JExpr._null()).arg(target) + .arg(copyStrategy)); + return copyTo$copyTo; } @@ -207,137 +201,143 @@ protected void processClassOutline(ClassOutline classOutline) { final JMethod copyTo = theClass.method(JMod.PUBLIC, codeModel.ref(Object.class), "copyTo"); - copyTo.annotate(Override.class); - { - final JVar locator = copyTo.param(ObjectLocator.class, "locator"); - final JVar target = copyTo.param(Object.class, "target"); - final JVar copyStrategy = copyTo.param(CopyStrategy2.class, - "strategy"); - - final JBlock body = copyTo.body(); - - final JVar draftCopy; - if (!classOutline.target.isAbstract()) { - draftCopy = body.decl( - JMod.FINAL, - codeModel.ref(Object.class), - "draftCopy", - - JOp.cond(JOp.eq(target, JExpr._null()), - JExpr.invoke("createNewInstance"), target)); - } else { - body._if(JExpr._null().eq(target)) - ._then() - ._throw(JExpr - ._new(codeModel - .ref(IllegalArgumentException.class)) - .arg("Target argument must not be null for abstract copyable classes.")); - draftCopy = target; - } + copyTo.annotate(Override.class); // DEMATIC + final JVar locator = copyTo.param(ObjectLocator.class, "locator"); + final JVar target = copyTo.param(Object.class, "target"); + final JVar copyStrategy = copyTo.param(CopyStrategy2.class, + "strategy2"); + + final JBlock body = copyTo.body(); + + final JVar draftCopy; + if (!classOutline.target.isAbstract()) { + draftCopy = body.decl( + JMod.FINAL, + codeModel.ref(Object.class), + "draftCopy", - Boolean superClassImplementsCopyTo = StrategyClassUtils - .superClassImplements(classOutline, getIgnoring(), - CopyTo2.class); + JOp.cond(JOp.eq(target, JExpr._null()), + JExpr.invoke("createNewInstance"), target)); + } else { + body._if(JExpr._null().eq(target)) + ._then() + ._throw(JExpr + ._new(codeModel + .ref(IllegalArgumentException.class)) + .arg("Target argument must not be null for abstract copyable classes.")); + draftCopy = target; + } - if (superClassImplementsCopyTo == null) { + Boolean superClassImplementsCopyTo = StrategyClassUtils + .superClassImplements(classOutline, getIgnoring(), + CopyTo2.class); - } else if (superClassImplementsCopyTo.booleanValue()) { - body.invoke(JExpr._super(), "copyTo").arg(locator) - .arg(draftCopy).arg(copyStrategy); + if (superClassImplementsCopyTo == null) { - } else { + } else if (superClassImplementsCopyTo.booleanValue()) { + body.invoke(JExpr._super(), "copyTo").arg(locator) + .arg(draftCopy).arg(copyStrategy); - } + } else { - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); + } - if (declaredFields.length > 0) { + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); - final JBlock bl = body._if(draftCopy._instanceof(theClass)) - ._then(); + if (declaredFields.length > 0) { + + final JBlock bl = body._if(draftCopy._instanceof(theClass)) + ._then(); + + final JVar copy = bl.decl(JMod.FINAL, theClass, "copy", + JExpr.cast(theClass, draftCopy)); - final JVar copy = bl.decl(JMod.FINAL, theClass, "copy", - JExpr.cast(theClass, draftCopy)); - - for (final FieldOutline fieldOutline : declaredFields) { - - final FieldAccessorEx sourceFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, JExpr._this()); - final FieldAccessorEx copyFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, copy); - - if (sourceFieldAccessor.isConstant()) { - continue; - } - - final JBlock block = bl.block(); - - final JExpression valueIsSet = (sourceFieldAccessor - .isAlwaysSet() || sourceFieldAccessor.hasSetValue() == null) ? JExpr.TRUE - : sourceFieldAccessor.hasSetValue(); - - final JVar shouldBeCopied = block.decl(codeModel - .ref(Boolean.class), fieldOutline.getPropertyInfo() - .getName(false) + "ShouldBeCopiedAndSet", - copyStrategy.invoke("shouldBeCopiedAndSet").arg(locator) - .arg(valueIsSet)); - - final JConditional ifShouldBeSetConditional = block._if(JOp - .eq(shouldBeCopied, codeModel.ref(Boolean.class) - .staticRef("TRUE"))); - - final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional - ._then(); - final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional - ._elseif(JOp.eq( - shouldBeCopied, - codeModel.ref(Boolean.class).staticRef( - "FALSE"))); - final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional - ._then(); - - final JType copyFieldType = sourceFieldAccessor.getType(); - final JVar sourceField = ifShouldBeSetBlock.decl( - copyFieldType, - "source" - + fieldOutline.getPropertyInfo().getName( - true)); - sourceFieldAccessor.toRawValue(ifShouldBeSetBlock, - sourceField); - final JExpression builtCopy = JExpr - .invoke(copyStrategy, "copy") - .arg(codeModel - .ref(LocatorUtils.class) - .staticInvoke("property") - .arg(locator) - .arg(fieldOutline.getPropertyInfo() - .getName(false)).arg(sourceField)) - .arg(sourceField).arg(valueIsSet); - final JVar copyField = ifShouldBeSetBlock.decl( - copyFieldType, - "copy" - + fieldOutline.getPropertyInfo().getName( - true), - copyFieldType.isPrimitive() ? builtCopy : - - JExpr.cast(copyFieldType, builtCopy)); - if (copyFieldType instanceof JClass - && ((JClass) copyFieldType).isParameterized()) { - copyField.annotate(SuppressWarnings.class).param( - "value", "unchecked"); - } - copyFieldAccessor.fromRawValue(ifShouldBeSetBlock, "unique" - + fieldOutline.getPropertyInfo().getName(true), - copyField); - - copyFieldAccessor.unsetValues(ifShouldBeUnsetBlock); + for (final FieldOutline fieldOutline : declaredFields) { + + final FieldAccessorEx sourceFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, JExpr._this()); + final FieldAccessorEx copyFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, copy); + + if (sourceFieldAccessor.isConstant()) { + continue; } - } - body._return(draftCopy); + final JBlock block = bl; // DEMATIC + + final JExpression valueIsSet = (sourceFieldAccessor + .isAlwaysSet() || sourceFieldAccessor.hasSetValue() == null) ? JExpr.TRUE + : sourceFieldAccessor.hasSetValue(); + + final JVar shouldBeCopied = block.decl(codeModel + .ref(Boolean.class), fieldOutline.getPropertyInfo() + .getName(false) + "ShouldBeCopiedAndSet", + copyStrategy.invoke("shouldBeCopiedAndSet").arg(locator) + .arg(valueIsSet)); + + final JConditional ifShouldBeSetConditional = block._if(JOp + .eq(shouldBeCopied, codeModel.ref(Boolean.class) + .staticRef("TRUE"))); + + final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional + ._then(); + final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional + ._elseif(JOp.eq( + shouldBeCopied, + codeModel.ref(Boolean.class).staticRef( + "FALSE"))); + final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional + ._then(); + + final JType copyFieldType = sourceFieldAccessor.getType(); + + //final JVar sourceField = ifShouldBeSetBlock.decl( copyFieldType, "source" + fieldOutline.getPropertyInfo().getName(true)); + //sourceFieldAccessor.toRawValue(ifShouldBeSetBlock, sourceField); + + String propertyName = fieldOutline.getPropertyInfo().getName(true);// DEMATIC + final JVar sourceField = ifShouldBeSetBlock.decl(copyFieldType, "source" + propertyName, JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + + final JExpression builtCopy = JExpr + .invoke(copyStrategy, "copy") + .arg(codeModel + .ref(LocatorUtils.class) + .staticInvoke("property") + .arg(locator) + .arg(fieldOutline.getPropertyInfo() + .getName(false)).arg(sourceField)) + .arg(sourceField).arg(valueIsSet); + final JVar copyField = ifShouldBeSetBlock.decl( + copyFieldType, + "copy" + + fieldOutline.getPropertyInfo().getName( + true), + copyFieldType.isPrimitive() ? builtCopy : + + JExpr.cast(copyFieldType, builtCopy)); +// if (copyFieldType instanceof JClass +// && ((JClass) copyFieldType).isParameterized()) { +// copyField.annotate(SuppressWarnings.class).param( +// "value", "unchecked"); +// } + copyFieldAccessor.fromRawValue(ifShouldBeSetBlock, "unique" + + fieldOutline.getPropertyInfo().getName(true), + copyField); + + copyFieldAccessor.unsetValues(ifShouldBeUnsetBlock); + } } + + body._return(draftCopy); return copyTo; } - -} + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } +} \ No newline at end of file diff --git a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/mergeable/MergeablePlugin.java b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/mergeable/MergeablePlugin.java index 7edec3d1..03bbda08 100644 --- a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/mergeable/MergeablePlugin.java +++ b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/mergeable/MergeablePlugin.java @@ -132,19 +132,17 @@ protected void processClassOutline(ClassOutline classOutline) { JCodeModel codeModel = theClass.owner(); final JMethod mergeFrom$mergeFrom = theClass.method(JMod.PUBLIC, codeModel.VOID, "mergeFrom"); - mergeFrom$mergeFrom.annotate(Override.class); - { - final JVar left = mergeFrom$mergeFrom.param(Object.class, "left"); - final JVar right = mergeFrom$mergeFrom.param(Object.class, "right"); - final JBlock body = mergeFrom$mergeFrom.body(); - - final JVar mergeStrategy = body.decl(JMod.FINAL, - codeModel.ref(MergeStrategy2.class), "strategy", - createMergeStrategy(codeModel)); - - body.invoke("mergeFrom").arg(JExpr._null()).arg(JExpr._null()) - .arg(left).arg(right).arg(mergeStrategy); - } + mergeFrom$mergeFrom.annotate(Override.class); // DEMATIC + final JVar left = mergeFrom$mergeFrom.param(Object.class, "left"); + final JVar right = mergeFrom$mergeFrom.param(Object.class, "right"); + final JBlock body = mergeFrom$mergeFrom.body(); + + final JVar mergeStrategy = body.decl(JMod.FINAL, + codeModel.ref(MergeStrategy2.class), "strategy2", + createMergeStrategy(codeModel)); + + body.invoke("mergeFrom").arg(JExpr._null()).arg(JExpr._null()) + .arg(left).arg(right).arg(mergeStrategy); return mergeFrom$mergeFrom; } @@ -154,143 +152,143 @@ protected void processClassOutline(ClassOutline classOutline) { final JMethod mergeFrom = theClass.method(JMod.PUBLIC, codeModel.VOID, "mergeFrom"); - mergeFrom.annotate(Override.class); - { - final JVar leftLocator = mergeFrom.param(ObjectLocator.class, - "leftLocator"); - final JVar rightLocator = mergeFrom.param(ObjectLocator.class, - "rightLocator"); - final JVar left = mergeFrom.param(Object.class, "left"); - final JVar right = mergeFrom.param(Object.class, "right"); + mergeFrom.annotate(Override.class); // DEMATIC + final JVar leftLocator = mergeFrom.param(ObjectLocator.class, + "leftLocator"); + final JVar rightLocator = mergeFrom.param(ObjectLocator.class, + "rightLocator"); + final JVar left = mergeFrom.param(Object.class, "left"); + final JVar right = mergeFrom.param(Object.class, "right"); - final JVar mergeStrategy = mergeFrom.param(MergeStrategy2.class, - "strategy"); + final JVar mergeStrategy = mergeFrom.param(MergeStrategy2.class, + "strategy2"); - final JBlock methodBody = mergeFrom.body(); + final JBlock methodBody = mergeFrom.body(); - Boolean superClassImplementsMergeFrom = StrategyClassUtils - .superClassImplements(classOutline, getIgnoring(), - MergeFrom2.class); + Boolean superClassImplementsMergeFrom = StrategyClassUtils + .superClassImplements(classOutline, getIgnoring(), + MergeFrom2.class); - if (superClassImplementsMergeFrom == null) { + if (superClassImplementsMergeFrom == null) { - } else if (superClassImplementsMergeFrom.booleanValue()) { - methodBody.invoke(JExpr._super(), "mergeFrom").arg(leftLocator) - .arg(rightLocator).arg(left).arg(right) - .arg(mergeStrategy); - } else { + } else if (superClassImplementsMergeFrom.booleanValue()) { + methodBody.invoke(JExpr._super(), "mergeFrom").arg(leftLocator) + .arg(rightLocator).arg(left).arg(right) + .arg(mergeStrategy); + } else { - } + } - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (declaredFields.length > 0) { + + final JBlock body = methodBody._if(right._instanceof(theClass)) + ._then(); + + JVar target = body.decl(JMod.FINAL, theClass, "target", + JExpr._this()); + JVar leftObject = body.decl(JMod.FINAL, theClass, "leftObject", + JExpr.cast(theClass, left)); + JVar rightObject = body.decl(JMod.FINAL, theClass, + "rightObject", JExpr.cast(theClass, right)); + for (final FieldOutline fieldOutline : declaredFields) { + final FieldAccessorEx leftFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, leftObject); + final FieldAccessorEx rightFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, rightObject); + if (leftFieldAccessor.isConstant() + || rightFieldAccessor.isConstant()) { + continue; + } - if (declaredFields.length > 0) { + final JBlock block = body; // DEMATIC - final JBlock body = methodBody._if(right._instanceof(theClass)) - ._then(); + final JExpression leftFieldHasSetValue = (leftFieldAccessor + .isAlwaysSet() || leftFieldAccessor.hasSetValue() == null) ? JExpr.TRUE + : leftFieldAccessor.hasSetValue(); - JVar target = body.decl(JMod.FINAL, theClass, "target", - JExpr._this()); - JVar leftObject = body.decl(JMod.FINAL, theClass, "leftObject", - JExpr.cast(theClass, left)); - JVar rightObject = body.decl(JMod.FINAL, theClass, - "rightObject", JExpr.cast(theClass, right)); - for (final FieldOutline fieldOutline : declaredFields) { - final FieldAccessorEx leftFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, leftObject); - final FieldAccessorEx rightFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, rightObject); - if (leftFieldAccessor.isConstant() - || rightFieldAccessor.isConstant()) { - continue; - } - - final JBlock block = body.block(); - - final JExpression leftFieldHasSetValue = (leftFieldAccessor - .isAlwaysSet() || leftFieldAccessor.hasSetValue() == null) ? JExpr.TRUE - : leftFieldAccessor.hasSetValue(); - - final JExpression rightFieldHasSetValue = (rightFieldAccessor - .isAlwaysSet() || rightFieldAccessor.hasSetValue() == null) ? JExpr.TRUE - : rightFieldAccessor.hasSetValue(); - - final JVar shouldBeSet = block.decl( - codeModel.ref(Boolean.class), - fieldOutline.getPropertyInfo().getName(false) - + "ShouldBeMergedAndSet", - mergeStrategy.invoke("shouldBeMergedAndSet") - .arg(leftLocator).arg(rightLocator) - .arg(leftFieldHasSetValue) - .arg(rightFieldHasSetValue)); + final JExpression rightFieldHasSetValue = (rightFieldAccessor + .isAlwaysSet() || rightFieldAccessor.hasSetValue() == null) ? JExpr.TRUE + : rightFieldAccessor.hasSetValue(); + + final JVar shouldBeSet = block.decl( + codeModel.ref(Boolean.class), + fieldOutline.getPropertyInfo().getName(false) + + "ShouldBeMergedAndSet", + mergeStrategy.invoke("shouldBeMergedAndSet") + .arg(leftLocator).arg(rightLocator) + .arg(leftFieldHasSetValue) + .arg(rightFieldHasSetValue)); + + final JConditional ifShouldBeSetConditional = block._if(JOp + .eq(shouldBeSet, codeModel.ref(Boolean.class) + .staticRef("TRUE"))); - final JConditional ifShouldBeSetConditional = block._if(JOp - .eq(shouldBeSet, codeModel.ref(Boolean.class) - .staticRef("TRUE"))); - - final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional - ._then(); - final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional - ._elseif(JOp.eq( - shouldBeSet, - codeModel.ref(Boolean.class).staticRef( - "FALSE"))); - final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional - ._then(); - // final JBlock ifShouldBeIgnoredBlock = - // ifShouldNotBeSetConditional - // ._else(); - - final JVar leftField = ifShouldBeSetBlock.decl( - leftFieldAccessor.getType(), - "lhs" - + fieldOutline.getPropertyInfo().getName( - true)); - leftFieldAccessor.toRawValue(ifShouldBeSetBlock, leftField); - final JVar rightField = ifShouldBeSetBlock.decl( - rightFieldAccessor.getType(), - "rhs" - + fieldOutline.getPropertyInfo().getName( - true)); - - rightFieldAccessor.toRawValue(ifShouldBeSetBlock, - rightField); - - final JExpression leftFieldLocator = codeModel - .ref(LocatorUtils.class).staticInvoke("property") - .arg(leftLocator) - .arg(fieldOutline.getPropertyInfo().getName(false)) - .arg(leftField); - final JExpression rightFieldLocator = codeModel - .ref(LocatorUtils.class).staticInvoke("property") - .arg(rightLocator) - .arg(fieldOutline.getPropertyInfo().getName(false)) - .arg(rightField); - - final FieldAccessorEx targetFieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, target); - final JExpression mergedValue = JExpr.cast( + final JBlock ifShouldBeSetBlock = ifShouldBeSetConditional + ._then(); + final JConditional ifShouldNotBeSetConditional = ifShouldBeSetConditional + ._elseif(JOp.eq( + shouldBeSet, + codeModel.ref(Boolean.class).staticRef( + "FALSE"))); + final JBlock ifShouldBeUnsetBlock = ifShouldNotBeSetConditional + ._then(); + // final JBlock ifShouldBeIgnoredBlock = + // ifShouldNotBeSetConditional + // ._else(); + + String propertyName = fieldOutline.getPropertyInfo().getName(true); + + //final JVar leftField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(),"lhs" + fieldOutline.getPropertyInfo().getName(true)); + //leftFieldAccessor.toRawValue(ifShouldBeSetBlock, leftField); + final JVar leftField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(), "lhs" + propertyName, leftObject.invoke(createMethodName(fieldOutline))); // DEMATIC + + //final JVar rightField = ifShouldBeSetBlock.decl(rightFieldAccessor.getType(),"rhs" + fieldOutline.getPropertyInfo().getName(true)); + //rightFieldAccessor.toRawValue(ifShouldBeSetBlock, rightField); + final JVar rightField = ifShouldBeSetBlock.decl(leftFieldAccessor.getType(), "rhs" + propertyName, rightObject.invoke(createMethodName(fieldOutline))); // DEMATIC + + final JExpression leftFieldLocator = codeModel + .ref(LocatorUtils.class).staticInvoke("property") + .arg(leftLocator) + .arg(fieldOutline.getPropertyInfo().getName(false)) + .arg(leftField); + final JExpression rightFieldLocator = codeModel + .ref(LocatorUtils.class).staticInvoke("property") + .arg(rightLocator) + .arg(fieldOutline.getPropertyInfo().getName(false)) + .arg(rightField); + + final FieldAccessorEx targetFieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, target); + final JExpression mergedValue; + if (targetFieldAccessor.getType().name().equals("byte")|| + targetFieldAccessor.getType().name().equals("int")|| + targetFieldAccessor.getType().name().equals("float")|| + targetFieldAccessor.getType().name().equals("long")|| + targetFieldAccessor.getType().name().equals("short")|| + targetFieldAccessor.getType().name().equals("Object") + ) { + mergedValue = mergeStrategy.invoke("merge").arg(leftFieldLocator) + .arg(rightFieldLocator).arg(leftField) + .arg(rightField).arg(leftFieldHasSetValue) + .arg(rightFieldHasSetValue); + + } else { + mergedValue = JExpr.cast( targetFieldAccessor.getType(), mergeStrategy.invoke("merge").arg(leftFieldLocator) .arg(rightFieldLocator).arg(leftField) .arg(rightField).arg(leftFieldHasSetValue) .arg(rightFieldHasSetValue)); + } + + final JVar merged = ifShouldBeSetBlock.decl( rightFieldAccessor.getType(), "merged" + fieldOutline.getPropertyInfo().getName(true), mergedValue); - final JVar merged = ifShouldBeSetBlock.decl( - rightFieldAccessor.getType(), - "merged" - + fieldOutline.getPropertyInfo().getName( - true), mergedValue); - - targetFieldAccessor.fromRawValue( - ifShouldBeSetBlock, - "unique" - + fieldOutline.getPropertyInfo().getName( - true), merged); + targetFieldAccessor.fromRawValue( ifShouldBeSetBlock, "unique" + fieldOutline.getPropertyInfo().getName(true), merged); - targetFieldAccessor.unsetValues(ifShouldBeUnsetBlock); - } + targetFieldAccessor.unsetValues(ifShouldBeUnsetBlock); } } return mergeFrom; @@ -305,14 +303,23 @@ protected void processClassOutline(ClassOutline classOutline) { final JMethod newMethod = theClass.method(JMod.PUBLIC, theClass .owner().ref(Object.class), "createNewInstance"); - newMethod.annotate(Override.class); - { - final JBlock body = newMethod.body(); - body._return(JExpr._new(theClass)); - } + newMethod.annotate(Override.class); // DEMATIC + final JBlock body = newMethod.body(); + body._return(JExpr._new(theClass)); + return newMethod; } else { return existingMethod; } } -} + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + +} \ No newline at end of file diff --git a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simpleequals/SimpleEqualsPlugin.java b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simpleequals/SimpleEqualsPlugin.java index 954136ff..dd6e7297 100644 --- a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simpleequals/SimpleEqualsPlugin.java +++ b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simpleequals/SimpleEqualsPlugin.java @@ -55,8 +55,10 @@ protected void generate(ClassOutline classOutline, JDefinedClass theClass) { final JCodeModel codeModel = theClass.owner(); final JMethod objectEquals = theClass.method(JMod.PUBLIC, codeModel.BOOLEAN, "equals"); - objectEquals.annotate(Override.class); + objectEquals.annotate(Override.class); // DEMATIC + final JVar object = objectEquals.param(Object.class, "object"); + final JBlock body = objectEquals.body(); JExpression objectIsNull = object.eq(JExpr._null()); @@ -94,18 +96,13 @@ protected void generate(ClassOutline classOutline, JDefinedClass theClass) { continue; } - final JBlock block = body.block(); - - final String name = fieldOutline.getPropertyInfo() - .getName(true); + final JBlock block = body; // DEMATIC + final String name = fieldOutline.getPropertyInfo().getName(true); final JType type = leftFieldAccessor.getType(); - final JVar leftValue = block.decl(type, "left" + name); - leftFieldAccessor.toRawValue(block, leftValue); - - final JVar rightValue = block.decl( - rightFieldAccessor.getType(), "right" + name); - rightFieldAccessor.toRawValue(block, rightValue); + + final JVar leftValue = block.decl(type, "left" + name, JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + final JVar rightValue = block.decl( rightFieldAccessor.getType(), "right" + name,_that.invoke(createMethodName(fieldOutline))); // DEMATIC final JType exposedType = leftFieldAccessor.getType(); @@ -137,4 +134,15 @@ protected void generate(ClassOutline classOutline, JDefinedClass theClass) { body._return(JExpr.TRUE); } + + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + } diff --git a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/SimpleHashCodePlugin.java b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/SimpleHashCodePlugin.java index 127ab61e..6ae4d229 100644 --- a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/SimpleHashCodePlugin.java +++ b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/SimpleHashCodePlugin.java @@ -57,71 +57,75 @@ protected CodeGenerator createCodeGenerator( @Override protected void generate(ClassOutline classOutline, JDefinedClass theClass) { - final JCodeModel codeModel = theClass.owner(); - final JMethod object$hashCode = theClass.method(JMod.PUBLIC, - codeModel.INT, "hashCode"); - object$hashCode.annotate(Override.class); - { - final JBlock body = object$hashCode.body(); - - final JExpression currentHashCodeExpression = JExpr.lit(1); + final JMethod object$hashCode = theClass.method(JMod.PUBLIC, codeModel.INT, "hashCode"); + object$hashCode.annotate(Override.class); // DEMATIC - final JVar currentHashCode = body.decl(codeModel.INT, - "currentHashCode", currentHashCodeExpression); + final JBlock body = object$hashCode.body(); - final Boolean superClassImplementsHashCode = StrategyClassUtils - .superClassNotIgnored(classOutline, getIgnoring()); + final JExpression currentHashCodeExpression = JExpr.lit(1); - if (superClassImplementsHashCode != null) { - body.assign( - currentHashCode, - currentHashCode.mul(JExpr.lit(getMultiplier())).plus( - JExpr._super().invoke("hashCode"))); - } + final JVar currentHashCode = body.decl(codeModel.INT, + "currentHashCode", currentHashCodeExpression); - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); + final Boolean superClassImplementsHashCode = StrategyClassUtils + .superClassNotIgnored(classOutline, getIgnoring()); - if (declaredFields.length > 0) { - - for (final FieldOutline fieldOutline : declaredFields) { - final FieldAccessorEx fieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, JExpr._this()); - if (fieldAccessor.isConstant()) { - continue; - } - final JBlock block = body.block(); - block.assign(currentHashCode, - currentHashCode.mul(JExpr.lit(getMultiplier()))); + if (superClassImplementsHashCode != null) { + body.assign( + currentHashCode, + currentHashCode.mul(JExpr.lit(getMultiplier())).plus( + JExpr._super().invoke("hashCode"))); + } - String propertyName = fieldOutline.getPropertyInfo() - .getName(true); - final JVar value = block.decl(fieldAccessor.getType(), - "the" + propertyName); + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); - fieldAccessor.toRawValue(block, value); - final JType exposedType = fieldAccessor.getType(); + if (declaredFields.length > 0) { - final Collection possibleTypes = FieldUtils - .getPossibleTypes(fieldOutline, Aspect.EXPOSED); - final boolean isAlwaysSet = fieldAccessor.isAlwaysSet(); + for (final FieldOutline fieldOutline : declaredFields) { + final FieldAccessorEx fieldAccessor = getFieldAccessorFactory() + .createFieldAccessor(fieldOutline, JExpr._this()); + if (fieldAccessor.isConstant()) { + continue; + } + final JBlock block = body; // DEMATIC + block.assign(currentHashCode, + currentHashCode.mul(JExpr.lit(getMultiplier()))); + + String propertyName = fieldOutline.getPropertyInfo().getName(true);// DEMATIC + final JVar value = block.decl(fieldAccessor.getType(), "the" + propertyName,JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + + final JType exposedType = fieldAccessor.getType(); + + final Collection possibleTypes = FieldUtils + .getPossibleTypes(fieldOutline, Aspect.EXPOSED); + final boolean isAlwaysSet = fieldAccessor.isAlwaysSet(); // final JExpression hasSetValue = exposedType.isPrimitive() ? JExpr.TRUE // : value.ne(JExpr._null()); - - final JExpression hasSetValue = (fieldAccessor.isAlwaysSet() || fieldAccessor - .hasSetValue() == null) ? JExpr.TRUE - : fieldAccessor.hasSetValue(); - getCodeGenerator().generate( - block, - exposedType, - possibleTypes, - isAlwaysSet, - new HashCodeArguments(codeModel, currentHashCode, - getMultiplier(), value, hasSetValue)); - } + + final JExpression hasSetValue = (fieldAccessor.isAlwaysSet() || fieldAccessor + .hasSetValue() == null) ? JExpr.TRUE + : fieldAccessor.hasSetValue(); + getCodeGenerator().generate( + block, + exposedType, + possibleTypes, + isAlwaysSet, + new HashCodeArguments(codeModel, currentHashCode, + getMultiplier(), value, hasSetValue)); } - body._return(currentHashCode); } + body._return(currentHashCode); } + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } + } diff --git a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/tostring/ToStringPlugin.java b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/tostring/ToStringPlugin.java index 1d9ae783..d2553bb6 100644 --- a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/tostring/ToStringPlugin.java +++ b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/tostring/ToStringPlugin.java @@ -122,22 +122,19 @@ protected void processClassOutline(ClassOutline classOutline) { final JCodeModel codeModel = theClass.owner(); final JMethod object$toString = theClass.method(JMod.PUBLIC, codeModel.ref(String.class), "toString"); - object$toString.annotate(Override.class); - { - final JBlock body = object$toString.body(); + object$toString.annotate(Override.class); // DEMATIC - final JVar toStringStrategy = + final JBlock body = object$toString.body(); - body.decl(JMod.FINAL, codeModel.ref(ToStringStrategy2.class), - "strategy", createToStringStrategy(codeModel)); + final JVar toStringStrategy = body.decl(JMod.FINAL, codeModel.ref(ToStringStrategy2.class), + "strategy2", createToStringStrategy(codeModel)); - final JVar buffer = body.decl(JMod.FINAL, - codeModel.ref(StringBuilder.class), "buffer", - JExpr._new(codeModel.ref(StringBuilder.class))); - body.invoke("append").arg(JExpr._null()).arg(buffer) - .arg(toStringStrategy); - body._return(buffer.invoke("toString")); - } + final JVar buffer = body.decl(JMod.FINAL, + codeModel.ref(StringBuilder.class), "buffer", + JExpr._new(codeModel.ref(StringBuilder.class))); + body.invoke("append").arg(JExpr._null()).arg(buffer).arg(toStringStrategy); + body._return(buffer.invoke("toString")); + return object$toString; } @@ -146,90 +143,92 @@ protected void processClassOutline(ClassOutline classOutline) { final JCodeModel codeModel = theClass.owner(); final JMethod toString$append = theClass.method(JMod.PUBLIC, codeModel.ref(StringBuilder.class), "append"); - toString$append.annotate(Override.class); - { - - final JVar locator = toString$append.param(ObjectLocator.class, - "locator"); - final JVar buffer = toString$append.param(StringBuilder.class, - "buffer"); - final JVar toStringStrategy = toString$append.param( - ToStringStrategy2.class, "strategy"); - - final JBlock body = toString$append.body(); - - body.invoke(toStringStrategy, "appendStart").arg(locator) - .arg(JExpr._this()).arg(buffer); - body.invoke("appendFields").arg(locator).arg(buffer) - .arg(toStringStrategy); - body.invoke(toStringStrategy, "appendEnd").arg(locator) - .arg(JExpr._this()).arg(buffer); - body._return(buffer); - } + toString$append.annotate(Override.class); // DEMATIC + + final JVar locator = toString$append.param(ObjectLocator.class, "locator"); + final JVar buffer = toString$append.param(StringBuilder.class, "buffer"); + final JVar toStringStrategy = toString$append.param( + ToStringStrategy2.class, "strategy2"); + + final JBlock body = toString$append.body(); + + body.invoke(toStringStrategy, "appendStart").arg(locator) + .arg(JExpr._this()).arg(buffer); + body.invoke("appendFields").arg(locator).arg(buffer) + .arg(toStringStrategy); + body.invoke(toStringStrategy, "appendEnd").arg(locator) + .arg(JExpr._this()).arg(buffer); + body._return(buffer); + return toString$append; } - protected JMethod generateToString$appendFields(ClassOutline classOutline, - final JDefinedClass theClass) { + protected JMethod generateToString$appendFields(ClassOutline classOutline, final JDefinedClass theClass) { final JCodeModel codeModel = theClass.owner(); final JMethod toString$appendFields = theClass.method(JMod.PUBLIC, codeModel.ref(StringBuilder.class), "appendFields"); - toString$appendFields.annotate(Override.class); - { - final JVar locator = toString$appendFields.param( - ObjectLocator.class, "locator"); - final JVar buffer = toString$appendFields.param( - StringBuilder.class, "buffer"); - final JVar toStringStrategy = toString$appendFields.param( - ToStringStrategy2.class, "strategy"); - final JBlock body = toString$appendFields.body(); - - final Boolean superClassImplementsToString = StrategyClassUtils - .superClassImplements(classOutline, ignoring, - ToString2.class); - - if (superClassImplementsToString == null) { - // No superclass - } else if (superClassImplementsToString.booleanValue()) { - body.invoke(JExpr._super(), "appendFields").arg(locator) - .arg(buffer).arg(toStringStrategy); - } else { - // Superclass does not implement ToString - } + toString$appendFields.annotate(Override.class); // DEMATIC + + final JVar locator = toString$appendFields.param( + ObjectLocator.class, "locator"); + final JVar buffer = toString$appendFields.param( + StringBuilder.class, "buffer"); + final JVar toStringStrategy = toString$appendFields.param( + ToStringStrategy2.class, "strategy2"); + final JBlock body = toString$appendFields.body(); + + final Boolean superClassImplementsToString = StrategyClassUtils + .superClassImplements(classOutline, ignoring, + ToString2.class); + + if (superClassImplementsToString == null) { + // No superclass + } else if (superClassImplementsToString.booleanValue()) { + body.invoke(JExpr._super(), "appendFields").arg(locator) + .arg(buffer).arg(toStringStrategy); + } else { + // Superclass does not implement ToString + } - final FieldOutline[] declaredFields = FieldOutlineUtils.filter( - classOutline.getDeclaredFields(), getIgnoring()); - - if (declaredFields.length > 0) { - - for (final FieldOutline fieldOutline : declaredFields) { - final JBlock block = body.block(); - final FieldAccessorEx fieldAccessor = getFieldAccessorFactory() - .createFieldAccessor(fieldOutline, JExpr._this()); - final JVar theValue = block.decl( - fieldAccessor.getType(), - "the" - + fieldOutline.getPropertyInfo().getName( - true)); - - final JExpression valueIsSet = (fieldAccessor.isAlwaysSet() || fieldAccessor - .hasSetValue() == null) ? JExpr.TRUE - : fieldAccessor.hasSetValue(); - - fieldAccessor.toRawValue(block, theValue); - - block.invoke(toStringStrategy, "appendField") - .arg(locator) - .arg(JExpr._this()) - .arg(JExpr.lit(fieldOutline.getPropertyInfo() - .getName(false))).arg(buffer).arg(theValue) - .arg(valueIsSet); - } + final FieldOutline[] declaredFields = FieldOutlineUtils.filter( + classOutline.getDeclaredFields(), getIgnoring()); + + if (declaredFields.length > 0) { + + for (final FieldOutline fieldOutline : declaredFields) { + final JBlock block = body; //DEMATIC + final FieldAccessorEx fieldAccessor = getFieldAccessorFactory().createFieldAccessor(fieldOutline, JExpr._this()); + + //final JVar theValue = block.decl(fieldAccessor.getType(),"the"+ fieldOutline.getPropertyInfo().getName(true)); + //fieldAccessor.toRawValue(block, theValue); + + String propertyName = fieldOutline.getPropertyInfo().getName(true); + final JVar theValue = block.decl(fieldAccessor.getType(), "the" + propertyName,JExpr._this().invoke(createMethodName(fieldOutline))); // DEMATIC + + final JExpression valueIsSet = (fieldAccessor.isAlwaysSet() || fieldAccessor + .hasSetValue() == null) ? JExpr.TRUE + : fieldAccessor.hasSetValue(); + + block.invoke(toStringStrategy, "appendField") + .arg(locator) + .arg(JExpr._this()) + .arg(JExpr.lit(fieldOutline.getPropertyInfo() + .getName(false))).arg(buffer).arg(theValue) + .arg(valueIsSet); } - body._return(buffer); } + body._return(buffer); return toString$appendFields; } + + private String createMethodName(FieldOutline fieldOutline) { + String name = fieldOutline.getPropertyInfo().getName(true); + String type = fieldOutline.getRawType().name(); + if (type.toLowerCase().equals("boolean")) { + return "is" + name; + } + return "get" + name; + } } \ No newline at end of file From af523152cdcafa6e927e72a7f86d94188e98008b Mon Sep 17 00:00:00 2001 From: cstenkes Date: Sat, 9 Feb 2019 07:29:18 +0100 Subject: [PATCH 6/6] fixing warnings on primitive types - where no cast is necessary we will not cast --- .../HashCodeCodeGenerationImplementor.java | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/HashCodeCodeGenerationImplementor.java b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/HashCodeCodeGenerationImplementor.java index 572be117..2c156e05 100644 --- a/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/HashCodeCodeGenerationImplementor.java +++ b/basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simplehashcode/HashCodeCodeGenerationImplementor.java @@ -35,6 +35,15 @@ private void ifHasSetValueAssignPlusValueCastedToInt( true); } + //DEMATIC + private void ifHasSetValueAssignPlusValue( + HashCodeArguments arguments, JBlock block, boolean isAlwaysSet) { + ifHasSetValueAssignPlusValueHashCode(arguments, block, + arguments.value(), isAlwaysSet, + true); + } + + @Override public void onArray(JBlock block, boolean isAlwaysSet, HashCodeArguments arguments) { @@ -57,7 +66,7 @@ public void onBoolean(HashCodeArguments arguments, JBlock block, @Override public void onByte(HashCodeArguments arguments, JBlock block, boolean isAlwaysSet) { - ifHasSetValueAssignPlusValueCastedToInt(arguments, block, isAlwaysSet); + ifHasSetValueAssignPlusValue(arguments, block, isAlwaysSet); //DEMATIC } @Override @@ -111,7 +120,7 @@ public void onLong(HashCodeArguments arguments, JBlock block, @Override public void onShort(HashCodeArguments arguments, JBlock block, boolean isAlwaysSet) { - ifHasSetValueAssignPlusValueCastedToInt(arguments, block, isAlwaysSet); + ifHasSetValueAssignPlusValue(arguments, block, isAlwaysSet); //DEMATIC } @Override