Issue highsource#11. Large refactoring, using the bridge pattern to s…

…eparate code

generation abstraction and implementor.

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/AbstractCodeGenerator.java

@@ -0,0 +1,32 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import org.apache.commons.lang3.Validate;
+
+import com.sun.codemodel.JCodeModel;
+
+public abstract class AbstractCodeGenerator<A extends Arguments> implements
+		CodeGenerator<A> {
+
+	private final CodeGenerator<A> codeGenerator;
+	private final CodeGenerationImplementor<A> implementor;
+	private final JCodeModel codeModel;
+
+	public AbstractCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		this.codeGenerator = Validate.notNull(codeGenerator);
+		this.implementor = Validate.notNull(implementor);
+		this.codeModel = implementor.getCodeModel();
+	}
+
+	public CodeGenerationImplementor<A> getImplementor() {
+		return implementor;
+	}
+
+	public CodeGenerator<A> getCodeGeneratorFactory() {
+		return codeGenerator;
+	}
+
+	public JCodeModel getCodeModel() {
+		return codeModel;
+	}
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/Arguments.java

@@ -0,0 +1,5 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+public interface Arguments {
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/ArrayCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class ArrayCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public ArrayCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onArray(block, isAlwaysSet, arguments);
+	}
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/BooleanCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class BooleanCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public BooleanCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onBoolean(arguments, block, isAlwaysSet);
+	}
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/ByteCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class ByteCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public ByteCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onByte(arguments, block, isAlwaysSet);
+	}
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/CharCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class CharCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public CharCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onChar(arguments, block, isAlwaysSet);
+	}
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/CodeGenerationAbstraction.java

@@ -0,0 +1,108 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import javax.xml.bind.JAXBElement;
+
+import org.apache.commons.lang3.Validate;
+import org.jvnet.jaxb2_commons.codemodel.JCMType;
+import org.jvnet.jaxb2_commons.codemodel.JCMTypeFactory;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JCodeModel;
+import com.sun.codemodel.JType;
+
+public class CodeGenerationAbstraction<A extends Arguments> implements
+		CodeGenerator<A> {
+
+	private final JCodeModel codeModel;
+	private final JCMTypeFactory typeFactory;
+	// Known code generators
+	private final Map<JCMType<?>, CodeGenerator<A>> codeGenerators = new LinkedHashMap<JCMType<?>, CodeGenerator<A>>();
+	private final CodeGenerator<A> defaultCodeGenerator;
+
+	private final CodeGenerationImplementor<A> implementor;
+
+	public CodeGenerationAbstraction(CodeGenerationImplementor<A> generationImplementor) {
+
+		this.implementor = Validate.notNull(generationImplementor);
+		this.codeModel = generationImplementor.getCodeModel();
+		this.typeFactory = generationImplementor.getTypeFactory();
+
+		addCodeGenerator(this.codeModel.BOOLEAN, new BooleanCodeGenerator<A>(
+				this, this.implementor));
+		addCodeGenerator(this.codeModel.BYTE, new ByteCodeGenerator<A>(this,
+				this.implementor));
+		addCodeGenerator(this.codeModel.CHAR, new CharCodeGenerator<A>(this,
+				this.implementor));
+		addCodeGenerator(this.codeModel.DOUBLE, new DoubleCodeGenerator<A>(
+				this, this.implementor));
+		addCodeGenerator(this.codeModel.FLOAT, new FloatCodeGenerator<A>(this,
+				this.implementor));
+		addCodeGenerator(this.codeModel.LONG, new LongCodeGenerator<A>(this,
+				this.implementor));
+		addCodeGenerator(this.codeModel.INT, new IntCodeGenerator<A>(this,
+				this.implementor));
+		addCodeGenerator(this.codeModel.SHORT, new ShortCodeGenerator<A>(this,
+				this.implementor));
+
+		addCodeGenerator(this.codeModel.BOOLEAN.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.BYTE.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.SHORT.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.CHAR.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.INT.array(), new ArrayCodeGenerator<A>(
+				this, this.implementor));
+		addCodeGenerator(this.codeModel.FLOAT.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.LONG.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.DOUBLE.array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+		addCodeGenerator(this.codeModel.ref(Object.class).array(),
+				new ArrayCodeGenerator<A>(this, this.implementor));
+
+		addCodeGenerator(
+				this.codeModel.ref(JAXBElement.class).narrow(Object.class),
+				new JAXBElementCodeGenerator<A>(this, this.implementor));
+
+		addCodeGenerator(this.codeModel.ref(List.class).narrow(Object.class),
+				new ListCodeGenerator<A>(this, this.implementor));
+
+		addCodeGenerator(this.codeModel.ref(Object.class),
+				new ObjectCodeGenerator<A>(this, this.implementor));
+		defaultCodeGenerator = new ObjectCodeGenerator<A>(this,
+				this.implementor);
+	}
+
+	private void addCodeGenerator(final JType type,
+			CodeGenerator<A> codeGenerator) {
+		final JCMType<?> factoredType = typeFactory.create(type);
+		this.codeGenerators.put(factoredType, codeGenerator);
+	}
+
+	private CodeGenerator<A> getCodeGenerator(JType type) {
+		final JCMType<JType> factoredType = typeFactory.create(type);
+		for (Entry<JCMType<?>, CodeGenerator<A>> entry : codeGenerators
+				.entrySet()) {
+			if (entry.getKey().matches(factoredType)) {
+				return entry.getValue();
+			}
+		}
+		return defaultCodeGenerator;
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getCodeGenerator(type).append(block, type, possibleTypes, isAlwaysSet,
+				arguments);
+	}
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/CodeGenerationImplementor.java

@@ -0,0 +1,55 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import org.jvnet.jaxb2_commons.codemodel.JCMTypeFactory;
+import org.jvnet.jaxb2_commons.codemodel.JConditionable;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JCodeModel;
+import com.sun.codemodel.JType;
+
+public interface CodeGenerationImplementor<A extends Arguments> {
+
+	public JCodeModel getCodeModel();
+
+	public JCMTypeFactory getTypeFactory();
+
+	public void onArray(JBlock block, boolean isAlwaysSet, A arguments);
+
+	public void onBoolean(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onByte(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onChar(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onDouble(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onFloat(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onInt(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onLong(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onShort(A arguments, JBlock block, boolean isAlwaysSet);
+
+	public void onObject(A arguments, JBlock block, boolean isAlwaysSet);
+
+	// (JBlock block, JType type, Collection<JType> possibleTypes,
+	// boolean isAlwaysSet, A arguments)
+	public void onJAXBElement(CodeGenerator<A> codeGenerator, JBlock block,
+			JType valueType, Collection<JType> possibleValueTypes,
+			boolean isAlwaysSet, A arguments);
+
+	public void onList(CodeGenerator<A> codeGenerator, JBlock block,
+			JType elementType, Collection<JType> possibleElementTypes,
+			boolean isAlwaysSet, A arguments);
+
+	public void onIfArray(CodeGenerator<A> codeGeneratorFactory,
+			JConditionable _if, JType arrayType, A arguments);
+
+	public void onIfJAXBElement(CodeGenerator<A> codeGenerator,
+			JConditionable _if, JType jaxbElementType,
+			Collection<JType> possibleJAXBElementTypes, A arguments);
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/CodeGenerator.java

@@ -0,0 +1,12 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public interface CodeGenerator<A extends Arguments> {
+
+	public void append(JBlock block, JType type, Collection<JType> possibleTypes,
+			boolean isAlwaysSet, A arguments);
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/DoubleCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class DoubleCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public DoubleCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onDouble(arguments, block, isAlwaysSet);
+	}
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/FloatCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class FloatCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public FloatCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onShort(arguments, block, isAlwaysSet);
+	}
+
+}

basic/src/main/java/org/jvnet/jaxb2_commons/plugin/simple/codegeneration/IntCodeGenerator.java

@@ -0,0 +1,22 @@
+package org.jvnet.jaxb2_commons.plugin.simple.codegeneration;
+
+import java.util.Collection;
+
+import com.sun.codemodel.JBlock;
+import com.sun.codemodel.JType;
+
+public class IntCodeGenerator<A extends Arguments> extends
+		AbstractCodeGenerator<A> {
+
+	public IntCodeGenerator(CodeGenerator<A> codeGenerator,
+			CodeGenerationImplementor<A> implementor) {
+		super(codeGenerator, implementor);
+	}
+
+	@Override
+	public void append(JBlock block, JType type,
+			Collection<JType> possibleTypes, boolean isAlwaysSet, A arguments) {
+		getImplementor().onInt(arguments, block, isAlwaysSet);
+	}
+
+}