diff --git a/java/src/main/java/org/msgpack/MessagePacker.java b/java/src/main/java/org/msgpack/MessagePacker.java index 05d4de5d..e5d387ee 100644 --- a/java/src/main/java/org/msgpack/MessagePacker.java +++ b/java/src/main/java/org/msgpack/MessagePacker.java @@ -20,6 +20,6 @@ package org.msgpack; import java.io.IOException; public interface MessagePacker { - public void pack(Packer pk, Object target) throws IOException; + void pack(Packer pk, Object target) throws IOException; } diff --git a/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java b/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java new file mode 100644 index 00000000..081b28c0 --- /dev/null +++ b/java/src/main/java/org/msgpack/annotation/MessagePackOptional.java @@ -0,0 +1,12 @@ +package org.msgpack.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.CLASS) +public @interface MessagePackOptional { + int value() default -1; +} \ No newline at end of file diff --git a/java/src/main/java/org/msgpack/annotation/MessagePackRequired.java b/java/src/main/java/org/msgpack/annotation/MessagePackRequired.java new file mode 100644 index 00000000..e268c4f5 --- /dev/null +++ b/java/src/main/java/org/msgpack/annotation/MessagePackRequired.java @@ -0,0 +1,12 @@ +package org.msgpack.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.CLASS) +public @interface MessagePackRequired { + int value() default -1; +} \ No newline at end of file diff --git a/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java b/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java index f675f815..e568a762 100644 --- a/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java +++ b/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java @@ -98,10 +98,8 @@ public interface BasicConstants { String METHOD_NAME_NEXT = "next"; - String METHOD_NAME_MSGPACK = "messagePack"; - - String METHOD_NAME_MSGUNPACK = "messageUnpack"; - + String METHOD_NAME_CONVERT = "convert"; + String METHOD_NAME_MSGCONVERT = "messageConvert"; String METHOD_NAME_PACK = "pack"; diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java index bd010eac..9193b98f 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java @@ -8,6 +8,7 @@ import java.lang.reflect.ParameterizedType; import java.math.BigInteger; import java.util.ArrayList; import java.util.HashMap; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; @@ -21,6 +22,7 @@ import javassist.CtNewConstructor; import javassist.CtNewMethod; import javassist.NotFoundException; +import org.msgpack.MessageConvertable; import org.msgpack.MessagePackObject; import org.msgpack.MessagePacker; import org.msgpack.MessageTypeException; @@ -204,6 +206,7 @@ public class DynamicCodeGen extends DynamicCodeGenBase implements Constants { private void addPackMethod(CtClass packerCtClass, Class c, Field[] fs) throws CannotCompileException, NotFoundException { + // void pack(Packer pk, Object target) throws IOException; StringBuilder sb = new StringBuilder(); StringBuilder bsb = new StringBuilder(); insertPackMethodBody(bsb, c, fs); @@ -211,7 +214,7 @@ public class DynamicCodeGen extends DynamicCodeGenBase implements Constants { Packer.class, Object.class }, new String[] { VARIABLE_NAME_PK, VARIABLE_NAME_OBJECT }, new Class[] { IOException.class }, bsb .toString()); - System.out.println("pack method: " + sb.toString()); + // System.out.println("pack method: " + sb.toString()); CtMethod newCtMethod = CtNewMethod.make(sb.toString(), packerCtClass); packerCtClass.addMethod(newCtMethod); } @@ -226,17 +229,15 @@ public class DynamicCodeGen extends DynamicCodeGenBase implements Constants { new String[] { new Integer(fs.length).toString() }); insertSemicolon(sb); for (Field f : fs) { - insertCodeOfPackCall(sb, f); + insertCodeOfPackMethodCall(sb, f); } } - private void insertCodeOfPackCall(StringBuilder sb, Field field) { - StringBuilder aname = new StringBuilder(); - aname.append(VARIABLE_NAME_TARGET); - aname.append(CHAR_NAME_DOT); - aname.append(field.getName()); + private void insertCodeOfPackMethodCall(StringBuilder sb, Field field) { + StringBuilder fa = new StringBuilder(); + insertFieldAccess(fa, VARIABLE_NAME_TARGET, field.getName()); insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_PACK, - new String[] { aname.toString() }); + new String[] { fa.toString() }); insertSemicolon(sb); } @@ -251,7 +252,7 @@ public class DynamicCodeGen extends DynamicCodeGenBase implements Constants { new String[] { VARIABLE_NAME_PK }, new Class[] { MessageTypeException.class, IOException.class }, bsb .toString()); - System.out.println("unpack method: " + sb.toString()); + // System.out.println("unpack method: " + sb.toString()); CtMethod newCtMethod = CtNewMethod.make(sb.toString(), unpackerCtClass); unpackerCtClass.addMethod(newCtMethod); } @@ -326,6 +327,7 @@ public class DynamicCodeGen extends DynamicCodeGenBase implements Constants { Field f, Class c) { if (f != null) { sb.append(VARIABLE_NAME_TARGET); + sb.append(CHAR_NAME_DOT); sb.append(f.getName()); sb.append(CHAR_NAME_SPACE); sb.append(CHAR_NAME_EQUAL); @@ -547,10 +549,501 @@ public class DynamicCodeGen extends DynamicCodeGenBase implements Constants { sb.append(CHAR_NAME_SPACE); } - private void addConvertMethod(CtClass tmplCtClass, Class c, Field[] fs) + public void addConvertMethod(CtClass tmplCtClass, Class c, Field[] fs) throws CannotCompileException, NotFoundException { // Object convert(MessagePackObject from) throws MessageTypeException; - // FIXME + StringBuilder sb = new StringBuilder(); + StringBuilder bsb = new StringBuilder(); + insertConvertMethodBody(bsb, c, fs); + addPublicMethodDecl(sb, METHOD_NAME_CONVERT, Object.class, + new Class[] { MessagePackObject.class }, + new String[] { VARIABLE_NAME_MPO }, + new Class[] { MessageTypeException.class }, bsb.toString()); + // System.out.println("convert method: " + sb.toString()); + CtMethod newCtMethod = CtNewMethod.make(sb.toString(), tmplCtClass); + tmplCtClass.addMethod(newCtMethod); + } + + private void insertConvertMethodBody(StringBuilder sb, Class c, + Field[] fields) throws CannotCompileException { + insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET); + StringBuilder mc = new StringBuilder(); + insertDefaultConsCall(mc, c); + insertValueInsertion(sb, mc.toString()); + insertSemicolon(sb); + insertCodeOfMessagePackObjectArrayGet(sb); + insertCodeOfConvertMethodCalls(sb, fields); + insertReturnStat(sb, VARIABLE_NAME_TARGET); + insertSemicolon(sb); + } + + private void insertCodeOfMessagePackObjectArrayGet(StringBuilder sb) { + // MessagePackObject[] ary = obj.asArray(); + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_ARRAY); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_MPO); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_ASARRAY); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + } + + private void insertCodeOfConvertMethodCalls(StringBuilder sb, Field[] fields) { + for (int i = 0; i < fields.length; ++i) { + insertCodeOfMessageConvertCall(sb, fields[i], fields[i].getType(), + i, null); + } + } + + private void insertCodeOfMessageConvertCall(StringBuilder sb, Field f, + Class c, int i, String v) { + if (c.isPrimitive()) { // primitive type + insertCodeOfConvertMethodCallForPrimTypes(sb, f, c, i, v); + } else { // reference type + if (c.equals(Boolean.class) || c.equals(Byte.class) + || c.equals(Short.class) || c.equals(Integer.class) + || c.equals(Float.class) || c.equals(Long.class) + || c.equals(Double.class)) { + // wrapper type + insertCodeOfMessageConvertCallForWrapTypes(sb, f, c, i, v); + } else if (c.equals(String.class) || c.equals(byte[].class) + || c.equals(BigInteger.class)) { + insertCodeOfConvertMethodCallForPrimTypes(sb, f, c, i, v); + } else if (List.class.isAssignableFrom(c)) { + insertCodeOfMessageConvertCallForList(sb, f, c, i); + } else if (Map.class.isAssignableFrom(c)) { + insertCodeOfMessageConvertCallForMap(sb, f, c, i); + } else if (MessageConvertable.class.isAssignableFrom(c)) { + insertCodeOfMessageConvertCallForMsgConvtblType(sb, f, c, i); + } else { + throw new MessageTypeException("Type error: " + c.getName()); + } + } + } + + // + // private void insertCodeOfMessageConvertCallForEnhancedType( + // StringBuilder sb, Field f, Class c, int i) { + // c = getCache(c.getName()); + // insertCodeOfMessageConvertCallForMsgConvtblType(sb, f, c, i); + // } + + private void insertCodeOfMessageConvertCallForMsgConvtblType( + StringBuilder sb, Field f, Class c, int i) { + // if (fi == null) { fi = new Foo_$$_Enhanced(); } + sb.append(Constants.KEYWORD_IF); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.KEYWORD_NULL); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.KEYWORD_NEW); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(c.getName()); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); + + // ((MessageConvertable)f_i).messageConvert(ary[i]); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(MessageConvertable.class.getName()); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_MSGCONVERT); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.VARIABLE_NAME_ARRAY); + sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(i); + sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + } + + private void insertCodeOfConvertMethodCallForPrimTypes(StringBuilder sb, + Field f, Class c, int i, String name) { + // target.f0 = objs[0].intValue(); + if (f != null) { + sb.append(Constants.VARIABLE_NAME_TARGET); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_ARRAY); + sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(i); + sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET); + } else { + sb.append(name); + } + sb.append(Constants.CHAR_NAME_DOT); + if (c.equals(boolean.class)) { + sb.append(Constants.METHOD_NAME_ASBOOLEAN); + } else if (c.equals(byte.class)) { + sb.append(Constants.METHOD_NAME_ASBYTE); + } else if (c.equals(short.class)) { + sb.append(Constants.METHOD_NAME_ASSHORT); + } else if (c.equals(int.class)) { + sb.append(Constants.METHOD_NAME_ASINT); + } else if (c.equals(float.class)) { + sb.append(Constants.METHOD_NAME_ASFLOAT); + } else if (c.equals(long.class)) { + sb.append(Constants.METHOD_NAME_ASLONG); + } else if (c.equals(double.class)) { + sb.append(Constants.METHOD_NAME_ASDOUBLE); + } else if (c.equals(String.class)) { + sb.append(Constants.METHOD_NAME_ASSTRING); + } else if (c.equals(byte[].class)) { + sb.append(Constants.METHOD_NAME_ASBYTEARRAY); + } else if (c.equals(BigInteger.class)) { + sb.append(Constants.METHOD_NAME_ASBIGINTEGER); + } else { + throw new MessageTypeException("Type error: " + c.getName()); + } + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + if (f != null) { + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + } + } + + private void insertCodeOfMessageConvertCallForWrapTypes(StringBuilder sb, + Field f, Class c, int i, String v) { + if (f != null) { + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + } + sb.append(Constants.KEYWORD_NEW); + sb.append(Constants.CHAR_NAME_SPACE); + if (c.equals(Boolean.class)) { + sb.append(Boolean.class.getName()); + } else if (c.equals(Byte.class)) { + sb.append(Byte.class.getName()); + } else if (c.equals(Short.class)) { + sb.append(Short.class.getName()); + } else if (c.equals(Integer.class)) { + sb.append(Integer.class.getName()); + } else if (c.equals(Float.class)) { + sb.append(Float.class.getName()); + } else if (c.equals(Long.class)) { + sb.append(Long.class.getName()); + } else if (c.equals(Double.class)) { + sb.append(Double.class.getName()); + } else { + throw new MessageTypeException("Type error: " + c.getName()); + } + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + if (f != null) { + sb.append(Constants.VARIABLE_NAME_ARRAY); + sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(i); + sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET); + } else { + sb.append(v); + } + sb.append(Constants.CHAR_NAME_DOT); + if (c.equals(Boolean.class)) { + sb.append(Constants.METHOD_NAME_ASBOOLEAN); + } else if (c.equals(Byte.class)) { + sb.append(Constants.METHOD_NAME_ASBYTE); + } else if (c.equals(Short.class)) { + sb.append(Constants.METHOD_NAME_ASSHORT); + } else if (c.equals(Integer.class)) { + sb.append(Constants.METHOD_NAME_ASINT); + } else if (c.equals(Float.class)) { + sb.append(Constants.METHOD_NAME_ASFLOAT); + } else if (c.equals(Long.class)) { + sb.append(Constants.METHOD_NAME_ASLONG); + } else if (c.equals(Double.class)) { + sb.append(Constants.METHOD_NAME_ASDOUBLE); + } else { + throw new MessageTypeException("Type error: " + c.getName()); + } + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + if (f != null) { + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + } + } + + private void insertCodeOfMessageConvertCallForList(StringBuilder sb, + Field field, Class type, int i) { + ParameterizedType generic = (ParameterizedType) field.getGenericType(); + Class genericType = (Class) generic.getActualTypeArguments()[0]; + + // List list = ary[i].asList(); + sb.append(List.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_LIST); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_ARRAY); + sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(i); + sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET); + sb.append(Constants.CHAR_NAME_DOT); + sb.append("asList"); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + // int size = list.size(); + sb.append(int.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_SIZE); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_LIST); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_SIZE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + // field initializer + sb.append(field.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.KEYWORD_NEW); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(ArrayList.class.getName()); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + // for loop + sb.append(Constants.KEYWORD_FOR); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(int.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_I); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(0); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_I); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LESSTHAN); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_SIZE); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_PLUS); + sb.append(Constants.CHAR_NAME_PLUS); + sb.append(Constants.VARIABLE_NAME_I); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SPACE); + + // block begin + sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_VAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.VARIABLE_NAME_LIST); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_GET); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.VARIABLE_NAME_I); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + sb.append(field.getName()); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_ADD); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + insertCodeOfMessageConvertCall(sb, null, genericType, -1, + Constants.VARIABLE_NAME_VAL); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + // block end + sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); + } + + private void insertCodeOfMessageConvertCallForMap(StringBuilder sb, + Field f, Class c, int i) { + ParameterizedType generic = (ParameterizedType) f.getGenericType(); + Class genericType0 = (Class) generic.getActualTypeArguments()[0]; + Class genericType1 = (Class) generic.getActualTypeArguments()[1]; + + // Map map = ary[i].asMap(); + sb.append(Map.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_MAP); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_ARRAY); + sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(i); + sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET); + sb.append(Constants.CHAR_NAME_DOT); + sb.append("asMap"); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + // int size = list.size(); + sb.append(int.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_SIZE); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_MAP); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_SIZE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + // field initializer + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.KEYWORD_NEW); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(HashMap.class.getName()); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + // for loop + sb.append(Constants.KEYWORD_FOR); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Iterator.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_ITER); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_MAP); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_KEYSET); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_ITERATOR); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_ITER); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_HASNEXT); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); + + // block map. + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_KEY); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.VARIABLE_NAME_ITER); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_NEXT); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.VARIABLE_NAME_VAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_EQUAL); + sb.append(Constants.CHAR_NAME_SPACE); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(MessagePackObject.class.getName()); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.VARIABLE_NAME_MAP); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_GET); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + sb.append(Constants.VARIABLE_NAME_KEY); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + sb.append(f.getName()); + sb.append(Constants.CHAR_NAME_DOT); + sb.append(Constants.METHOD_NAME_PUT); + sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); + insertCodeOfMessageConvertCall(sb, null, genericType0, -1, + Constants.VARIABLE_NAME_KEY); + sb.append(Constants.CHAR_NAME_COMMA); + sb.append(Constants.CHAR_NAME_SPACE); + insertCodeOfMessageConvertCall(sb, null, genericType1, -1, + Constants.VARIABLE_NAME_VAL); + sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); + sb.append(Constants.CHAR_NAME_SEMICOLON); + sb.append(Constants.CHAR_NAME_SPACE); + + sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACKET); + sb.append(Constants.CHAR_NAME_SPACE); } private Class createClass(CtClass packerCtClass) 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 1c907a23..9e10cf7c 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java @@ -15,8 +15,8 @@ public class DynamicCodeGenBase implements BasicConstants { sb.append(CHAR_NAME_SPACE); sb.append(name); } - - public void addPublicMethodDecl(StringBuilder sb, String mname, + + public void addPublicMethodDecl(StringBuilder sb, String mname, Class returnType, Class[] paramTypes, String[] anames, Class[] exceptTypes, String methodBody) { sb.append(KEYWORD_MODIFIER_PUBLIC); @@ -54,12 +54,14 @@ public class DynamicCodeGenBase implements BasicConstants { } public void insertSemicolon(StringBuilder sb) { + // ; sb.append(CHAR_NAME_SEMICOLON); sb.append(CHAR_NAME_SPACE); } public void insertLocalVariableDecl(StringBuilder sb, Class type, String name) { + // int lv sb.append(type.getName()); sb.append(CHAR_NAME_SPACE); sb.append(name); @@ -73,6 +75,13 @@ public class DynamicCodeGenBase implements BasicConstants { sb.append(expr); } + public void insertFieldAccess(StringBuilder sb, String target, String field) { + // target.field + sb.append(target); + sb.append(CHAR_NAME_DOT); + sb.append(field); + } + public void insertDefaultConsCall(StringBuilder sb, Class type) { // new tname() insertConsCall(sb, type, null); diff --git a/java/src/test/java/org/msgpack/util/TestDynamicCodeGenPackerTemplate.java b/java/src/test/java/org/msgpack/util/TestDynamicCodeGenPackerTemplate.java new file mode 100644 index 00000000..5b52c8ac --- /dev/null +++ b/java/src/test/java/org/msgpack/util/TestDynamicCodeGenPackerTemplate.java @@ -0,0 +1,77 @@ +package org.msgpack.util; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; + +import org.junit.Test; +import org.msgpack.CustomPacker; +import org.msgpack.MessagePacker; +import org.msgpack.Packer; +import org.msgpack.ReflectionTemplate; +import org.msgpack.Template; +import org.msgpack.Unpacker; +import org.msgpack.util.codegen.DynamicCodeGenPacker; +import org.msgpack.util.codegen.DynamicCodeGenTemplate; + +import static org.junit.Assert.*; + +public class TestDynamicCodeGenPackerTemplate { + + public static class StringFieldClass { + public String s1; + public String s2; + public StringFieldClass() { } + } + + @Test + public void testPackConvert() throws Exception { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + + MessagePacker packer = DynamicCodeGenPacker.create(StringFieldClass.class); + + StringFieldClass src = new StringFieldClass(); + + src.s1 = "kumofs"; + src.s2 = "frsyuki"; + + packer.pack(new Packer(out), src); + + Template tmpl = DynamicCodeGenTemplate.create(StringFieldClass.class); + + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + + Object obj = tmpl.unpack(new Unpacker(in)); + assertEquals(obj.getClass(), StringFieldClass.class); + + StringFieldClass dst = (StringFieldClass)obj; + assertEquals(src.s1, dst.s1); + assertEquals(src.s2, dst.s2); + } + + @Test + public void testPackConvert02() throws Exception { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + + CustomPacker.register(StringFieldClass.class, DynamicCodeGenPacker.create(StringFieldClass.class)); + + + StringFieldClass src = new StringFieldClass(); + + src.s1 = "kumofs"; + src.s2 = "frsyuki"; + + new Packer(out).pack(src); + + Template tmpl = ReflectionTemplate.create(StringFieldClass.class); + + ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); + + Object obj = tmpl.unpack(new Unpacker(in)); + assertEquals(obj.getClass(), StringFieldClass.class); + + StringFieldClass dst = (StringFieldClass)obj; + assertEquals(src.s1, dst.s1); + assertEquals(src.s2, dst.s2); + } +} + diff --git a/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPacker.java b/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPacker.java deleted file mode 100644 index 88515378..00000000 --- a/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPacker.java +++ /dev/null @@ -1,61 +0,0 @@ -package org.msgpack.util.codegen; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; - -import org.junit.Test; -import org.msgpack.MessagePacker; -import org.msgpack.MessageUnpacker; -import org.msgpack.Packer; -import org.msgpack.Template; -import org.msgpack.Unpacker; - -import junit.framework.TestCase; - -public class TestDynamicCodeGenPacker extends TestCase { - public static class StringFieldClass { - public String s1; - public String s2; - - public StringFieldClass() { - } - } - - @Test - public void testPackConvert01() throws Exception { - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker - .create(StringFieldClass.class); - MessageUnpacker unpacker = DynamicCodeGenUnpacker - .create(StringFieldClass.class); - - StringFieldClass src = new StringFieldClass(); - src.s1 = "muga"; - src.s2 = "nishizawa"; - packer.pack(new Packer(out), src); - - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - StringFieldClass dst = (StringFieldClass) new Unpacker(in) - .unpack(unpacker); - assertEquals(src.s1, dst.s1); - assertEquals(src.s2, dst.s2); - } - - @Test - public void testPackConvert02() throws Exception { - ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker - .create(StringFieldClass.class); - Template tmpl = DynamicCodeGenTemplate.create(StringFieldClass.class); - - StringFieldClass src = new StringFieldClass(); - src.s1 = "muga"; - src.s2 = "nishizawa"; - packer.pack(new Packer(out), src); - - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - StringFieldClass dst = (StringFieldClass) tmpl.unpack(new Unpacker(in)); - assertEquals(src.s1, dst.s1); - assertEquals(src.s2, dst.s2); - } -} diff --git a/java/src/test/java/org/msgpack/util/codegen/TestMessagePackUnpackable.java b/java/src/test/java/org/msgpack/util/codegen/TestMessagePackUnpackable.java deleted file mode 100644 index 7e0baccd..00000000 --- a/java/src/test/java/org/msgpack/util/codegen/TestMessagePackUnpackable.java +++ /dev/null @@ -1,703 +0,0 @@ -package org.msgpack.util.codegen; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.math.BigInteger; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -import junit.framework.TestCase; - -import org.junit.Test; -import org.msgpack.MessagePackObject; -import org.msgpack.MessageUnpackable; -import org.msgpack.Packer; -import org.msgpack.Unpacker; -import org.msgpack.util.codegen.MessagePackUnpackable; -import org.msgpack.util.codegen.PackUnpackUtil; -import org.msgpack.util.codegen.DynamicCodeGenException; - -public class TestMessagePackUnpackable extends TestCase { - - @Test - public void testPrimitiveTypeFields01() throws Exception { - PrimitiveTypeFieldsClass src = (PrimitiveTypeFieldsClass) PackUnpackUtil - .newEnhancedInstance(PrimitiveTypeFieldsClass.class); - src.f0 = (byte) 0; - src.f1 = 1; - src.f2 = 2; - src.f3 = 3; - src.f4 = 4; - src.f5 = 5; - src.f6 = false; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) PackUnpackUtil - .newEnhancedInstance(PrimitiveTypeFieldsClass.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertEquals(src.f0, dst.f0); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2, dst.f2); - assertEquals(src.f3, dst.f3); - assertEquals(src.f4, dst.f4); - assertEquals(src.f5, dst.f5); - assertEquals(src.f6, dst.f6); - } - - @Test - public void testPrimitiveTypeFields02() throws Exception { - PrimitiveTypeFieldsClass src = (PrimitiveTypeFieldsClass) PackUnpackUtil - .newEnhancedInstance(PrimitiveTypeFieldsClass.class); - src.f0 = (byte) 0; - src.f1 = 1; - src.f2 = 2; - src.f3 = 3; - src.f4 = 4; - src.f5 = 5; - src.f6 = false; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) PackUnpackUtil - .initEnhancedInstance(mpo, PrimitiveTypeFieldsClass.class); - assertEquals(src.f0, dst.f0); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2, dst.f2); - assertEquals(src.f3, dst.f3); - assertEquals(src.f4, dst.f4); - assertEquals(src.f5, dst.f5); - assertEquals(src.f6, dst.f6); - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class PrimitiveTypeFieldsClass { - public byte f0; - public short f1; - public int f2; - public long f3; - public float f4; - public double f5; - public boolean f6; - - public PrimitiveTypeFieldsClass() { - } - } - - @Test - public void testGeneralReferenceTypeFieldsClass01() throws Exception { - GeneralReferenceTypeFieldsClass src = (GeneralReferenceTypeFieldsClass) PackUnpackUtil - .newEnhancedInstance(GeneralReferenceTypeFieldsClass.class); - src.f0 = 0; - src.f1 = 1; - src.f2 = 2; - src.f3 = (long) 3; - src.f4 = (float) 4; - src.f5 = (double) 5; - src.f6 = false; - src.f7 = new BigInteger("7"); - src.f8 = "8"; - src.f9 = new byte[] { 0x01, 0x02 }; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) PackUnpackUtil - .newEnhancedInstance(GeneralReferenceTypeFieldsClass.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertEquals(src.f0, dst.f0); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2, dst.f2); - assertEquals(src.f3, dst.f3); - assertEquals(src.f4, dst.f4); - assertEquals(src.f5, dst.f5); - assertEquals(src.f6, dst.f6); - assertEquals(src.f7, dst.f7); - assertEquals(src.f8, dst.f8); - assertEquals(src.f9[0], dst.f9[0]); - assertEquals(src.f9[1], dst.f9[1]); - } - - @Test - public void testGeneralReferenceTypeFieldsClass02() throws Exception { - GeneralReferenceTypeFieldsClass src = (GeneralReferenceTypeFieldsClass) PackUnpackUtil - .newEnhancedInstance(GeneralReferenceTypeFieldsClass.class); - src.f0 = 0; - src.f1 = 1; - src.f2 = 2; - src.f3 = (long) 3; - src.f4 = (float) 4; - src.f5 = (double) 5; - src.f6 = false; - src.f7 = new BigInteger("7"); - src.f8 = "8"; - src.f9 = new byte[] { 0x01, 0x02 }; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) PackUnpackUtil - .initEnhancedInstance(mpo, - GeneralReferenceTypeFieldsClass.class); - assertEquals(src.f0, dst.f0); - assertEquals(src.f1, dst.f1); - assertEquals(src.f2, dst.f2); - assertEquals(src.f3, dst.f3); - assertEquals(src.f4, dst.f4); - assertEquals(src.f5, dst.f5); - assertEquals(src.f6, dst.f6); - assertEquals(src.f7, dst.f7); - assertEquals(src.f8, dst.f8); - assertEquals(src.f9[0], dst.f9[0]); - assertEquals(src.f9[1], dst.f9[1]); - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class GeneralReferenceTypeFieldsClass { - public Byte f0; - public Short f1; - public Integer f2; - public Long f3; - public Float f4; - public Double f5; - public Boolean f6; - public BigInteger f7; - public String f8; - public byte[] f9; - - public GeneralReferenceTypeFieldsClass() { - } - } - - public void testListTypes01() throws Exception { - SampleListTypes src = (SampleListTypes) PackUnpackUtil - .newEnhancedInstance(SampleListTypes.class); - src.f0 = new ArrayList(); - src.f1 = new ArrayList(); - src.f1.add(1); - src.f1.add(2); - src.f1.add(3); - src.f2 = new ArrayList(); - src.f2.add("e1"); - src.f2.add("e2"); - src.f2.add("e3"); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - SampleListTypes dst = (SampleListTypes) PackUnpackUtil - .newEnhancedInstance(SampleListTypes.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1.size(), dst.f1.size()); - for (int i = 0; i < src.f1.size(); ++i) { - assertEquals(src.f1.get(i), dst.f1.get(i)); - } - assertEquals(src.f2.size(), dst.f2.size()); - for (int i = 0; i < src.f2.size(); ++i) { - assertEquals(src.f2.get(i), dst.f2.get(i)); - } - } - - public void testListTypes02() throws Exception { - SampleListTypes src = (SampleListTypes) PackUnpackUtil - .newEnhancedInstance(SampleListTypes.class); - src.f0 = new ArrayList(); - src.f1 = new ArrayList(); - src.f1.add(1); - src.f1.add(2); - src.f1.add(3); - src.f2 = new ArrayList(); - src.f2.add("e1"); - src.f2.add("e2"); - src.f2.add("e3"); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - SampleListTypes dst = (SampleListTypes) PackUnpackUtil - .initEnhancedInstance(mpo, SampleListTypes.class); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1.size(), dst.f1.size()); - for (int i = 0; i < src.f1.size(); ++i) { - assertEquals(src.f1.get(i), dst.f1.get(i)); - } - assertEquals(src.f2.size(), dst.f2.size()); - for (int i = 0; i < src.f2.size(); ++i) { - assertEquals(src.f2.get(i), dst.f2.get(i)); - } - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class SampleListTypes { - public List f0; - public List f1; - public List f2; - - public SampleListTypes() { - } - } - - public void testMapTypes01() throws Exception { - SampleMapTypes src = (SampleMapTypes) PackUnpackUtil - .newEnhancedInstance(SampleMapTypes.class); - src.f0 = new HashMap(); - src.f1 = new HashMap(); - src.f1.put(1, 1); - src.f1.put(2, 2); - src.f1.put(3, 3); - src.f2 = new HashMap(); - src.f2.put("k1", 1); - src.f2.put("k2", 2); - src.f2.put("k3", 3); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - SampleMapTypes dst = (SampleMapTypes) PackUnpackUtil - .newEnhancedInstance(SampleMapTypes.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1.size(), dst.f1.size()); - Iterator srcf1 = src.f1.keySet().iterator(); - Iterator dstf1 = dst.f1.keySet().iterator(); - while (srcf1.hasNext()) { - Integer s1 = srcf1.next(); - Integer d1 = dstf1.next(); - assertEquals(s1, d1); - assertEquals(src.f1.get(s1), dst.f1.get(d1)); - } - assertEquals(src.f2.size(), dst.f2.size()); - Iterator srcf2 = src.f2.keySet().iterator(); - Iterator dstf2 = dst.f2.keySet().iterator(); - while (srcf2.hasNext()) { - String s2 = srcf2.next(); - String d2 = dstf2.next(); - assertEquals(s2, d2); - assertEquals(src.f2.get(s2), dst.f2.get(d2)); - } - } - - public void testMapTypes02() throws Exception { - SampleMapTypes src = (SampleMapTypes) PackUnpackUtil - .newEnhancedInstance(SampleMapTypes.class); - src.f0 = new HashMap(); - src.f1 = new HashMap(); - src.f1.put(1, 1); - src.f1.put(2, 2); - src.f1.put(3, 3); - src.f2 = new HashMap(); - src.f2.put("k1", 1); - src.f2.put("k2", 2); - src.f2.put("k3", 3); - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - SampleMapTypes dst = (SampleMapTypes) PackUnpackUtil - .initEnhancedInstance(mpo, SampleMapTypes.class); - assertEquals(src.f0.size(), dst.f0.size()); - assertEquals(src.f1.size(), dst.f1.size()); - Iterator srcf1 = src.f1.keySet().iterator(); - Iterator dstf1 = dst.f1.keySet().iterator(); - while (srcf1.hasNext()) { - Integer s1 = srcf1.next(); - Integer d1 = dstf1.next(); - assertEquals(s1, d1); - assertEquals(src.f1.get(s1), dst.f1.get(d1)); - } - assertEquals(src.f2.size(), dst.f2.size()); - Iterator srcf2 = src.f2.keySet().iterator(); - Iterator dstf2 = dst.f2.keySet().iterator(); - while (srcf2.hasNext()) { - String s2 = srcf2.next(); - String d2 = dstf2.next(); - assertEquals(s2, d2); - assertEquals(src.f2.get(s2), dst.f2.get(d2)); - } - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class SampleMapTypes { - public Map f0; - public Map f1; - public Map f2; - - public SampleMapTypes() { - } - } - - @Test - public void testDefaultConstructorModifiers() throws Exception { - try { - PackUnpackUtil.newEnhancedInstance(NoDefaultConstructorClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - try { - PackUnpackUtil - .newEnhancedInstance(PrivateDefaultConstructorClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - try { - PackUnpackUtil - .newEnhancedInstance(ProtectedDefaultConstructorClass.class); - assertTrue(true); - } catch (DynamicCodeGenException e) { - fail(); - } - assertTrue(true); - try { - PackUnpackUtil - .newEnhancedInstance(PackageDefaultConstructorClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - } - - @MessagePackUnpackable - public static class NoDefaultConstructorClass { - public NoDefaultConstructorClass(int i) { - } - } - - @MessagePackUnpackable - public static class PrivateDefaultConstructorClass { - private PrivateDefaultConstructorClass() { - } - } - - @MessagePackUnpackable - public static class ProtectedDefaultConstructorClass { - protected ProtectedDefaultConstructorClass() { - } - } - - @MessagePackUnpackable - public static class PackageDefaultConstructorClass { - PackageDefaultConstructorClass() { - } - } - - @Test - public void testClassModifiers() throws Exception { - try { - PackUnpackUtil.newEnhancedInstance(PrivateModifierClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - try { - PackUnpackUtil.newEnhancedInstance(ProtectedModifierClass.class); - assertTrue(true); - } catch (DynamicCodeGenException e) { - fail(); - } - assertTrue(true); - try { - PackUnpackUtil.newEnhancedInstance(PackageModifierClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - } - - @MessagePackUnpackable - private static class PrivateModifierClass { - } - - @MessagePackUnpackable - protected static class ProtectedModifierClass { - protected ProtectedModifierClass() { - } - } - - @MessagePackUnpackable - static class PackageModifierClass { - } - - @Test - public void testFinalClassAndAbstractClass() throws Exception { - try { - PackUnpackUtil.newEnhancedInstance(FinalModifierClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - try { - PackUnpackUtil.newEnhancedInstance(AbstractModifierClass.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - } - - @MessagePackUnpackable - public final static class FinalModifierClass { - } - - @MessagePackUnpackable - public abstract static class AbstractModifierClass { - } - - @Test - public void testInterfaceAndEnumType() throws Exception { - try { - PackUnpackUtil.newEnhancedInstance(SampleInterface.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - try { - PackUnpackUtil.newEnhancedInstance(SampleEnum.class); - fail(); - } catch (DynamicCodeGenException e) { - assertTrue(true); - } - assertTrue(true); - } - - @MessagePackUnpackable - public interface SampleInterface { - } - - @MessagePackUnpackable - public enum SampleEnum { - } - - @Test - public void testFieldModifiers01() throws Exception { - FieldModifiersClass src = (FieldModifiersClass) PackUnpackUtil - .newEnhancedInstance(FieldModifiersClass.class); - src.f0 = 0; - src.f2 = 2; - src.f3 = 3; - src.f4 = 4; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - FieldModifiersClass dst = (FieldModifiersClass) PackUnpackUtil - .newEnhancedInstance(FieldModifiersClass.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertTrue(src.f0 == dst.f0); - assertTrue(src.f1 == dst.f1); - assertTrue(src.f2 != dst.f2); - assertTrue(src.f3 == dst.f3); - assertTrue(src.f4 != dst.f4); - } - - @Test - public void testFieldModifiers02() throws Exception { - FieldModifiersClass src = (FieldModifiersClass) PackUnpackUtil - .newEnhancedInstance(FieldModifiersClass.class); - src.f0 = 0; - src.f2 = 2; - src.f3 = 3; - src.f4 = 4; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - FieldModifiersClass dst = (FieldModifiersClass) PackUnpackUtil - .initEnhancedInstance(mpo, FieldModifiersClass.class); - assertTrue(src.f0 == dst.f0); - assertTrue(src.f1 == dst.f1); - assertTrue(src.f2 != dst.f2); - assertTrue(src.f3 == dst.f3); - assertTrue(src.f4 != dst.f4); - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class FieldModifiersClass { - public int f0; - public final int f1 = 1; - private int f2; - protected int f3; - int f4; - - public FieldModifiersClass() { - } - } - - @Test - public void testNestedAnnotatedFieldClass01() throws Exception { - NestedClass src2 = (NestedClass) PackUnpackUtil - .newEnhancedInstance(NestedClass.class); - BaseClass src = (BaseClass) PackUnpackUtil - .newEnhancedInstance(BaseClass.class); - src.f0 = 0; - src2.f2 = 2; - src.f1 = src2; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - BaseClass dst = (BaseClass) PackUnpackUtil - .newEnhancedInstance(BaseClass.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertTrue(src.f0 == dst.f0); - assertTrue(src2.f2 == dst.f1.f2); - } - - @Test - public void testNestedAnnotatedFieldClass02() throws Exception { - NestedClass src2 = (NestedClass) PackUnpackUtil - .newEnhancedInstance(NestedClass.class); - BaseClass src = (BaseClass) PackUnpackUtil - .newEnhancedInstance(BaseClass.class); - src.f0 = 0; - src2.f2 = 2; - src.f1 = src2; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - BaseClass dst = (BaseClass) PackUnpackUtil.initEnhancedInstance(mpo, - BaseClass.class); - assertTrue(src.f0 == dst.f0); - assertTrue(src2.f2 == dst.f1.f2); - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class BaseClass { - public int f0; - public NestedClass f1; - - public BaseClass() { - } - } - - @MessagePackUnpackable - public static class NestedClass { - public int f2; - - public NestedClass() { - } - } - - @Test - public void testExtendedClass01() throws Exception { - SampleSubClass src = (SampleSubClass) PackUnpackUtil - .newEnhancedInstance(SampleSubClass.class); - src.f0 = 0; - src.f2 = 2; - src.f3 = 3; - src.f4 = 4; - src.f5 = 5; - src.f8 = 8; - src.f9 = 9; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - SampleSubClass dst = (SampleSubClass) PackUnpackUtil - .newEnhancedInstance(SampleSubClass.class); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - pac.unpack((MessageUnpackable) dst); - assertTrue(src.f0 == dst.f0); - assertTrue(src.f1 == dst.f1); - assertTrue(src.f2 != dst.f2); - assertTrue(src.f3 == dst.f3); - assertTrue(src.f4 != dst.f4); - assertTrue(src.f5 == dst.f5); - assertTrue(src.f6 == dst.f6); - assertTrue(src.f8 == dst.f8); - assertTrue(src.f9 != dst.f9); - } - - @Test - public void testExtendedClass02() throws Exception { - SampleSubClass src = (SampleSubClass) PackUnpackUtil - .newEnhancedInstance(SampleSubClass.class); - src.f0 = 0; - src.f2 = 2; - src.f3 = 3; - src.f4 = 4; - src.f5 = 5; - src.f8 = 8; - src.f9 = 9; - ByteArrayOutputStream out = new ByteArrayOutputStream(); - new Packer(out).pack(src); - ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Unpacker pac = new Unpacker(in); - Iterator it = pac.iterator(); - assertTrue(it.hasNext()); - MessagePackObject mpo = it.next(); - SampleSubClass dst = (SampleSubClass) PackUnpackUtil - .initEnhancedInstance(mpo, SampleSubClass.class); - assertTrue(src.f0 == dst.f0); - assertTrue(src.f1 == dst.f1); - assertTrue(src.f2 != dst.f2); - assertTrue(src.f3 == dst.f3); - assertTrue(src.f4 != dst.f4); - assertTrue(src.f5 == dst.f5); - assertTrue(src.f6 == dst.f6); - assertTrue(src.f8 == dst.f8); - assertTrue(src.f9 != dst.f9); - assertFalse(it.hasNext()); - } - - @MessagePackUnpackable - public static class SampleSubClass extends SampleSuperClass { - public int f0; - public final int f1 = 1; - private int f2; - protected int f3; - int f4; - - public SampleSubClass() { - } - } - - public static class SampleSuperClass { - public int f5; - public final int f6 = 2; - private int f7; - protected int f8; - int f9; - - public SampleSuperClass() { - } - } -}