diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java index 7cb9048f..f1415d52 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java @@ -33,6 +33,9 @@ import org.slf4j.LoggerFactory; public class DynamicCodeGenBase implements Constants { + private static Logger LOG = LoggerFactory + .getLogger(DynamicCodeGenBase.class); + public static interface NullChecker { void setNullCheck(boolean nullCheck); } @@ -58,9 +61,6 @@ public class DynamicCodeGenBase implements Constants { } } - private static Logger LOG = LoggerFactory - .getLogger(DynamicCodeGenBase.class); - private static AtomicInteger COUNTER = new AtomicInteger(0); protected static int inc() { @@ -74,80 +74,58 @@ public class DynamicCodeGenBase implements Constants { } protected void checkTypeValidation(Class type) { - DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: " - + type.getName()); + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "Fatal error: %s", new Object[] { type.getName() })); LOG.error(e.getMessage(), e); throw e; } - protected void throwTypeValidationException(Class origClass, - String message) throws DynamicCodeGenException { - DynamicCodeGenException e = new DynamicCodeGenException(message + ": " - + origClass.getName()); + protected void throwTypeValidationException(Class type, String message) + throws DynamicCodeGenException { + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "%s: %s", new Object[] { message, type.getName() })); LOG.error(e.getMessage(), e); throw e; } protected void checkDefaultConstructorValidation(Class type) { - DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: " - + type.getName()); + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "Fatal error: %s", new Object[] { type.getName() })); LOG.error(e.getMessage(), e); throw e; } protected void throwConstructorValidationException(Class origClass) { - DynamicCodeGenException e = new DynamicCodeGenException( - "it must have a public zero-argument constructor: " - + origClass.getName()); + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "it must have a public zero-argument constructor: %s", + new Object[] { origClass.getName() })); LOG.error(e.getMessage(), e); throw e; } - protected void throwFieldValidationException(Field f) { - DynamicCodeGenException e = new DynamicCodeGenException( - "it must be a public field: " + f.getName()); + protected void throwFieldValidationException(Field field) { + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "it must be a public field: %s", + new Object[] { field.getName() })); LOG.debug(e.getMessage(), e); throw e; } protected static void throwMethodValidationException(Method method, String message) throws DynamicCodeGenException { - DynamicCodeGenException e = new DynamicCodeGenException(message + ": " - + method.getName()); + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "%s: %s", new Object[] { message, method.getName() })); LOG.error(e.getMessage(), e); throw e; } protected CtClass makeClass(String name) throws NotFoundException { - DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: " - + name); + DynamicCodeGenException e = new DynamicCodeGenException(String.format( + "Fatal error: %s", new Object[] { name })); LOG.error(e.getMessage(), e); throw e; } - enum Color { - // TODO - RED, BLUE - } - - public static void main(String[] args) throws Exception { - // TODO - class Foo { - } - class Bar extends Foo { - } - Color c = Color.RED; - Color c1 = null; - - ClassPool pool = ClassPool.getDefault(); - CtClass barCtClass = pool.get(Bar.class.getName()); - CtClass sbarCtClass = barCtClass.getSuperclass(); - System.out.println("bar: " + sbarCtClass.getName()); - CtClass fooCtClass = pool.get(Foo.class.getName()); - CtClass sfooCtClass = fooCtClass.getSuperclass(); - System.out.println("foo: " + sfooCtClass.getName()); - } - protected void setSuperclass(CtClass newCtClass, Class superClass) throws NotFoundException, CannotCompileException { // check the specified super class diff --git a/java/src/main/java/org/msgpack/util/codegen/FieldOption.java b/java/src/main/java/org/msgpack/util/codegen/FieldOption.java new file mode 100644 index 00000000..723a765a --- /dev/null +++ b/java/src/main/java/org/msgpack/util/codegen/FieldOption.java @@ -0,0 +1,10 @@ +package org.msgpack.util.codegen; + +import org.msgpack.Template; + +public class FieldOption { + + public String name; + + public Template tmpl; +} diff --git a/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java b/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java index 40fed226..2e6ea58f 100644 --- a/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java +++ b/java/src/test/java/org/msgpack/util/codegen/TestPackConvert.java @@ -2,6 +2,7 @@ package org.msgpack.util.codegen; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; +import java.io.IOException; import java.math.BigInteger; import java.util.ArrayList; import java.util.HashMap; @@ -15,8 +16,11 @@ import org.junit.Test; import org.msgpack.CustomConverter; import org.msgpack.CustomPacker; import org.msgpack.CustomUnpacker; +import org.msgpack.MessageConvertable; import org.msgpack.MessagePackObject; +import org.msgpack.MessagePackable; import org.msgpack.MessagePacker; +import org.msgpack.MessageTypeException; import org.msgpack.Packer; import org.msgpack.Template; import org.msgpack.Unpacker; @@ -1007,4 +1011,121 @@ public class TestPackConvert extends TestCase { public SampleSuperClass() { } } + + //@Test + public void XtestMessagePackableUnpackableClass00() throws Exception { + BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass(); + MessagePackableConvertableClass src1 = new MessagePackableConvertableClass(); + List src2 = new ArrayList(); + src1.f0 = 0; + src1.f1 = 1; + src.f0 = src1; + src.f1 = 1; + src2.add(src1); + src.f2 = src2; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = DynamicPacker + .create(BaseMessagePackableConvertableClass.class); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = DynamicTemplate + .create(BaseMessagePackableConvertableClass.class); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl + .convert(mpo); + assertEquals(src.f0.f0, dst.f0.f0); + assertEquals(src.f0.f1, dst.f0.f1); + assertEquals(src.f1, dst.f1); + assertEquals(src.f2.size(), dst.f2.size()); + assertEquals(src.f2.get(0).f0, dst.f2.get(0).f0); + assertEquals(src.f2.get(0).f1, dst.f2.get(0).f1); + assertFalse(it.hasNext()); + } + + //@Test + public void XtestMessagePackableUnpackableClass01() throws Exception { + BaseMessagePackableConvertableClass src = new BaseMessagePackableConvertableClass(); + src.f0 = null; + src.f1 = 1; + src.f2 = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = DynamicPacker + .create(BaseMessagePackableConvertableClass.class); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = DynamicTemplate + .create(BaseMessagePackableConvertableClass.class); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl + .convert(mpo); + assertEquals(src.f0, dst.f0); + assertEquals(src.f1, dst.f1); + assertEquals(src.f2, dst.f2); + assertFalse(it.hasNext()); + } + + //@Test + public void XtestMessagePackableUnpackableClass02() throws Exception { + BaseMessagePackableConvertableClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = DynamicPacker + .create(BaseMessagePackableConvertableClass.class); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = DynamicTemplate + .create(BaseMessagePackableConvertableClass.class); + Unpacker pac = new Unpacker(in); + Iterator it = pac.iterator(); + assertTrue(it.hasNext()); + MessagePackObject mpo = it.next(); + BaseMessagePackableConvertableClass dst = (BaseMessagePackableConvertableClass) tmpl + .convert(mpo); + assertEquals(src, dst); + assertFalse(it.hasNext()); + } + + public static class BaseMessagePackableConvertableClass { + public MessagePackableConvertableClass f0; + + public int f1; + + public List f2; + + public BaseMessagePackableConvertableClass() { + } + } + + public static class MessagePackableConvertableClass implements + MessagePackable, MessageConvertable { + + public int f0; + + public int f1; + + public MessagePackableConvertableClass() { + } + + @Override + public void messagePack(Packer packer) throws IOException { + packer.pack(f0); + packer.pack(f1); + } + + @Override + public void messageConvert(MessagePackObject obj) + throws MessageTypeException { + if (obj.isNil()) { + return; + } + MessagePackObject[] objs = obj.asArray(); + f0 = objs[0].asInt(); + f1 = objs[1].asInt(); + } + } } diff --git a/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java b/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java index 3222bec8..dc56b6c7 100644 --- a/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java +++ b/java/src/test/java/org/msgpack/util/codegen/TestPackUnpack.java @@ -2,6 +2,7 @@ package org.msgpack.util.codegen; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; +import java.io.IOException; import java.math.BigInteger; import java.util.ArrayList; import java.util.HashMap; @@ -13,7 +14,10 @@ import org.junit.Test; import org.msgpack.CustomConverter; import org.msgpack.CustomPacker; import org.msgpack.CustomUnpacker; +import org.msgpack.MessagePackable; import org.msgpack.MessagePacker; +import org.msgpack.MessageTypeException; +import org.msgpack.MessageUnpackable; import org.msgpack.Packer; import org.msgpack.Template; import org.msgpack.Unpacker; @@ -885,4 +889,104 @@ public class TestPackUnpack extends TestCase { public SampleSuperClass() { } } + + //@Test + public void XtestMessagePackableUnpackableClass00() throws Exception { + BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass(); + MessagePackableUnpackableClass src1 = new MessagePackableUnpackableClass(); + List src2 = new ArrayList(); + src1.f0 = 0; + src1.f1 = 1; + src.f0 = src1; + src.f1 = 1; + src2.add(src1); + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = DynamicPacker + .create(BaseMessagePackableUnpackableClass.class); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = DynamicTemplate + .create(BaseMessagePackableUnpackableClass.class); + BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl + .unpack(new Unpacker(in)); + assertEquals(src.f0.f0, dst.f0.f0); + assertEquals(src.f0.f1, dst.f0.f1); + assertEquals(src.f1, dst.f1); + assertEquals(src.f2.size(), dst.f2.size()); + assertEquals(src.f2.get(0).f0, dst.f2.get(0).f0); + assertEquals(src.f2.get(0).f1, dst.f2.get(0).f1); + } + + //@Test + public void XtestMessagePackableUnpackableClass01() throws Exception { + BaseMessagePackableUnpackableClass src = new BaseMessagePackableUnpackableClass(); + src.f0 = null; + src.f1 = 1; + src.f2 = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = DynamicPacker + .create(BaseMessagePackableUnpackableClass.class); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = DynamicTemplate + .create(BaseMessagePackableUnpackableClass.class); + BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl + .unpack(new Unpacker(in)); + assertEquals(src.f0, dst.f0); + assertEquals(src.f1, dst.f1); + assertEquals(src.f2, dst.f2); + } + + //@Test + public void XtestMessagePackableUnpackableClass02() throws Exception { + BaseMessagePackableUnpackableClass src = null; + ByteArrayOutputStream out = new ByteArrayOutputStream(); + MessagePacker packer = DynamicPacker + .create(BaseMessagePackableUnpackableClass.class); + packer.pack(new Packer(out), src); + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + Template tmpl = DynamicTemplate + .create(BaseMessagePackableUnpackableClass.class); + BaseMessagePackableUnpackableClass dst = (BaseMessagePackableUnpackableClass) tmpl + .unpack(new Unpacker(in)); + assertEquals(src, dst); + } + + public static class BaseMessagePackableUnpackableClass { + public MessagePackableUnpackableClass f0; + + public int f1; + + public List f2; + + public BaseMessagePackableUnpackableClass() { + } + } + + public static class MessagePackableUnpackableClass implements + MessagePackable, MessageUnpackable { + + public int f0; + + public int f1; + + public MessagePackableUnpackableClass() { + } + + @Override + public void messagePack(Packer packer) throws IOException { + packer.pack(f0); + packer.pack(f1); + } + + @Override + public void messageUnpack(Unpacker unpacker) throws IOException, + MessageTypeException { + if (unpacker.tryUnpackNull()) { + return; + } + f0 = unpacker.unpackInt(); + f1 = unpacker.unpackInt(); + } + } }