generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-22 16:02:30 +02:00
Code Issues Projects Releases Wiki Activity

java: refactor the programs in a org.msgpack.util.codegen package

Browse Source
This commit is contained in:
Muga Nishizawa
2010-10-09 21:53:49 +09:00
parent 790f9409b1
commit 3f5ac54bf5
14 changed files with 729 additions and 917 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,194 +0,0 @@
package org.msgpack.util.codegen;
public interface BasicConstants {
String KEYWORD_MODIFIER_PUBLIC = "public";
String KEYWORD_CATCH = "catch";
String KEYWORD_ELSE = "else";
String KEYWORD_ELSEIF = "else if";
String KEYWORD_FOR = "for";
String KEYWORD_IF = "if";
String KEYWORD_INSTANCEOF = "instanceof";
String KEYWORD_NEW = "new";
String KEYWORD_NULL = "null";
String KEYWORD_RETURN = "return";
String KEYWORD_THROW = "throw";
String KEYWORD_THROWS = "throws";
String KEYWORD_TRY = "try";
String CHAR_NAME_SPACE = " ";
String CHAR_NAME_COMMA = ",";
String CHAR_NAME_EQUAL = "=";
String CHAR_NAME_PLUS = "+";
String CHAR_NAME_MINUS = "-";
String CHAR_NAME_UNDERSCORE = "_";
String CHAR_NAME_LESSTHAN = "<";
String CHAR_NAME_RIGHT_PARENTHESIS = ")";
String CHAR_NAME_LEFT_PARENTHESIS = "(";
String CHAR_NAME_RIGHT_CURLY_BRACKET = "}";
String CHAR_NAME_LEFT_CURLY_BRACKET = "{";
String CHAR_NAME_RIGHT_SQUARE_BRACKET = "]";
String CHAR_NAME_LEFT_SQUARE_BRACKET = "[";
String CHAR_NAME_DOT = ".";
String CHAR_NAME_SEMICOLON = ";";
String VARIABLE_NAME_PK = "_$$_pk";
String VARIABLE_NAME_OBJECT = "_$$_obj";
String VARIABLE_NAME_TARGET = "_$$_t";
String VARIABLE_NAME_SIZE = "_$$_len";
String VARIABLE_NAME_ARRAY = "_$$_ary";
String VARIABLE_NAME_LIST = "_$$_list";
String VARIABLE_NAME_MAP = "_$$_map";
String VARIABLE_NAME_KEY = "_$$_key";
String VARIABLE_NAME_VAL = "_$$_val";
String VARIABLE_NAME_ITER = "_$$_iter";
String VARIABLE_NAME_MPO = "_$$_mpo";
String VARIABLE_NAME_I = "i";
String VARIABLE_NAME_TEMPLATES = "_$$_templates";
String VARIABLE_NAME_TEMPLATES0 = "_$$_tmpls";
String VARIABLE_NAME_CLIENT = "_$$_client";
String VARIABLE_NAME_CLIENT0 = "_$$_c";
String METHOD_NAME_VALUEOF = "valueOf";
String METHOD_NAME_BOOLEANVALUE = "booleanValue";
String METHOD_NAME_BYTEVALUE = "byteValue";
String METHOD_NAME_SHORTVALUE = "shortValue";
String METHOD_NAME_INTVALUE = "intValue";
String METHOD_NAME_FLOATVALUE = "floatValue";
String METHOD_NAME_LONGVALUE = "longValue";
String METHOD_NAME_DOUBLEVALUE = "doubleValue";
String METHOD_NAME_ADD = "add";
String METHOD_NAME_PUT = "put";
String METHOD_NAME_GET = "get";
String METHOD_NAME_SIZE = "size";
String METHOD_NAME_KEYSET = "keySet";
String METHOD_NAME_ITERATOR = "iterator";
String METHOD_NAME_HASNEXT = "hasNext";
String METHOD_NAME_NEXT = "next";
String METHOD_NAME_ORDINAL = "ordinal";
String METHOD_NAME_GETENUMCONSTANTS = "getEnumConstants";
String METHOD_NAME_CONVERT = "convert";
String METHOD_NAME_MSGCONVERT = "messageConvert";
String METHOD_NAME_SETTEMPLATES = "setTemplates";
String METHOD_NAME_SETCLIENT = "setClient";
String METHOD_NAME_PACK = "pack";
String METHOD_NAME_PACKARRAY = "packArray";
String METHOD_NAME_UNPACK = "unpack";
String METHOD_NAME_UNPACKBOOLEAN = "unpackBoolean";
String METHOD_NAME_UNPACKBYTE = "unpackByte";
String METHOD_NAME_UNPACKDOUBLE = "unpackDouble";
String METHOD_NAME_UNPACKFLOAT = "unpackFloat";
String METHOD_NAME_UNPACKINT = "unpackInt";
String METHOD_NAME_UNPACKLONG = "unpackLong";
String METHOD_NAME_UNPACKSHORT = "unpackShort";
String METHOD_NAME_UNPACKSTRING = "unpackString";
String METHOD_NAME_UNPACKBIGINTEGER = "unpackBigInteger";
String METHOD_NAME_UNPACKOBJECT = "unpackObject";
String METHOD_NAME_UNPACKBYTEARRAY = "unpackByteArray";
String METHOD_NAME_UNPACKARRAY = "unpackArray";
String METHOD_NAME_UNPACKMAP = "unpackMap";
String METHOD_NAME_ASARRAY = "asArray";
String METHOD_NAME_ASBOOLEAN = "asBoolean";
String METHOD_NAME_ASBYTE = "asByte";
String METHOD_NAME_ASSHORT = "asShort";
String METHOD_NAME_ASINT = "asInt";
String METHOD_NAME_ASFLOAT = "asFloat";
String METHOD_NAME_ASLONG = "asLong";
String METHOD_NAME_ASDOUBLE = "asDouble";
String METHOD_NAME_ASSTRING = "asString";
String METHOD_NAME_ASBYTEARRAY = "asByteArray";
String METHOD_NAME_ASBIGINTEGER = "asBigInteger";
String METHOD_NAME_ASLIST = "asList";
String METHOD_NAME_ASMAP = "asMap";
}

218
java/src/main/java/org/msgpack/util/codegen/Constants.java
View File

@@ -1,6 +1,6 @@
package org.msgpack.util.codegen;
public interface Constants extends BasicConstants {
public interface Constants {
String POSTFIX_TYPE_NAME_PACKER = "_$$_Packer";
String POSTFIX_TYPE_NAME_UNPACKER = "_$$_Unpacker";
@@ -8,4 +8,220 @@ public interface Constants extends BasicConstants {
String POSTFIX_TYPE_NAME_CONVERTER = "_$$_Converter";
String POSTFIX_TYPE_NAME_TEMPLATE = "_$$_Template";
String KEYWORD_MODIFIER_PUBLIC = "public";
String KEYWORD_CATCH = "catch";
String KEYWORD_ELSE = "else";
String KEYWORD_ELSEIF = "else if";
String KEYWORD_FOR = "for";
String KEYWORD_IF = "if";
String KEYWORD_INSTANCEOF = "instanceof";
String KEYWORD_NEW = "new";
String KEYWORD_NULL = "null";
String KEYWORD_RETURN = "return";
String KEYWORD_THROW = "throw";
String KEYWORD_THROWS = "throws";
String KEYWORD_TRY = "try";
String CHAR_NAME_SPACE = " ";
String CHAR_NAME_COMMA = ",";
String CHAR_NAME_EQUAL = "=";
String CHAR_NAME_PLUS = "+";
String CHAR_NAME_MINUS = "-";
String CHAR_NAME_UNDERSCORE = "_";
String CHAR_NAME_LESSTHAN = "<";
String CHAR_NAME_RIGHT_PARENTHESIS = ")";
String CHAR_NAME_LEFT_PARENTHESIS = "(";
String CHAR_NAME_RIGHT_CURLY_BRACKET = "}";
String CHAR_NAME_LEFT_CURLY_BRACKET = "{";
String CHAR_NAME_RIGHT_SQUARE_BRACKET = "]";
String CHAR_NAME_LEFT_SQUARE_BRACKET = "[";
String CHAR_NAME_DOT = ".";
String CHAR_NAME_SEMICOLON = ";";
String VARIABLE_NAME_PK = "_$$_pk";
String VARIABLE_NAME_OBJECT = "_$$_obj";
String VARIABLE_NAME_TARGET = "_$$_t";
String VARIABLE_NAME_SIZE = "_$$_len";
String VARIABLE_NAME_ARRAY = "_$$_ary";
String VARIABLE_NAME_LIST = "_$$_list";
String VARIABLE_NAME_MAP = "_$$_map";
String VARIABLE_NAME_KEY = "_$$_key";
String VARIABLE_NAME_VAL = "_$$_val";
String VARIABLE_NAME_ITER = "_$$_iter";
String VARIABLE_NAME_MPO = "_$$_mpo";
String VARIABLE_NAME_I = "i";
String VARIABLE_NAME_TEMPLATES = "_$$_templates";
String VARIABLE_NAME_TEMPLATES0 = "_$$_tmpls";
String VARIABLE_NAME_CLIENT = "_$$_client";
String VARIABLE_NAME_CLIENT0 = "_$$_c";
String METHOD_NAME_VALUEOF = "valueOf";
String METHOD_NAME_BOOLEANVALUE = "booleanValue";
String METHOD_NAME_BYTEVALUE = "byteValue";
String METHOD_NAME_SHORTVALUE = "shortValue";
String METHOD_NAME_INTVALUE = "intValue";
String METHOD_NAME_FLOATVALUE = "floatValue";
String METHOD_NAME_LONGVALUE = "longValue";
String METHOD_NAME_DOUBLEVALUE = "doubleValue";
String METHOD_NAME_ADD = "add";
String METHOD_NAME_PUT = "put";
String METHOD_NAME_GET = "get";
String METHOD_NAME_SIZE = "size";
String METHOD_NAME_KEYSET = "keySet";
String METHOD_NAME_ITERATOR = "iterator";
String METHOD_NAME_HASNEXT = "hasNext";
String METHOD_NAME_NEXT = "next";
String METHOD_NAME_ORDINAL = "ordinal";
String METHOD_NAME_GETENUMCONSTANTS = "getEnumConstants";
String METHOD_NAME_CONVERT = "convert";
String METHOD_NAME_MSGCONVERT = "messageConvert";
String METHOD_NAME_SETTEMPLATES = "setTemplates";
String METHOD_NAME_SETCLIENT = "setClient";
String METHOD_NAME_PACK = "pack";
String METHOD_NAME_PACKARRAY = "packArray";
String METHOD_NAME_UNPACK = "unpack";
String METHOD_NAME_UNPACKBOOLEAN = "unpackBoolean";
String METHOD_NAME_UNPACKBYTE = "unpackByte";
String METHOD_NAME_UNPACKDOUBLE = "unpackDouble";
String METHOD_NAME_UNPACKFLOAT = "unpackFloat";
String METHOD_NAME_UNPACKINT = "unpackInt";
String METHOD_NAME_UNPACKLONG = "unpackLong";
String METHOD_NAME_UNPACKSHORT = "unpackShort";
String METHOD_NAME_UNPACKSTRING = "unpackString";
String METHOD_NAME_UNPACKBIGINTEGER = "unpackBigInteger";
String METHOD_NAME_UNPACKOBJECT = "unpackObject";
String METHOD_NAME_UNPACKBYTEARRAY = "unpackByteArray";
String METHOD_NAME_UNPACKARRAY = "unpackArray";
String METHOD_NAME_UNPACKMAP = "unpackMap";
String METHOD_NAME_ASARRAY = "asArray";
String METHOD_NAME_ASBOOLEAN = "asBoolean";
String METHOD_NAME_ASBYTE = "asByte";
String METHOD_NAME_ASSHORT = "asShort";
String METHOD_NAME_ASINT = "asInt";
String METHOD_NAME_ASFLOAT = "asFloat";
String METHOD_NAME_ASLONG = "asLong";
String METHOD_NAME_ASDOUBLE = "asDouble";
String METHOD_NAME_ASSTRING = "asString";
String METHOD_NAME_ASBYTEARRAY = "asByteArray";
String METHOD_NAME_ASBIGINTEGER = "asBigInteger";
String METHOD_NAME_ASLIST = "asList";
String METHOD_NAME_ASMAP = "asMap";
String STATEMENT_PACKER_PACKERMETHODBODY_01 = "%s _$$_t = (%s)$2; ";
String STATEMENT_PACKER_PACKERMETHODBODY_02 = "$1.packArray(%d); ";
String STATEMENT_PACKER_PACKERMETHODBODY_03 = "$1.pack(_$$_t.%s); ";
String STATEMENT_PACKER_PACKERMETHODBODY_04 = "$1.pack(((java.lang.Enum)_$$_t).ordinal()); ";
String STATEMENT_PACKER_UNPACKERMETHODBODY_01 = "%s _$$_t = new %s(); ";
String STATEMENT_PACKER_UNPACKERMETHODBODY_02 = "$1.unpackArray(); ";
String STATEMENT_PACKER_UNPACKERMETHODBODY_03 = "_$$_t.%s = %s(%s)_$$_templates[%d].unpack($1)%s; ";
String STATEMENT_PACKER_UNPACKERMETHODBODY_04 = "return _$$_t; ";
String STATEMENT_PACKER_UNPACKERMETHODBODY_05 = "int i = $1.unpackInt(); ";
String STATEMENT_PACKER_UNPACKERMETHODBODY_06 = "return %s.class.getEnumConstants()[i]; ";
String STATEMENT_PACKER_CONVERTMETHODBODY_01 = "%s _$$_ary = $1.asArray(); ";
String STATEMENT_PACKER_CONVERTMETHODBODY_02 = "_$$_t.%s = %s(%s)_$$_templates[%d].convert(_$$_ary[%d])%s; ";
String STATEMENT_PACKER_CONVERTMETHODBODY_03 = "int i = _$$_ary[0].asInt(); ";
}

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

@@ -9,15 +9,10 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.CtNewConstructor;
import javassist.CtNewMethod;
import javassist.NotFoundException;
@@ -44,12 +39,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
private static DynamicCodeGen INSTANCE;
private static AtomicInteger COUNTER = new AtomicInteger(0);
private static int inc() {
return COUNTER.addAndGet(1);
}
public static DynamicCodeGen getInstance() {
if (INSTANCE == null) {
LOG.info("create an instance of the type: "
@@ -59,37 +48,37 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
return INSTANCE;
}
private ClassPool pool;
private ConcurrentHashMap<String, Template[]> tmplMap;
private ConcurrentHashMap<String, Template[]> tmplCache;
DynamicCodeGen() {
pool = ClassPool.getDefault();
tmplMap = new ConcurrentHashMap<String, Template[]>();
super();
tmplCache = new ConcurrentHashMap<String, Template[]>();
}
public void setTemplates(Class<?> origClass, Template[] tmpls) {
tmplMap.putIfAbsent(origClass.getName(), tmpls);
public void setTemplates(Class<?> type, Template[] tmpls) {
tmplCache.putIfAbsent(type.getName(), tmpls);
}
public Template[] getTemplates(Class<?> origClass) {
return tmplMap.get(origClass.getName());
public Template[] getTemplates(Class<?> type) {
return tmplCache.get(type.getName());
}
public Class<?> generateMessagePackerClass(Class<?> origClass) {
LOG.debug("start generating a MessagePacker impl.: "
+ origClass.getName());
try {
LOG.debug("start generating a packer class for "
+ origClass.getName());
String origName = origClass.getName();
String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc();
checkClassValidation(origClass);
checkTypeValidation(origClass);
checkDefaultConstructorValidation(origClass);
CtClass packerCtClass = pool.makeClass(packerName);
setInterface(packerCtClass, MessagePacker.class);
addDefaultConstructor(packerCtClass);
Field[] fields = getDeclaredFields(origClass);
addPackMethod(packerCtClass, origClass, fields);
return createClass(packerCtClass);
addPackMethod(packerCtClass, origClass, fields, false);
Class<?> packerClass = createClass(packerCtClass);
LOG.debug("generated a packer class for " + origClass.getName());
return packerClass;
} catch (NotFoundException e) {
LOG.error(e.getMessage(), e);
throw new DynamicCodeGenException(e.getMessage(), e);
@@ -100,17 +89,19 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
}
public Class<?> generateOrdinalEnumPackerClass(Class<?> origClass) {
LOG.debug("start generating a OrdinalEnumPacker impl.: "
+ origClass.getName());
try {
LOG.debug("start generating an enum packer for "
+ origClass.getName());
String origName = origClass.getName();
String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc();
checkClassValidation(origClass);
checkTypeValidation(origClass);
CtClass packerCtClass = pool.makeClass(packerName);
setInterface(packerCtClass, MessagePacker.class);
addDefaultConstructor(packerCtClass);
addPackMethodForOrdinalEnumTypes(packerCtClass, origClass);
return createClass(packerCtClass);
addPackMethod(packerCtClass, origClass, null, true);
Class<?> packerClass = createClass(packerCtClass);
LOG.debug("generated an enum class for " + origClass.getName());
return packerClass;
} catch (NotFoundException e) {
LOG.error(e.getMessage(), e);
throw new DynamicCodeGenException(e.getMessage(), e);
@@ -121,123 +112,103 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
}
public Class<?> generateTemplateClass(Class<?> origClass) {
LOG.debug("start generating a Template impl.: " + origClass.getName());
try {
LOG.debug("start generating a template class for "
+ origClass.getName());
String origName = origClass.getName();
String tmplName = origName + POSTFIX_TYPE_NAME_TEMPLATE + inc();
checkClassValidation(origClass);
checkTypeValidation(origClass);
checkDefaultConstructorValidation(origClass);
CtClass tmplCtClass = pool.makeClass(tmplName);
CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
setInterface(tmplCtClass, Template.class);
setInterface(tmplCtClass, DynamicCodeGenBase.TemplateAccessor.class);
addDefaultConstructor(tmplCtClass);
Field[] fields = getDeclaredFields(origClass);
Template[] tmpls = createTemplates(fields);
setTemplates(origClass, tmpls);
addTemplateArrayField(tmplCtClass, acsCtClass);
addSetTemplatesMethod(tmplCtClass, acsCtClass);
addUnpackMethod(tmplCtClass, origClass, fields);
addConvertMethod(tmplCtClass, origClass, fields);
return createClass(tmplCtClass);
addTemplateArrayField(tmplCtClass);
addSetTemplatesMethod(tmplCtClass);
addUnpackMethod(tmplCtClass, origClass, fields, false);
addConvertMethod(tmplCtClass, origClass, fields, false);
Class<?> tmplClass = createClass(tmplCtClass);
LOG.debug("generated a template class for " + origClass.getName());
return tmplClass;
} catch (NotFoundException e) {
LOG.error(e.getMessage(), e);
throw new DynamicCodeGenException(e.getMessage(), e);
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
} catch (CannotCompileException e) {
LOG.error(e.getMessage(), e);
throw new DynamicCodeGenException(e.getMessage(), e);
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
public Class<?> generateOrdinalEnumTemplateClass(Class<?> origClass) {
LOG.debug("start generating a OrdinalEnumTemplate impl.: "
+ origClass.getName());
try {
LOG.debug("start generating a enum template class for "
+ origClass.getName());
String origName = origClass.getName();
checkClassValidation(origClass);
CtClass tmplCtClass = makeClass(origName);
checkTypeValidation(origClass);
String tmplName = origName + POSTFIX_TYPE_NAME_TEMPLATE + inc();
CtClass tmplCtClass = pool.makeClass(tmplName);
setInterface(tmplCtClass, Template.class);
addDefaultConstructor(tmplCtClass);
addUnpackMethodForOrdinalEnumTypes(tmplCtClass, origClass);
addConvertMethodForOrdinalEnumTypes(tmplCtClass, origClass);
return createClass(tmplCtClass);
addUnpackMethod(tmplCtClass, origClass, null, true);
addConvertMethod(tmplCtClass, origClass, null, true);
// addConvertMethodForOrdinalEnumTypes(tmplCtClass, origClass);
Class<?> tmplClass = createClass(tmplCtClass);
LOG.debug("generated an enum template class for "
+ origClass.getName());
return tmplClass;
} catch (NotFoundException e) {
LOG.error(e.getMessage(), e);
throw new DynamicCodeGenException(e.getMessage(), e);
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
} catch (CannotCompileException e) {
LOG.error(e.getMessage(), e);
throw new DynamicCodeGenException(e.getMessage(), e);
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
private CtClass makeClass(String origName) throws NotFoundException {
StringBuilder sb = new StringBuilder();
sb.append(origName);
sb.append(POSTFIX_TYPE_NAME_TEMPLATE);
sb.append(inc());
String invokerName = sb.toString();
CtClass newCtClass = pool.makeClass(invokerName);
newCtClass.setModifiers(Modifier.PUBLIC);
return newCtClass;
}
private void checkClassValidation(Class<?> origClass) {
@Override
public void checkTypeValidation(Class<?> origClass) {
// not public, abstract
int mod = origClass.getModifiers();
if ((!Modifier.isPublic(mod)) || Modifier.isAbstract(mod)) {
throwClassValidationException(origClass,
throwTypeValidationException(origClass,
"a class must have a public modifier");
}
// interface
if (origClass.isInterface()) {
throwClassValidationException(origClass,
throwTypeValidationException(origClass,
"cannot generate packer and unpacker for an interface");
}
}
private static void throwClassValidationException(Class<?> origClass,
String msg) {
DynamicCodeGenException e = new DynamicCodeGenException(msg + ": "
+ origClass.getName());
LOG.error(e.getMessage(), e);
throw e;
}
private void checkDefaultConstructorValidation(Class<?> origClass) {
@Override
public void checkDefaultConstructorValidation(Class<?> origClass) {
// check that the zero-argument constructor exists
Constructor<?> cons = null;
try {
cons = origClass.getDeclaredConstructor(new Class[0]);
} catch (Exception e1) {
} catch (Exception e) {
throwConstructorValidationException(origClass);
}
// check the modifiers
int mod = cons.getModifiers();
if (!Modifier.isPublic(mod)) {
throwConstructorValidationException(origClass);
}
}
private static void throwConstructorValidationException(Class<?> origClass) {
DynamicCodeGenException e = new DynamicCodeGenException(
"it must have a public zero-argument constructor: "
+ origClass.getName());
LOG.error(e.getMessage(), e);
throw e;
}
private void setInterface(CtClass packerCtClass, Class<?> infClass)
throws NotFoundException {
CtClass infCtClass = pool.get(infClass.getName());
packerCtClass.addInterface(infCtClass);
}
private void addDefaultConstructor(CtClass dstCtClass)
throws CannotCompileException {
CtConstructor newCtCons = CtNewConstructor
.defaultConstructor(dstCtClass);
dstCtClass.addConstructor(newCtCons);
}
private Field[] getDeclaredFields(Class<?> origClass) {
Field[] getDeclaredFields(Class<?> origClass) {
ArrayList<Field> allFields = new ArrayList<Field>();
Class<?> nextClass = origClass;
while (nextClass != Object.class) {
@@ -247,6 +218,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
checkFieldValidation(field, allFields);
allFields.add(field);
} catch (DynamicCodeGenException e) { // ignore
LOG.error(e.getMessage(), e);
}
}
nextClass = nextClass.getSuperclass();
@@ -254,7 +226,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
return allFields.toArray(new Field[0]);
}
private void checkFieldValidation(Field field, List<Field> fields) {
void checkFieldValidation(Field field, List<Field> fields) {
// check that it has a public modifier
int mod = field.getModifiers();
if ((!(Modifier.isPublic(mod))) || Modifier.isStatic(mod)
@@ -270,13 +242,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
}
}
private static void throwFieldValidationException(Field f) {
DynamicCodeGenException e = new DynamicCodeGenException(
"it must be a public field: " + f.getName());
LOG.debug(e.getMessage(), e);
throw e;
}
Template[] createTemplates(Field[] fields) {
Template[] tmpls = new Template[fields.length];
for (int i = 0; i < tmpls.length; ++i) {
@@ -294,19 +259,25 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
}
}
private void addPackMethod(CtClass packerCtClass, Class<?> c, Field[] fs) {
private void addPackMethod(CtClass packerCtClass, Class<?> c, Field[] fs,
boolean isEnum) {
// void pack(Packer pk, Object target) throws IOException;
StringBuilder sb = new StringBuilder();
StringBuilder bsb = new StringBuilder();
insertPackMethodBody(bsb, c, fs);
addPublicMethodDecl(sb, METHOD_NAME_PACK, void.class, new Class[] {
Packer.class, Object.class }, new String[] { VARIABLE_NAME_PK,
VARIABLE_NAME_OBJECT }, new Class[] { IOException.class }, bsb
.toString());
LOG.trace("pack method src: " + sb.toString());
if (!isEnum) {
insertPackMethodBody(sb, c, fs);
} else {
insertOrdinalEnumPackMethodBody(sb, c);
}
try {
CtMethod newCtMethod = CtNewMethod.make(sb.toString(),
packerCtClass);
LOG.trace("pack method src: " + sb.toString());
int mod = javassist.Modifier.PUBLIC;
CtClass returnType = classToCtClass(void.class);
String mname = METHOD_NAME_PACK;
CtClass[] paramTypes = new CtClass[] {
classToCtClass(Packer.class), classToCtClass(Object.class) };
CtClass[] exceptTypes = new CtClass[] { classToCtClass(IOException.class) };
CtMethod newCtMethod = CtNewMethod.make(mod, returnType, mname,
paramTypes, exceptTypes, sb.toString(), packerCtClass);
packerCtClass.addMethod(newCtMethod);
} catch (CannotCompileException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
@@ -314,21 +285,29 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
} catch (NotFoundException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
private void insertPackMethodBody(StringBuilder sb, Class<?> c, Field[] fs) {
insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET);
StringBuilder mc = new StringBuilder();
insertTypeCast(mc, c, VARIABLE_NAME_OBJECT);
insertValueInsertion(sb, mc.toString());
insertSemicolon(sb);
insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_PACKARRAY,
new String[] { new Integer(fs.length).toString() });
insertSemicolon(sb);
for (Field f : fs) {
private void insertPackMethodBody(StringBuilder sb, Class<?> type,
Field[] fields) {
// void pack(Packer packer, Object target) throws IOException;
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
String typeName = classToString(type);
Object[] args0 = new Object[] { typeName, typeName };
sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_01, args0));
Object[] args1 = new Object[] { fields.length };
sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_02, args1));
for (Field f : fields) {
insertCodeOfPackMethodCall(sb, f);
}
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
}
private void insertCodeOfPackMethodCall(StringBuilder sb, Field field) {
@@ -352,7 +331,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
; // ignore
} else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) {
// @MessagePackMessage
MessagePacker packer = DynamicCodeGenPacker.create(c);
MessagePacker packer = DynamicPacker.create(c);
CustomMessage.registerPacker(c, packer);
} else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) {
// FIXME DelegatePacker
@@ -362,7 +341,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
throw e;
} else if (CustomMessage.isAnnotated(c, MessagePackOrdinalEnum.class)) {
// @MessagePackOrdinalEnum
MessagePacker packer = DynamicCodeGenOrdinalEnumPacker.create(c);
MessagePacker packer = DynamicOrdinalEnumPacker.create(c);
CustomMessage.registerPacker(c, packer);
} else {
MessageTypeException e = new MessageTypeException("unknown type: "
@@ -370,106 +349,77 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
LOG.error(e.getMessage(), e);
throw e;
}
StringBuilder fa = new StringBuilder();
insertFieldAccess(fa, VARIABLE_NAME_TARGET, field.getName());
insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_PACK,
new String[] { fa.toString() });
insertSemicolon(sb);
Object[] args = new Object[] { field.getName() };
sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_03, args));
}
private void addPackMethodForOrdinalEnumTypes(CtClass packerCtClass,
Class<?> c) throws CannotCompileException, NotFoundException {
// void pack(Packer pk, Object target) throws IOException;
private void insertOrdinalEnumPackMethodBody(StringBuilder sb, Class<?> c) {
// void pack(Packer packer, Object target) throws IOException;
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
String typeName = classToString(c);
Object[] args0 = new Object[] { typeName, typeName };
sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_01, args0));
Object[] args1 = new Object[] { 1 };
sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_02, args1));
Object[] args2 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_04, args2));
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
}
private void addUnpackMethod(CtClass tmplCtClass, Class<?> type,
Field[] fields, boolean isEnum) {
// Object unpack(Unpacker u) throws IOException, MessageTypeException;
StringBuilder sb = new StringBuilder();
StringBuilder bsb = new StringBuilder();
insertLocalVariableDecl(bsb, c, VARIABLE_NAME_TARGET);
StringBuilder fa = new StringBuilder();
insertTypeCast(fa, c, VARIABLE_NAME_OBJECT);
insertValueInsertion(bsb, fa.toString());
insertSemicolon(bsb);
insertMethodCall(bsb, VARIABLE_NAME_PK, METHOD_NAME_PACKARRAY,
new String[] { new Integer(1).toString() });
insertSemicolon(bsb);
fa = new StringBuilder();
insertTypeCast(fa, Enum.class, VARIABLE_NAME_TARGET);
String t = fa.toString();
fa = new StringBuilder();
insertMethodCall(fa, t, METHOD_NAME_ORDINAL, new String[0]);
insertMethodCall(bsb, VARIABLE_NAME_PK, METHOD_NAME_PACK,
new String[] { fa.toString() });
insertSemicolon(bsb);
addPublicMethodDecl(sb, METHOD_NAME_PACK, void.class, new Class[] {
Packer.class, Object.class }, new String[] { VARIABLE_NAME_PK,
VARIABLE_NAME_OBJECT }, new Class[] { IOException.class }, bsb
.toString());
LOG.trace("pack method src: " + sb.toString());
if (!isEnum) {
insertUnpackMethodBody(sb, type, fields);
} else {
insertOrdinalEnumUnpackMethodBody(sb, type);
}
try {
CtMethod newCtMethod = CtNewMethod.make(sb.toString(),
packerCtClass);
packerCtClass.addMethod(newCtMethod);
LOG.trace("unpack method src: " + sb.toString());
int mod = javassist.Modifier.PUBLIC;
CtClass returnType = classToCtClass(Object.class);
String mname = METHOD_NAME_UNPACK;
CtClass[] paramTypes = new CtClass[] { classToCtClass(Unpacker.class) };
CtClass[] exceptTypes = new CtClass[] {
classToCtClass(IOException.class),
classToCtClass(MessageTypeException.class) };
CtMethod newCtMethod = CtNewMethod.make(mod, returnType, mname,
paramTypes, exceptTypes, sb.toString(), tmplCtClass);
tmplCtClass.addMethod(newCtMethod);
} catch (CannotCompileException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
} catch (NotFoundException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
private void addTemplateArrayField(CtClass newCtClass, CtClass acsCtClass)
throws NotFoundException, CannotCompileException {
CtField tmplsField = acsCtClass
.getDeclaredField(VARIABLE_NAME_TEMPLATES);
CtField tmplsField2 = new CtField(tmplsField.getType(), tmplsField
.getName(), newCtClass);
newCtClass.addField(tmplsField2);
}
private void addSetTemplatesMethod(CtClass newCtClass, CtClass acsCtClass)
throws NotFoundException, CannotCompileException {
CtMethod settmplsMethod = acsCtClass
.getDeclaredMethod(METHOD_NAME_SETTEMPLATES);
CtMethod settmplsMethod2 = CtNewMethod.copy(settmplsMethod, newCtClass,
null);
newCtClass.addMethod(settmplsMethod2);
}
private void addUnpackMethod(CtClass unpackerCtClass, Class<?> c, Field[] fs) {
// Object unpack(Unpacker pac) throws IOException, MessageTypeException;
StringBuilder sb = new StringBuilder();
StringBuilder bsb = new StringBuilder();
insertUnpackMethodBody(bsb, c, fs);
addPublicMethodDecl(sb, METHOD_NAME_UNPACK, Object.class,
new Class<?>[] { Unpacker.class },
new String[] { VARIABLE_NAME_PK }, new Class<?>[] {
MessageTypeException.class, IOException.class }, bsb
.toString());
LOG.trace("unpack method src: " + sb.toString());
try {
CtMethod newCtMethod = CtNewMethod.make(sb.toString(),
unpackerCtClass);
unpackerCtClass.addMethod(newCtMethod);
} catch (CannotCompileException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
private void insertUnpackMethodBody(StringBuilder sb, Class<?> c, Field[] fs) {
insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET);
StringBuilder mc = new StringBuilder();
insertDefaultConsCall(mc, c);
insertValueInsertion(sb, mc.toString());
insertSemicolon(sb);
insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_UNPACKARRAY,
new String[0]);
insertSemicolon(sb);
insertCodeOfUnpackMethodCalls(sb, fs);
insertReturnStat(sb, VARIABLE_NAME_TARGET);
insertSemicolon(sb);
private void insertUnpackMethodBody(StringBuilder sb, Class<?> type,
Field[] fields) {
// Object unpack(Unpacker u) throws IOException, MessageTypeException;
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
// Foo _$$_t = new Foo();
String typeName = classToString(type);
Object[] args0 = new Object[] { typeName, typeName };
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_01, args0));
// $1.unpackArray();
Object[] args1 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_02, args1));
insertCodeOfUnpackMethodCalls(sb, fields);
// return _$$_t;
Object[] args2 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_04, args2));
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
}
private void insertCodeOfUnpackMethodCalls(StringBuilder sb, Field[] fields) {
@@ -481,40 +431,17 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
private void insertCodeOfUnpackMethodCall(StringBuilder sb, Field field,
int i) {
// target.fi = ((Integer)_$$_tmpls[i].unpack(_$$_pk)).intValue();
Class<?> type = field.getType();
insertFieldAccess(sb, VARIABLE_NAME_TARGET, field.getName());
String castType = null;
String rawValueGetter = null;
if (type.isPrimitive()) {
castType = "(" + primitiveTypeToWrapperType(type).getName() + ")";
rawValueGetter = getPrimTypeValueMethodName(type);
} else if (type.isArray()) {
castType = "(" + arrayTypeToString(type) + ")";
} else {
castType = "(" + type.getName() + ")";
}
StringBuilder mc = new StringBuilder();
mc.append(castType);
mc.append(VARIABLE_NAME_TEMPLATES);
mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
mc.append(i);
mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
String tname = mc.toString();
mc = new StringBuilder();
insertMethodCall(mc, tname, METHOD_NAME_UNPACK,
new String[] { VARIABLE_NAME_PK });
if (type.isPrimitive()) {
tname = mc.toString();
mc = new StringBuilder();
mc.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
mc.append(tname);
mc.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
tname = mc.toString();
mc = new StringBuilder();
insertMethodCall(mc, tname, rawValueGetter, new String[0]);
}
insertValueInsertion(sb, mc.toString());
insertSemicolon(sb);
Class<?> returnType = field.getType();
boolean isPrim = returnType.isPrimitive();
Object[] args = new Object[] {
field.getName(),
isPrim ? "(" : "",
isPrim ? getPrimToWrapperType(returnType).getName()
: classToString(returnType),
i,
isPrim ? ")." + getPrimTypeValueMethodName(returnType) + "()"
: "" };
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_03, args));
}
private void insertCodeOfUnpackMethodCallForMsgUnpackableType(
@@ -567,59 +494,41 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
sb.append(CHAR_NAME_SPACE);
}
private void addUnpackMethodForOrdinalEnumTypes(CtClass unpackerCtClass,
Class<?> c) {
// Object unpack(Unpacker pac) throws IOException, MessageTypeException;
StringBuilder sb = new StringBuilder();
StringBuilder bsb = new StringBuilder();
insertMethodCall(bsb, VARIABLE_NAME_PK, METHOD_NAME_UNPACKARRAY,
new String[0]);
insertSemicolon(bsb);
StringBuilder mc = new StringBuilder();
insertMethodCall(mc, VARIABLE_NAME_PK, METHOD_NAME_UNPACKINT,
new String[0]);
insertLocalVariableDecl(bsb, int.class, VARIABLE_NAME_I);
insertValueInsertion(bsb, mc.toString());
insertSemicolon(bsb);
mc = new StringBuilder();
insertMethodCall(mc, c.getName() + ".class",
METHOD_NAME_GETENUMCONSTANTS, new String[0]);
mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
mc.append(VARIABLE_NAME_I);
mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
insertReturnStat(bsb, mc.toString());
insertSemicolon(bsb);
addPublicMethodDecl(sb, METHOD_NAME_UNPACK, Object.class,
new Class<?>[] { Unpacker.class },
new String[] { VARIABLE_NAME_PK }, new Class<?>[] {
MessageTypeException.class, IOException.class }, bsb
.toString());
LOG.trace("unpack method src: " + sb.toString());
try {
CtMethod newCtMethod = CtNewMethod.make(sb.toString(),
unpackerCtClass);
unpackerCtClass.addMethod(newCtMethod);
} catch (CannotCompileException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
private void insertOrdinalEnumUnpackMethodBody(StringBuilder sb,
Class<?> type) {
// Object unpack(Unpacker u) throws IOException, MessageTypeException;
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
// $1.unpackArray();
Object[] args0 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_02, args0));
// int i = $1.unapckInt();
Object[] args1 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_05, args1));
// return Foo.class.getEnumConstants()[i];
Object[] args2 = new Object[] { classToString(type) };
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_06, args2));
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
}
public void addConvertMethod(CtClass tmplCtClass, Class<?> c, Field[] fs) {
// Object convert(MessagePackObject from) throws MessageTypeException;
public void addConvertMethod(CtClass tmplCtClass, Class<?> type,
Field[] fields, boolean isEnum) {
// Object convert(MessagePackObject mpo) throws MessageTypeException;
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());
LOG.trace("convert method src: " + sb.toString());
if (!isEnum) {
insertConvertMethodBody(sb, type, fields);
} else {
insertOrdinalEnumConvertMethodBody(sb, type);
}
try {
CtMethod newCtMethod = CtNewMethod.make(sb.toString(), tmplCtClass);
LOG.trace("convert method src: " + sb.toString());
int mod = javassist.Modifier.PUBLIC;
CtClass returnType = classToCtClass(Object.class);
String mname = METHOD_NAME_CONVERT;
CtClass[] paramTypes = new CtClass[] { classToCtClass(MessagePackObject.class) };
CtClass[] exceptTypes = new CtClass[] { classToCtClass(MessageTypeException.class) };
CtMethod newCtMethod = CtNewMethod.make(mod, returnType, mname,
paramTypes, exceptTypes, sb.toString(), tmplCtClass);
tmplCtClass.addMethod(newCtMethod);
} catch (CannotCompileException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
@@ -627,31 +536,32 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
} catch (NotFoundException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
private void insertConvertMethodBody(StringBuilder sb, Class<?> c,
Field[] fs) {
insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET);
StringBuilder mc = new StringBuilder();
insertDefaultConsCall(mc, c);
insertValueInsertion(sb, mc.toString());
insertSemicolon(sb);
insertCodeOfMessagePackObjectArrayGet(sb);
insertCodeOfConvertMethodCalls(sb, fs);
insertReturnStat(sb, VARIABLE_NAME_TARGET);
insertSemicolon(sb);
}
private void insertCodeOfMessagePackObjectArrayGet(StringBuilder sb) {
// MessagePackObject[] ary = obj.asArray();
insertLocalVariableDecl(sb, MessagePackObject.class,
VARIABLE_NAME_ARRAY, 1);
StringBuilder mc = new StringBuilder();
insertMethodCall(mc, VARIABLE_NAME_MPO, METHOD_NAME_ASARRAY,
new String[0]);
insertValueInsertion(sb, mc.toString());
insertSemicolon(sb);
private void insertConvertMethodBody(StringBuilder sb, Class<?> type,
Field[] fields) {
// Object convert(MessagePackObject mpo) throws MessageTypeException;
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
// Foo _$$_t = new Foo();
String typeName = classToString(type);
Object[] args0 = new Object[] { typeName, typeName };
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_01, args0));
// MessagePackObject[] _$$_ary = $1.asArray();
Object[] args1 = new Object[] { classToString(MessagePackObject[].class) };
sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_01, args1));
insertCodeOfConvertMethodCalls(sb, fields);
// return _$$_t;
Object[] args2 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_04, args2));
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
}
private void insertCodeOfConvertMethodCalls(StringBuilder sb, Field[] fields) {
@@ -661,46 +571,19 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
}
private void insertCodeOfConvMethodCall(StringBuilder sb, Field field, int i) {
// target.f0 = ((Integer)_$$_tmpls[i].convert(_$$_ary[i])).intValue();
Class<?> type = field.getType();
insertFieldAccess(sb, VARIABLE_NAME_TARGET, field.getName());
String castType = null;
String rawValueGetter = null;
if (type.isPrimitive()) {
castType = "(" + primitiveTypeToWrapperType(type).getName() + ")";
rawValueGetter = getPrimTypeValueMethodName(type);
} else if (type.isArray()) {
castType = "(" + arrayTypeToString(type) + ")";
} else {
castType = "(" + type.getName() + ")";
}
StringBuilder mc = new StringBuilder();
mc.append(castType);
mc.append(VARIABLE_NAME_TEMPLATES);
mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
mc.append(i);
mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
String tname = mc.toString();
mc = new StringBuilder();
mc.append(VARIABLE_NAME_ARRAY);
mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
mc.append(i);
mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
String aname = mc.toString();
mc = new StringBuilder();
insertMethodCall(mc, tname, METHOD_NAME_CONVERT, new String[] { aname });
if (type.isPrimitive()) {
tname = mc.toString();
mc = new StringBuilder();
mc.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
mc.append(tname);
mc.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
tname = mc.toString();
mc = new StringBuilder();
insertMethodCall(mc, tname, rawValueGetter, new String[0]);
}
insertValueInsertion(sb, mc.toString());
insertSemicolon(sb);
// target.fi = ((Object)_$$_tmpls[i].convert(_$$_ary[i])).intValue();
Class<?> returnType = field.getType();
boolean isPrim = returnType.isPrimitive();
Object[] args = new Object[] {
field.getName(),
isPrim ? "(" : "",
isPrim ? getPrimToWrapperType(returnType).getName()
: classToString(returnType),
i,
i,
isPrim ? ")." + getPrimTypeValueMethodName(returnType) + "()"
: "" };
sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_02, args));
}
private void insertCodeOfMessageConvertCallForMsgConvtblType(
@@ -752,50 +635,20 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
sb.append(CHAR_NAME_SPACE);
}
public void addConvertMethodForOrdinalEnumTypes(CtClass tmplCtClass,
Class<?> c) {
// Object convert(MessagePackObject from) throws MessageTypeException;
StringBuilder sb = new StringBuilder();
StringBuilder bsb = new StringBuilder();
insertCodeOfMessagePackObjectArrayGet(bsb);
StringBuilder mc = new StringBuilder();
insertMethodCall(mc, VARIABLE_NAME_ARRAY + "[0]", METHOD_NAME_ASINT,
new String[0]);
insertLocalVariableDecl(bsb, int.class, VARIABLE_NAME_I);
insertValueInsertion(bsb, mc.toString());
insertSemicolon(bsb);
mc = new StringBuilder();
insertMethodCall(mc, c.getName() + ".class",
METHOD_NAME_GETENUMCONSTANTS, new String[0]);
mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
mc.append(VARIABLE_NAME_I);
mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
insertLocalVariableDecl(bsb, Object.class, VARIABLE_NAME_OBJECT);
insertValueInsertion(bsb, mc.toString());
insertSemicolon(bsb);
mc = new StringBuilder();
insertTypeCast(mc, c, VARIABLE_NAME_OBJECT);
insertReturnStat(bsb, mc.toString());
insertSemicolon(bsb);
addPublicMethodDecl(sb, METHOD_NAME_CONVERT, Object.class,
new Class<?>[] { MessagePackObject.class },
new String[] { VARIABLE_NAME_MPO },
new Class<?>[] { MessageTypeException.class }, bsb.toString());
LOG.trace("convert method src: " + sb.toString());
try {
CtMethod newCtMethod = CtNewMethod.make(sb.toString(), tmplCtClass);
tmplCtClass.addMethod(newCtMethod);
} catch (CannotCompileException e) {
DynamicCodeGenException ex = new DynamicCodeGenException(e
.getMessage()
+ ": " + sb.toString(), e);
LOG.error(ex.getMessage(), ex);
throw ex;
}
}
private Class<?> createClass(CtClass packerCtClass)
throws CannotCompileException {
return packerCtClass.toClass(null, null);
private void insertOrdinalEnumConvertMethodBody(StringBuilder sb,
Class<?> type) {
// Object convert(MessagePackObject mpo) throws MessageTypeException;
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
// MessagePackObject[] _$$_ary = $1.asArray();
Object[] args0 = new Object[] { classToString(MessagePackObject[].class) };
sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_01, args0));
// int i = _$$_ary[0].asInt();
Object[] args1 = new Object[0];
sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_03, args1));
// return Foo.class.getEnumConstants()[i];
Object[] args2 = new Object[] { classToString(type) };
sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_06, args2));
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
}
}

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

@@ -1,11 +1,24 @@
package org.msgpack.util.codegen;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigInteger;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.CtNewConstructor;
import javassist.CtNewMethod;
import javassist.NotFoundException;
import org.msgpack.CustomConverter;
import org.msgpack.CustomMessage;
@@ -18,7 +31,7 @@ import org.msgpack.annotation.MessagePackOrdinalEnum;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DynamicCodeGenBase implements BasicConstants {
public class DynamicCodeGenBase implements Constants {
public static interface TemplateAccessor {
void setTemplates(Template[] templates);
}
@@ -34,252 +47,104 @@ public class DynamicCodeGenBase implements BasicConstants {
private static Logger LOG = LoggerFactory
.getLogger(DynamicCodeGenBase.class);
private static AtomicInteger COUNTER = new AtomicInteger(0);
protected static int inc() {
return COUNTER.addAndGet(1);
}
protected ClassPool pool;
public DynamicCodeGenBase() {
pool = ClassPool.getDefault();
}
public void addPublicFieldDecl(StringBuilder sb, Class<?> type, String name) {
addPublicFieldDecl(sb, type, name, 0);
protected void checkTypeValidation(Class<?> type) {
DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
+ type.getName());
LOG.error(e.getMessage(), e);
throw e;
}
public void addPublicFieldDecl(StringBuilder sb, Class<?> type,
String name, int dim) {
sb.append(KEYWORD_MODIFIER_PUBLIC);
sb.append(CHAR_NAME_SPACE);
sb.append(type.getName());
for (int i = 0; i < dim; ++i) {
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
}
sb.append(CHAR_NAME_SPACE);
sb.append(name);
protected void throwTypeValidationException(Class<?> origClass,
String message) throws DynamicCodeGenException {
DynamicCodeGenException e = new DynamicCodeGenException(message + ": "
+ origClass.getName());
LOG.error(e.getMessage(), e);
throw e;
}
public void addPublicMethodDecl(StringBuilder sb, String mname,
Class<?> returnType, Class<?>[] paramTypes, String[] anames,
Class<?>[] exceptTypes, String methodBody) {
int[] dims = new int[paramTypes.length];
for (int i = 0; i < paramTypes.length; ++i) {
dims[i] = 0;
}
addPublicMethodDecl(sb, mname, returnType, paramTypes, dims, anames,
exceptTypes, methodBody);
protected void checkDefaultConstructorValidation(Class<?> type) {
DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
+ type.getName());
LOG.error(e.getMessage(), e);
throw e;
}
public void addPublicMethodDecl(StringBuilder sb, String mname,
Class<?> returnType, Class<?>[] paramTypes, int[] dims,
String[] anames, Class<?>[] exceptTypes, String methodBody) {
sb.append(KEYWORD_MODIFIER_PUBLIC);
sb.append(CHAR_NAME_SPACE);
sb.append(returnType.getName());
sb.append(CHAR_NAME_SPACE);
sb.append(mname);
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
for (int i = 0; i < paramTypes.length; ++i) {
sb.append(paramTypes[i].getName());
for (int j = 0; j < dims[i]; ++j) {
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
}
sb.append(CHAR_NAME_SPACE);
sb.append(anames[i]);
if (i + 1 != paramTypes.length) {
sb.append(CHAR_NAME_COMMA);
sb.append(CHAR_NAME_SPACE);
}
}
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
sb.append(CHAR_NAME_SPACE);
if (exceptTypes.length != 0) {
sb.append(KEYWORD_THROWS);
sb.append(CHAR_NAME_SPACE);
for (int i = 0; i < exceptTypes.length; ++i) {
sb.append(exceptTypes[i].getName());
if (i + 1 != exceptTypes.length) {
sb.append(CHAR_NAME_COMMA);
sb.append(CHAR_NAME_SPACE);
}
}
sb.append(CHAR_NAME_SPACE);
}
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
sb.append(methodBody);
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
protected void throwConstructorValidationException(Class<?> origClass) {
DynamicCodeGenException e = new DynamicCodeGenException(
"it must have a public zero-argument constructor: "
+ origClass.getName());
LOG.error(e.getMessage(), e);
throw e;
}
public void insertSemicolon(StringBuilder sb) {
// ;
sb.append(CHAR_NAME_SEMICOLON);
sb.append(CHAR_NAME_SPACE);
protected void throwFieldValidationException(Field f) {
DynamicCodeGenException e = new DynamicCodeGenException(
"it must be a public field: " + f.getName());
LOG.debug(e.getMessage(), e);
throw e;
}
public void insertLocalVariableDecl(StringBuilder sb, Class<?> type,
String name) {
// int lv
insertLocalVariableDecl(sb, type, name, 0);
protected static void throwMethodValidationException(Method method,
String message) throws DynamicCodeGenException {
DynamicCodeGenException e = new DynamicCodeGenException(message + ": "
+ method.getName());
LOG.error(e.getMessage(), e);
throw e;
}
public void insertLocalVariableDecl(StringBuilder sb, Class<?> type,
String name, int dim) {
// int[] lv
int dim0 = dim + getArrayDim(type);
Class<?> type0 = getArrayBaseType(type);
sb.append(type0.getName());
for (int i = 0; i < dim0; ++i) {
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
}
sb.append(CHAR_NAME_SPACE);
sb.append(name);
protected CtClass makeClass(String name) throws NotFoundException {
DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
+ name);
LOG.error(e.getMessage(), e);
throw e;
}
protected int getArrayDim(Class<?> type) {
if (type.isArray()) {
return 1 + getArrayDim(type.getComponentType());
} else {
return 0;
}
protected void setInterface(CtClass packerCtClass, Class<?> infClass)
throws NotFoundException {
CtClass infCtClass = pool.get(infClass.getName());
packerCtClass.addInterface(infCtClass);
}
protected Class<?> getArrayBaseType(Class<?> type) {
if (type.isArray()) {
return getArrayBaseType(type.getComponentType());
} else {
return type;
}
}
protected String arrayTypeToString(Class<?> type) {
StringBuilder sb = new StringBuilder();
int dim = getArrayDim(type);
Class<?> t = getArrayBaseType(type);
sb.append(t.getName());
for (int i = 0; i < dim; ++i) {
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
}
return sb.toString();
protected void addDefaultConstructor(CtClass enhancedCtClass)
throws CannotCompileException {
CtConstructor newCtCons = CtNewConstructor
.defaultConstructor(enhancedCtClass);
enhancedCtClass.addConstructor(newCtCons);
}
public void insertValueInsertion(StringBuilder sb, String expr) {
// = expr
sb.append(CHAR_NAME_SPACE);
sb.append(CHAR_NAME_EQUAL);
sb.append(CHAR_NAME_SPACE);
sb.append(expr);
protected void addTemplateArrayField(CtClass newCtClass)
throws NotFoundException, CannotCompileException {
CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
CtField tmplsField = acsCtClass
.getDeclaredField(VARIABLE_NAME_TEMPLATES);
CtField tmplsField2 = new CtField(tmplsField.getType(), tmplsField
.getName(), newCtClass);
newCtClass.addField(tmplsField2);
}
public void insertInsertion(StringBuilder sb) {
// =
sb.append(CHAR_NAME_SPACE);
sb.append(CHAR_NAME_EQUAL);
sb.append(CHAR_NAME_SPACE);
protected void addSetTemplatesMethod(CtClass newCtClass)
throws NotFoundException, CannotCompileException {
CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
CtMethod settmplsMethod = acsCtClass
.getDeclaredMethod(METHOD_NAME_SETTEMPLATES);
CtMethod settmplsMethod2 = CtNewMethod.copy(settmplsMethod, newCtClass,
null);
newCtClass.addMethod(settmplsMethod2);
}
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);
}
public void insertConsCall(StringBuilder sb, Class<?> type, String expr) {
// new tname(expr)
sb.append(KEYWORD_NEW);
sb.append(CHAR_NAME_SPACE);
sb.append(type.getName());
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
if (expr != null) {
sb.append(expr);
}
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
}
public void insertMethodCall(StringBuilder sb, String tname, String mname,
String[] anames) {
// tname.mname(anames[0], anames[1], ...)
int len = anames.length;
sb.append(tname);
sb.append(CHAR_NAME_DOT);
sb.append(mname);
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
for (int i = 0; i < len; ++i) {
sb.append(anames[i]);
if (i + 1 != len) {
sb.append(CHAR_NAME_COMMA);
sb.append(CHAR_NAME_SPACE);
}
}
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
}
public void insertTypeCast(StringBuilder sb, Class<?> type) {
// (type)
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
sb.append(type.getName());
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
}
public void insertTypeCast(StringBuilder sb, Class<?> type, String varName) {
// ((type)var)
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
sb.append(type.getName());
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
sb.append(varName);
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
}
public void insertReturnStat(StringBuilder sb, String expr) {
// return expr
sb.append(KEYWORD_RETURN);
sb.append(CHAR_NAME_SPACE);
sb.append(expr);
}
public void insertTypeConvToObjectType(StringBuilder sb, Class<?> type,
String expr) throws DynamicCodeGenException {
if (type.isPrimitive()) { // primitive type
insertConsCall(sb, primitiveTypeToWrapperType(type), expr);
} else { // reference type
sb.append(expr);
}
}
public void insertTryCatchBlocks(StringBuilder sb, String tryBody,
List<Class<?>> types, List<String> names, List<String> catchBodies) {
int len = types.size();
sb.append(KEYWORD_TRY);
sb.append(CHAR_NAME_SPACE);
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
sb.append(tryBody);
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
for (int i = 0; i < len; ++i) {
sb.append(KEYWORD_CATCH);
sb.append(CHAR_NAME_SPACE);
sb.append(CHAR_NAME_LEFT_PARENTHESIS);
sb.append(types.get(i).getName());
sb.append(CHAR_NAME_SPACE);
sb.append(names.get(i));
sb.append(CHAR_NAME_RIGHT_PARENTHESIS);
sb.append(CHAR_NAME_SPACE);
sb.append(CHAR_NAME_LEFT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
sb.append(catchBodies.get(i));
sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET);
sb.append(CHAR_NAME_SPACE);
}
}
public Class<?> primitiveTypeToWrapperType(Class<?> type) {
protected Class<?> getPrimToWrapperType(Class<?> type) {
if (type.equals(boolean.class)) {
return Boolean.class;
} else if (type.equals(byte.class)) {
@@ -298,7 +163,7 @@ public class DynamicCodeGenBase implements BasicConstants {
throw new MessageTypeException("Type error: " + type.getName());
}
}
public String getPrimTypeValueMethodName(Class<?> type) {
if (type.equals(boolean.class)) {
return METHOD_NAME_BOOLEANVALUE;
@@ -318,6 +183,7 @@ public class DynamicCodeGenBase implements BasicConstants {
throw new MessageTypeException("Type error: " + type.getName());
}
}
public String getUnpackMethodName(Class<?> c)
throws DynamicCodeGenException {
if (c.equals(boolean.class) || c.equals(Boolean.class)) {
@@ -404,7 +270,7 @@ public class DynamicCodeGenBase implements BasicConstants {
return (Template) CustomConverter.get(c);
} else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) {
// @MessagePackMessage
Template tmpl = DynamicCodeGenTemplate.create(c);
Template tmpl = DynamicTemplate.create(c);
CustomMessage.registerTemplate(c, tmpl);
return tmpl;
} else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) {
@@ -416,7 +282,7 @@ public class DynamicCodeGenBase implements BasicConstants {
} else if (CustomMessage.isAnnotated(c,
MessagePackOrdinalEnum.class)) {
// @MessagePackOrdinalEnum
Template tmpl = DynamicCodeGenOrdinalEnumTemplate.create(c);
Template tmpl = DynamicOrdinalEnumTemplate.create(c);
CustomMessage.registerTemplate(c, tmpl);
return tmpl;
} else {
@@ -450,4 +316,75 @@ public class DynamicCodeGenBase implements BasicConstants {
+ t.getClass().getName());
}
}
protected int getArrayDim(Class<?> type) {
if (type.isArray()) {
return 1 + getArrayDim(type.getComponentType());
} else {
return 0;
}
}
protected Class<?> getArrayBaseType(Class<?> type) {
if (type.isArray()) {
return getArrayBaseType(type.getComponentType());
} else {
return type;
}
}
protected String arrayTypeToString(Class<?> type) {
StringBuilder sb = new StringBuilder();
int dim = getArrayDim(type);
Class<?> t = getArrayBaseType(type);
sb.append(t.getName());
for (int i = 0; i < dim; ++i) {
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
}
return sb.toString();
}
protected String classToString(Class<?> type) {
if (type.isArray()) {
return arrayTypeToString(type);
} else {
return type.getName();
}
}
protected CtClass classToCtClass(Class<?> type) throws NotFoundException {
if (type.equals(void.class)) {
return CtClass.voidType;
} else if (type.isPrimitive()) {
if (type.equals(boolean.class)) {
return CtClass.booleanType;
} else if (type.equals(byte.class)) {
return CtClass.byteType;
} else if (type.equals(char.class)) {
return CtClass.charType;
} else if (type.equals(short.class)) {
return CtClass.shortType;
} else if (type.equals(int.class)) {
return CtClass.intType;
} else if (type.equals(long.class)) {
return CtClass.longType;
} else if (type.equals(float.class)) {
return CtClass.floatType;
} else if (type.equals(double.class)) {
return CtClass.doubleType;
} else {
throw new MessageTypeException("Fatal error: " + type.getName());
}
} else if (type.isArray()) {
return pool.get(arrayTypeToString(type));
} else {
return pool.get(type.getName());
}
}
protected Class<?> createClass(CtClass newCtClass)
throws CannotCompileException {
return newCtClass.toClass(null, null);
}
}

4
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenConverter.java → java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java
View File

@@ -2,8 +2,8 @@ package org.msgpack.util.codegen;
import org.msgpack.MessageConverter;
public class DynamicCodeGenConverter {
public class DynamicConverter {
public static MessageConverter create(Class<?> c) {
return DynamicCodeGenTemplate.create(c);
return DynamicTemplate.create(c);
}
}

2
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumConverter.java → java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumConverter.java
View File

@@ -2,7 +2,7 @@ package org.msgpack.util.codegen;
import org.msgpack.MessageConverter;
public class DynamicCodeGenOrdinalEnumConverter {
public class DynamicOrdinalEnumConverter {
public static MessageConverter create(Class<?> c) {
try {
DynamicCodeGen gen = DynamicCodeGen.getInstance();

2
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumPacker.java → java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumPacker.java
View File

@@ -2,7 +2,7 @@ package org.msgpack.util.codegen;
import org.msgpack.MessagePacker;
public class DynamicCodeGenOrdinalEnumPacker {
public class DynamicOrdinalEnumPacker {
public static MessagePacker create(Class<?> c) {
try {
DynamicCodeGen gen = DynamicCodeGen.getInstance();

2
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumTemplate.java → java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumTemplate.java
View File

@@ -2,7 +2,7 @@ package org.msgpack.util.codegen;
import org.msgpack.Template;
public class DynamicCodeGenOrdinalEnumTemplate {
public class DynamicOrdinalEnumTemplate {
public static Template create(Class<?> c) {
try {
DynamicCodeGen gen = DynamicCodeGen.getInstance();

2
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumUnpacker.java → java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumUnpacker.java
View File

@@ -2,7 +2,7 @@ package org.msgpack.util.codegen;
import org.msgpack.MessageUnpacker;
public class DynamicCodeGenOrdinalEnumUnpacker {
public class DynamicOrdinalEnumUnpacker {
public static MessageUnpacker create(Class<?> c) {
try {
DynamicCodeGen gen = DynamicCodeGen.getInstance();

2
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenPacker.java → java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java
View File

@@ -2,7 +2,7 @@ package org.msgpack.util.codegen;
import org.msgpack.MessagePacker;
public class DynamicCodeGenPacker {
public class DynamicPacker {
public static MessagePacker create(Class<?> c) {
try {

2
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenTemplate.java → java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java
View File

@@ -3,7 +3,7 @@ package org.msgpack.util.codegen;
import org.msgpack.Template;
import org.msgpack.util.codegen.DynamicCodeGenBase.TemplateAccessor;
public class DynamicCodeGenTemplate {
public class DynamicTemplate {
public static Template create(Class<?> c) {
try {
DynamicCodeGen gen = DynamicCodeGen.getInstance();

4
java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenUnpacker.java → java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java
View File

@@ -2,8 +2,8 @@ package org.msgpack.util.codegen;
import org.msgpack.MessageUnpacker;
public class DynamicCodeGenUnpacker {
public class DynamicUnpacker {
public static MessageUnpacker create(Class<?> c) {
return DynamicCodeGenTemplate.create(c);
return DynamicTemplate.create(c);
}
}

82
java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerConverter.java
View File

@@ -36,11 +36,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f5 = 5;
src.f6 = false;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(PrimitiveTypeFieldsClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(PrimitiveTypeFieldsClass.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
@@ -85,11 +85,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f8 = "8";
src.f9 = new byte[] { 0x01, 0x02 };
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(GeneralReferenceTypeFieldsClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(GeneralReferenceTypeFieldsClass.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
@@ -146,11 +146,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
slnt.f1 = "muga";
src.f4.add(slnt);
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleListTypes.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleListTypes.class);
Template tmpl = DynamicTemplate.create(SampleListTypes.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext());
@@ -217,11 +217,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f2.put("k2", 2);
src.f2.put("k3", 3);
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleMapTypes.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleMapTypes.class);
Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext());
@@ -261,28 +261,28 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testDefaultConstructorModifiers01() throws Exception {
try {
DynamicCodeGenPacker.create(NoDefaultConstructorClass.class);
DynamicPacker.create(NoDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(PrivateDefaultConstructorClass.class);
DynamicPacker.create(PrivateDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(ProtectedDefaultConstructorClass.class);
DynamicPacker.create(ProtectedDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(PackageDefaultConstructorClass.class);
DynamicPacker.create(PackageDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -293,21 +293,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testDefaultConstructorModifiers02() throws Exception {
try {
DynamicCodeGenTemplate.create(NoDefaultConstructorClass.class);
DynamicTemplate.create(NoDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenTemplate.create(PrivateDefaultConstructorClass.class);
DynamicTemplate.create(PrivateDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenTemplate
DynamicTemplate
.create(ProtectedDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
@@ -315,7 +315,7 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
}
assertTrue(true);
try {
DynamicCodeGenTemplate.create(PackageDefaultConstructorClass.class);
DynamicTemplate.create(PackageDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -346,21 +346,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testClassModifiers01() throws Exception {
try {
DynamicCodeGenPacker.create(PrivateModifierClass.class);
DynamicPacker.create(PrivateModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(ProtectedModifierClass.class);
DynamicPacker.create(ProtectedModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(PackageModifierClass.class);
DynamicPacker.create(PackageModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -371,21 +371,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testClassModifiers02() throws Exception {
try {
DynamicCodeGenTemplate.create(PrivateModifierClass.class);
DynamicTemplate.create(PrivateModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenTemplate.create(ProtectedModifierClass.class);
DynamicTemplate.create(ProtectedModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenTemplate.create(PackageModifierClass.class);
DynamicTemplate.create(PackageModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -407,14 +407,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testFinalClassAndAbstractClass01() throws Exception {
try {
DynamicCodeGenPacker.create(FinalModifierClass.class);
DynamicPacker.create(FinalModifierClass.class);
assertTrue(true);
} catch (DynamicCodeGenException e) {
fail();
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(AbstractModifierClass.class);
DynamicPacker.create(AbstractModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -425,14 +425,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testFinalClassAndAbstractClass02() throws Exception {
try {
DynamicCodeGenTemplate.create(FinalModifierClass.class);
DynamicTemplate.create(FinalModifierClass.class);
assertTrue(true);
} catch (DynamicCodeGenException e) {
fail();
}
assertTrue(true);
try {
DynamicCodeGenTemplate.create(AbstractModifierClass.class);
DynamicTemplate.create(AbstractModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -449,14 +449,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testInterfaceAndEnumType01() throws Exception {
try {
DynamicCodeGenPacker.create(SampleInterface.class);
DynamicPacker.create(SampleInterface.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(SampleEnum.class);
DynamicPacker.create(SampleEnum.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -467,7 +467,7 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testInterfaceType() throws Exception {
try {
DynamicCodeGenTemplate.create(SampleInterface.class);
DynamicTemplate.create(SampleInterface.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -484,11 +484,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f0 = 0;
src.f1 = SampleEnum.ONE;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleEnumFieldClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(SampleEnumFieldClass.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
@@ -521,11 +521,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f3 = 3;
src.f4 = 4;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(FieldModifiersClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(FieldModifiersClass.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
@@ -553,14 +553,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test
public void testNestedFieldClass() throws Exception {
MessagePacker packer2 = DynamicCodeGenPacker.create(NestedClass.class);
MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
CustomPacker.register(NestedClass.class, packer2);
MessagePacker packer1 = DynamicCodeGenPacker.create(BaseClass.class);
MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
CustomPacker.register(BaseClass.class, packer1);
Template tmpl2 = DynamicCodeGenTemplate.create(NestedClass.class);
Template tmpl2 = DynamicTemplate.create(NestedClass.class);
CustomUnpacker.register(NestedClass.class, tmpl2);
CustomConverter.register(NestedClass.class, tmpl2);
Template tmpl1 = DynamicCodeGenTemplate.create(BaseClass.class);
Template tmpl1 = DynamicTemplate.create(BaseClass.class);
CustomUnpacker.register(BaseClass.class, tmpl1);
CustomConverter.register(BaseClass.class, tmpl1);
BaseClass src = new BaseClass();
@@ -604,14 +604,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src2.f2 = 2;
src.f1 = src2;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker.create(BaseClass2.class);
MessagePacker packer = DynamicPacker.create(BaseClass2.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext());
MessagePackObject mpo = it.next();
Template tmpl = DynamicCodeGenTemplate.create(BaseClass2.class);
Template tmpl = DynamicTemplate.create(BaseClass2.class);
BaseClass2 dst = (BaseClass2) tmpl.convert(mpo);
assertTrue(src.f0 == dst.f0);
assertTrue(src.f1.f2 == dst.f1.f2);
@@ -645,11 +645,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f8 = 8;
src.f9 = 9;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleSubClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleSubClass.class);
Template tmpl = DynamicTemplate.create(SampleSubClass.class);
Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext());

80
java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerUnpacker.java
View File

@@ -35,11 +35,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f5 = 5;
src.f6 = false;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(PrimitiveTypeFieldsClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(PrimitiveTypeFieldsClass.class);
PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl
.unpack(new Unpacker(in));
@@ -79,11 +79,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f8 = "8";
src.f9 = new byte[] { 0x01, 0x02 };
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(GeneralReferenceTypeFieldsClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(GeneralReferenceTypeFieldsClass.class);
GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
.unpack(new Unpacker(in));
@@ -135,11 +135,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
slnt.f1 = "muga";
src.f4.add(slnt);
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleListTypes.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleListTypes.class);
Template tmpl = DynamicTemplate.create(SampleListTypes.class);
SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in));
assertEquals(src.f0.size(), dst.f0.size());
assertEquals(src.f1.size(), dst.f1.size());
@@ -201,11 +201,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f2.put("k2", 2);
src.f2.put("k3", 3);
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleMapTypes.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleMapTypes.class);
Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in));
assertEquals(src.f0.size(), dst.f0.size());
assertEquals(src.f1.size(), dst.f1.size());
@@ -240,28 +240,28 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testDefaultConstructorModifiers01() throws Exception {
try {
DynamicCodeGenPacker.create(NoDefaultConstructorClass.class);
DynamicPacker.create(NoDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(PrivateDefaultConstructorClass.class);
DynamicPacker.create(PrivateDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(ProtectedDefaultConstructorClass.class);
DynamicPacker.create(ProtectedDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(PackageDefaultConstructorClass.class);
DynamicPacker.create(PackageDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -272,21 +272,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testDefaultConstructorModifiers02() throws Exception {
try {
DynamicCodeGenUnpacker.create(NoDefaultConstructorClass.class);
DynamicUnpacker.create(NoDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenUnpacker.create(PrivateDefaultConstructorClass.class);
DynamicUnpacker.create(PrivateDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenUnpacker
DynamicUnpacker
.create(ProtectedDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
@@ -294,7 +294,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
}
assertTrue(true);
try {
DynamicCodeGenUnpacker.create(PackageDefaultConstructorClass.class);
DynamicUnpacker.create(PackageDefaultConstructorClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -325,21 +325,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testClassModifiers01() throws Exception {
try {
DynamicCodeGenPacker.create(PrivateModifierClass.class);
DynamicPacker.create(PrivateModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(ProtectedModifierClass.class);
DynamicPacker.create(ProtectedModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(PackageModifierClass.class);
DynamicPacker.create(PackageModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -350,21 +350,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testClassModifiers02() throws Exception {
try {
DynamicCodeGenUnpacker.create(PrivateModifierClass.class);
DynamicUnpacker.create(PrivateModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenUnpacker.create(ProtectedModifierClass.class);
DynamicUnpacker.create(ProtectedModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
}
assertTrue(true);
try {
DynamicCodeGenUnpacker.create(PackageModifierClass.class);
DynamicUnpacker.create(PackageModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -386,14 +386,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testFinalClassAndAbstractClass01() throws Exception {
try {
DynamicCodeGenPacker.create(FinalModifierClass.class);
DynamicPacker.create(FinalModifierClass.class);
assertTrue(true);
} catch (DynamicCodeGenException e) {
fail();
}
assertTrue(true);
try {
DynamicCodeGenPacker.create(AbstractModifierClass.class);
DynamicPacker.create(AbstractModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -404,14 +404,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testFinalClassAndAbstractClass02() throws Exception {
try {
DynamicCodeGenUnpacker.create(FinalModifierClass.class);
DynamicUnpacker.create(FinalModifierClass.class);
assertTrue(true);
} catch (DynamicCodeGenException e) {
fail();
}
assertTrue(true);
try {
DynamicCodeGenUnpacker.create(AbstractModifierClass.class);
DynamicUnpacker.create(AbstractModifierClass.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -428,7 +428,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testInterfaceType01() throws Exception {
try {
DynamicCodeGenPacker.create(SampleInterface.class);
DynamicPacker.create(SampleInterface.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -439,7 +439,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testInterfaceType02() throws Exception {
try {
DynamicCodeGenUnpacker.create(SampleInterface.class);
DynamicUnpacker.create(SampleInterface.class);
fail();
} catch (DynamicCodeGenException e) {
assertTrue(true);
@@ -456,11 +456,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f0 = 0;
src.f1 = SampleEnum.ONE;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleEnumFieldClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(SampleEnumFieldClass.class);
SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl
.unpack(new Unpacker(in));
@@ -490,11 +490,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f3 = 3;
src.f4 = 4;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(FieldModifiersClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate
Template tmpl = DynamicTemplate
.create(FieldModifiersClass.class);
FieldModifiersClass dst = (FieldModifiersClass) tmpl
.unpack(new Unpacker(in));
@@ -518,14 +518,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test
public void testNestedFieldClass() throws Exception {
MessagePacker packer2 = DynamicCodeGenPacker.create(NestedClass.class);
MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
CustomPacker.register(NestedClass.class, packer2);
MessagePacker packer1 = DynamicCodeGenPacker.create(BaseClass.class);
MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
CustomPacker.register(BaseClass.class, packer1);
Template tmpl2 = DynamicCodeGenTemplate.create(NestedClass.class);
Template tmpl2 = DynamicTemplate.create(NestedClass.class);
CustomUnpacker.register(NestedClass.class, tmpl2);
CustomConverter.register(NestedClass.class, tmpl2);
Template tmpl1 = DynamicCodeGenTemplate.create(BaseClass.class);
Template tmpl1 = DynamicTemplate.create(BaseClass.class);
CustomUnpacker.register(BaseClass.class, tmpl1);
CustomConverter.register(BaseClass.class, tmpl1);
BaseClass src = new BaseClass();
@@ -564,10 +564,10 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src2.f2 = 2;
src.f1 = src2;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker.create(BaseClass2.class);
MessagePacker packer = DynamicPacker.create(BaseClass2.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(BaseClass2.class);
Template tmpl = DynamicTemplate.create(BaseClass2.class);
BaseClass2 dst = (BaseClass2) tmpl.unpack(new Unpacker(in));
assertTrue(src.f0 == dst.f0);
assertTrue(src.f1.f2 == dst.f1.f2);
@@ -600,11 +600,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f8 = 8;
src.f9 = 9;
ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker
MessagePacker packer = DynamicPacker
.create(SampleSubClass.class);
packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleSubClass.class);
Template tmpl = DynamicTemplate.create(SampleSubClass.class);
SampleSubClass dst = (SampleSubClass) tmpl.unpack(new Unpacker(in));
assertTrue(src.f0 == dst.f0);
assertTrue(src.f1 == dst.f1);