generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-03-19 13:02:13 +01:00
Code Issues Projects Releases Wiki Activity

write a simple test program for a DynamicCodeGenPacker class

Browse Source
This commit is contained in:
Muga Nishizawa 2010-09-28 15:31:55 +09:00
parent 190af1d32b
commit 923580d2cd
9 changed files with 619 additions and 782 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
java/src/main/java/org/msgpack/MessagePacker.java
View File

@ -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;
}

12
java/src/main/java/org/msgpack/annotation/MessagePackOptional.java Normal file
View File

@ -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;
}

12
java/src/main/java/org/msgpack/annotation/MessagePackRequired.java Normal file
View File

@ -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;
}

6
java/src/main/java/org/msgpack/util/codegen/BasicConstants.java
View File

@ -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";

515
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java
View File

@ -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<MessagePackObject> 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<MessagePackObject, MessagePackObject> 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)

13
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java
View File

@ -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);

77
java/src/test/java/org/msgpack/util/TestDynamicCodeGenPackerTemplate.java Normal file
View File

@ -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);
}
}

61
java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPacker.java
View File

@ -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);
}
}

703
java/src/test/java/org/msgpack/util/codegen/TestMessagePackUnpackable.java
View File

@ -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<MessagePackObject> 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<MessagePackObject> 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<Integer>();
src.f1 = new ArrayList<Integer>();
src.f1.add(1);
src.f1.add(2);
src.f1.add(3);
src.f2 = new ArrayList<String>();
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<Integer>();
src.f1 = new ArrayList<Integer>();
src.f1.add(1);
src.f1.add(2);
src.f1.add(3);
src.f2 = new ArrayList<String>();
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<MessagePackObject> 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<Integer> f0;
public List<Integer> f1;
public List<String> f2;
public SampleListTypes() {
}
}
public void testMapTypes01() throws Exception {
SampleMapTypes src = (SampleMapTypes) PackUnpackUtil
.newEnhancedInstance(SampleMapTypes.class);
src.f0 = new HashMap<Integer, Integer>();
src.f1 = new HashMap<Integer, Integer>();
src.f1.put(1, 1);
src.f1.put(2, 2);
src.f1.put(3, 3);
src.f2 = new HashMap<String, Integer>();
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<Integer> srcf1 = src.f1.keySet().iterator();
Iterator<Integer> 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<String> srcf2 = src.f2.keySet().iterator();
Iterator<String> 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<Integer, Integer>();
src.f1 = new HashMap<Integer, Integer>();
src.f1.put(1, 1);
src.f1.put(2, 2);
src.f1.put(3, 3);
src.f2 = new HashMap<String, Integer>();
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<MessagePackObject> 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<Integer> srcf1 = src.f1.keySet().iterator();
Iterator<Integer> 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<String> srcf2 = src.f2.keySet().iterator();
Iterator<String> 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<Integer, Integer> f0;
public Map<Integer, Integer> f1;
public Map<String, Integer> 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<MessagePackObject> 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<MessagePackObject> 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<MessagePackObject> 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() {
}
}
}