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

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

@@ -1,11 +1,24 @@
package org.msgpack.util.codegen; package org.msgpack.util.codegen;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType; import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType; import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type; import java.lang.reflect.Type;
import java.math.BigInteger; import java.math.BigInteger;
import java.util.List; import java.util.List;
import java.util.Map; 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.CustomConverter;
import org.msgpack.CustomMessage; import org.msgpack.CustomMessage;
@@ -18,7 +31,7 @@ import org.msgpack.annotation.MessagePackOrdinalEnum;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
public class DynamicCodeGenBase implements BasicConstants { public class DynamicCodeGenBase implements Constants {
public static interface TemplateAccessor { public static interface TemplateAccessor {
void setTemplates(Template[] templates); void setTemplates(Template[] templates);
} }
@@ -34,252 +47,104 @@ public class DynamicCodeGenBase implements BasicConstants {
private static Logger LOG = LoggerFactory private static Logger LOG = LoggerFactory
.getLogger(DynamicCodeGenBase.class); .getLogger(DynamicCodeGenBase.class);
private static AtomicInteger COUNTER = new AtomicInteger(0);
protected static int inc() {
return COUNTER.addAndGet(1);
}
protected ClassPool pool;
public DynamicCodeGenBase() { public DynamicCodeGenBase() {
pool = ClassPool.getDefault();
} }
public void addPublicFieldDecl(StringBuilder sb, Class<?> type, String name) { protected void checkTypeValidation(Class<?> type) {
addPublicFieldDecl(sb, type, name, 0); DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
+ type.getName());
LOG.error(e.getMessage(), e);
throw e;
} }
public void addPublicFieldDecl(StringBuilder sb, Class<?> type, protected void throwTypeValidationException(Class<?> origClass,
String name, int dim) { String message) throws DynamicCodeGenException {
sb.append(KEYWORD_MODIFIER_PUBLIC); DynamicCodeGenException e = new DynamicCodeGenException(message + ": "
sb.append(CHAR_NAME_SPACE); + origClass.getName());
sb.append(type.getName()); LOG.error(e.getMessage(), e);
for (int i = 0; i < dim; ++i) { throw e;
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET);
}
sb.append(CHAR_NAME_SPACE);
sb.append(name);
} }
public void addPublicMethodDecl(StringBuilder sb, String mname, protected void checkDefaultConstructorValidation(Class<?> type) {
Class<?> returnType, Class<?>[] paramTypes, String[] anames, DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
Class<?>[] exceptTypes, String methodBody) { + type.getName());
int[] dims = new int[paramTypes.length]; LOG.error(e.getMessage(), e);
for (int i = 0; i < paramTypes.length; ++i) { throw e;
dims[i] = 0;
}
addPublicMethodDecl(sb, mname, returnType, paramTypes, dims, anames,
exceptTypes, methodBody);
} }
public void addPublicMethodDecl(StringBuilder sb, String mname, protected void throwConstructorValidationException(Class<?> origClass) {
Class<?> returnType, Class<?>[] paramTypes, int[] dims, DynamicCodeGenException e = new DynamicCodeGenException(
String[] anames, Class<?>[] exceptTypes, String methodBody) { "it must have a public zero-argument constructor: "
sb.append(KEYWORD_MODIFIER_PUBLIC); + origClass.getName());
sb.append(CHAR_NAME_SPACE); LOG.error(e.getMessage(), e);
sb.append(returnType.getName()); throw e;
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);
} }
public void insertSemicolon(StringBuilder sb) { protected void throwFieldValidationException(Field f) {
// ; DynamicCodeGenException e = new DynamicCodeGenException(
sb.append(CHAR_NAME_SEMICOLON); "it must be a public field: " + f.getName());
sb.append(CHAR_NAME_SPACE); LOG.debug(e.getMessage(), e);
throw e;
} }
public void insertLocalVariableDecl(StringBuilder sb, Class<?> type, protected static void throwMethodValidationException(Method method,
String name) { String message) throws DynamicCodeGenException {
// int lv DynamicCodeGenException e = new DynamicCodeGenException(message + ": "
insertLocalVariableDecl(sb, type, name, 0); + method.getName());
LOG.error(e.getMessage(), e);
throw e;
} }
public void insertLocalVariableDecl(StringBuilder sb, Class<?> type, protected CtClass makeClass(String name) throws NotFoundException {
String name, int dim) { DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: "
// int[] lv + name);
int dim0 = dim + getArrayDim(type); LOG.error(e.getMessage(), e);
Class<?> type0 = getArrayBaseType(type); throw e;
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 int getArrayDim(Class<?> type) { protected void setInterface(CtClass packerCtClass, Class<?> infClass)
if (type.isArray()) { throws NotFoundException {
return 1 + getArrayDim(type.getComponentType()); CtClass infCtClass = pool.get(infClass.getName());
} else { packerCtClass.addInterface(infCtClass);
return 0;
}
} }
protected Class<?> getArrayBaseType(Class<?> type) { protected void addDefaultConstructor(CtClass enhancedCtClass)
if (type.isArray()) { throws CannotCompileException {
return getArrayBaseType(type.getComponentType()); CtConstructor newCtCons = CtNewConstructor
} else { .defaultConstructor(enhancedCtClass);
return type; enhancedCtClass.addConstructor(newCtCons);
}
} }
protected String arrayTypeToString(Class<?> type) { protected void addTemplateArrayField(CtClass newCtClass)
StringBuilder sb = new StringBuilder(); throws NotFoundException, CannotCompileException {
int dim = getArrayDim(type); CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
Class<?> t = getArrayBaseType(type); CtField tmplsField = acsCtClass
sb.append(t.getName()); .getDeclaredField(VARIABLE_NAME_TEMPLATES);
for (int i = 0; i < dim; ++i) { CtField tmplsField2 = new CtField(tmplsField.getType(), tmplsField
sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET); .getName(), newCtClass);
sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); newCtClass.addField(tmplsField2);
}
return sb.toString();
} }
public void insertValueInsertion(StringBuilder sb, String expr) { protected void addSetTemplatesMethod(CtClass newCtClass)
// = expr throws NotFoundException, CannotCompileException {
sb.append(CHAR_NAME_SPACE); CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
sb.append(CHAR_NAME_EQUAL); CtMethod settmplsMethod = acsCtClass
sb.append(CHAR_NAME_SPACE); .getDeclaredMethod(METHOD_NAME_SETTEMPLATES);
sb.append(expr); CtMethod settmplsMethod2 = CtNewMethod.copy(settmplsMethod, newCtClass,
null);
newCtClass.addMethod(settmplsMethod2);
} }
public void insertInsertion(StringBuilder sb) { protected Class<?> getPrimToWrapperType(Class<?> type) {
// =
sb.append(CHAR_NAME_SPACE);
sb.append(CHAR_NAME_EQUAL);
sb.append(CHAR_NAME_SPACE);
}
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) {
if (type.equals(boolean.class)) { if (type.equals(boolean.class)) {
return Boolean.class; return Boolean.class;
} else if (type.equals(byte.class)) { } else if (type.equals(byte.class)) {
@@ -318,6 +183,7 @@ public class DynamicCodeGenBase implements BasicConstants {
throw new MessageTypeException("Type error: " + type.getName()); throw new MessageTypeException("Type error: " + type.getName());
} }
} }
public String getUnpackMethodName(Class<?> c) public String getUnpackMethodName(Class<?> c)
throws DynamicCodeGenException { throws DynamicCodeGenException {
if (c.equals(boolean.class) || c.equals(Boolean.class)) { if (c.equals(boolean.class) || c.equals(Boolean.class)) {
@@ -404,7 +270,7 @@ public class DynamicCodeGenBase implements BasicConstants {
return (Template) CustomConverter.get(c); return (Template) CustomConverter.get(c);
} else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) { } else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) {
// @MessagePackMessage // @MessagePackMessage
Template tmpl = DynamicCodeGenTemplate.create(c); Template tmpl = DynamicTemplate.create(c);
CustomMessage.registerTemplate(c, tmpl); CustomMessage.registerTemplate(c, tmpl);
return tmpl; return tmpl;
} else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) { } else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) {
@@ -416,7 +282,7 @@ public class DynamicCodeGenBase implements BasicConstants {
} else if (CustomMessage.isAnnotated(c, } else if (CustomMessage.isAnnotated(c,
MessagePackOrdinalEnum.class)) { MessagePackOrdinalEnum.class)) {
// @MessagePackOrdinalEnum // @MessagePackOrdinalEnum
Template tmpl = DynamicCodeGenOrdinalEnumTemplate.create(c); Template tmpl = DynamicOrdinalEnumTemplate.create(c);
CustomMessage.registerTemplate(c, tmpl); CustomMessage.registerTemplate(c, tmpl);
return tmpl; return tmpl;
} else { } else {
@@ -450,4 +316,75 @@ public class DynamicCodeGenBase implements BasicConstants {
+ t.getClass().getName()); + 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; import org.msgpack.MessageConverter;
public class DynamicCodeGenConverter { public class DynamicConverter {
public static MessageConverter create(Class<?> c) { 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; import org.msgpack.MessageConverter;
public class DynamicCodeGenOrdinalEnumConverter { public class DynamicOrdinalEnumConverter {
public static MessageConverter create(Class<?> c) { public static MessageConverter create(Class<?> c) {
try { try {
DynamicCodeGen gen = DynamicCodeGen.getInstance(); 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; import org.msgpack.MessagePacker;
public class DynamicCodeGenOrdinalEnumPacker { public class DynamicOrdinalEnumPacker {
public static MessagePacker create(Class<?> c) { public static MessagePacker create(Class<?> c) {
try { try {
DynamicCodeGen gen = DynamicCodeGen.getInstance(); 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; import org.msgpack.Template;
public class DynamicCodeGenOrdinalEnumTemplate { public class DynamicOrdinalEnumTemplate {
public static Template create(Class<?> c) { public static Template create(Class<?> c) {
try { try {
DynamicCodeGen gen = DynamicCodeGen.getInstance(); 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; import org.msgpack.MessageUnpacker;
public class DynamicCodeGenOrdinalEnumUnpacker { public class DynamicOrdinalEnumUnpacker {
public static MessageUnpacker create(Class<?> c) { public static MessageUnpacker create(Class<?> c) {
try { try {
DynamicCodeGen gen = DynamicCodeGen.getInstance(); 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; import org.msgpack.MessagePacker;
public class DynamicCodeGenPacker { public class DynamicPacker {
public static MessagePacker create(Class<?> c) { public static MessagePacker create(Class<?> c) {
try { 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.Template;
import org.msgpack.util.codegen.DynamicCodeGenBase.TemplateAccessor; import org.msgpack.util.codegen.DynamicCodeGenBase.TemplateAccessor;
public class DynamicCodeGenTemplate { public class DynamicTemplate {
public static Template create(Class<?> c) { public static Template create(Class<?> c) {
try { try {
DynamicCodeGen gen = DynamicCodeGen.getInstance(); 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; import org.msgpack.MessageUnpacker;
public class DynamicCodeGenUnpacker { public class DynamicUnpacker {
public static MessageUnpacker create(Class<?> c) { 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.f5 = 5;
src.f6 = false; src.f6 = false;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(PrimitiveTypeFieldsClass.class); .create(PrimitiveTypeFieldsClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(PrimitiveTypeFieldsClass.class); .create(PrimitiveTypeFieldsClass.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
@@ -85,11 +85,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f8 = "8"; src.f8 = "8";
src.f9 = new byte[] { 0x01, 0x02 }; src.f9 = new byte[] { 0x01, 0x02 };
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(GeneralReferenceTypeFieldsClass.class); .create(GeneralReferenceTypeFieldsClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(GeneralReferenceTypeFieldsClass.class); .create(GeneralReferenceTypeFieldsClass.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
@@ -146,11 +146,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
slnt.f1 = "muga"; slnt.f1 = "muga";
src.f4.add(slnt); src.f4.add(slnt);
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleListTypes.class); .create(SampleListTypes.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleListTypes.class); Template tmpl = DynamicTemplate.create(SampleListTypes.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext()); assertTrue(it.hasNext());
@@ -217,11 +217,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f2.put("k2", 2); src.f2.put("k2", 2);
src.f2.put("k3", 3); src.f2.put("k3", 3);
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleMapTypes.class); .create(SampleMapTypes.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleMapTypes.class); Template tmpl = DynamicTemplate.create(SampleMapTypes.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext()); assertTrue(it.hasNext());
@@ -261,28 +261,28 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testDefaultConstructorModifiers01() throws Exception { public void testDefaultConstructorModifiers01() throws Exception {
try { try {
DynamicCodeGenPacker.create(NoDefaultConstructorClass.class); DynamicPacker.create(NoDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(PrivateDefaultConstructorClass.class); DynamicPacker.create(PrivateDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(ProtectedDefaultConstructorClass.class); DynamicPacker.create(ProtectedDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(PackageDefaultConstructorClass.class); DynamicPacker.create(PackageDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -293,21 +293,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testDefaultConstructorModifiers02() throws Exception { public void testDefaultConstructorModifiers02() throws Exception {
try { try {
DynamicCodeGenTemplate.create(NoDefaultConstructorClass.class); DynamicTemplate.create(NoDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenTemplate.create(PrivateDefaultConstructorClass.class); DynamicTemplate.create(PrivateDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenTemplate DynamicTemplate
.create(ProtectedDefaultConstructorClass.class); .create(ProtectedDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
@@ -315,7 +315,7 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenTemplate.create(PackageDefaultConstructorClass.class); DynamicTemplate.create(PackageDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -346,21 +346,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testClassModifiers01() throws Exception { public void testClassModifiers01() throws Exception {
try { try {
DynamicCodeGenPacker.create(PrivateModifierClass.class); DynamicPacker.create(PrivateModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(ProtectedModifierClass.class); DynamicPacker.create(ProtectedModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(PackageModifierClass.class); DynamicPacker.create(PackageModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -371,21 +371,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testClassModifiers02() throws Exception { public void testClassModifiers02() throws Exception {
try { try {
DynamicCodeGenTemplate.create(PrivateModifierClass.class); DynamicTemplate.create(PrivateModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenTemplate.create(ProtectedModifierClass.class); DynamicTemplate.create(ProtectedModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenTemplate.create(PackageModifierClass.class); DynamicTemplate.create(PackageModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -407,14 +407,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testFinalClassAndAbstractClass01() throws Exception { public void testFinalClassAndAbstractClass01() throws Exception {
try { try {
DynamicCodeGenPacker.create(FinalModifierClass.class); DynamicPacker.create(FinalModifierClass.class);
assertTrue(true); assertTrue(true);
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
fail(); fail();
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(AbstractModifierClass.class); DynamicPacker.create(AbstractModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -425,14 +425,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testFinalClassAndAbstractClass02() throws Exception { public void testFinalClassAndAbstractClass02() throws Exception {
try { try {
DynamicCodeGenTemplate.create(FinalModifierClass.class); DynamicTemplate.create(FinalModifierClass.class);
assertTrue(true); assertTrue(true);
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
fail(); fail();
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenTemplate.create(AbstractModifierClass.class); DynamicTemplate.create(AbstractModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -449,14 +449,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testInterfaceAndEnumType01() throws Exception { public void testInterfaceAndEnumType01() throws Exception {
try { try {
DynamicCodeGenPacker.create(SampleInterface.class); DynamicPacker.create(SampleInterface.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(SampleEnum.class); DynamicPacker.create(SampleEnum.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -467,7 +467,7 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testInterfaceType() throws Exception { public void testInterfaceType() throws Exception {
try { try {
DynamicCodeGenTemplate.create(SampleInterface.class); DynamicTemplate.create(SampleInterface.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -484,11 +484,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f0 = 0; src.f0 = 0;
src.f1 = SampleEnum.ONE; src.f1 = SampleEnum.ONE;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleEnumFieldClass.class); .create(SampleEnumFieldClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(SampleEnumFieldClass.class); .create(SampleEnumFieldClass.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
@@ -521,11 +521,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f3 = 3; src.f3 = 3;
src.f4 = 4; src.f4 = 4;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(FieldModifiersClass.class); .create(FieldModifiersClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(FieldModifiersClass.class); .create(FieldModifiersClass.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
@@ -553,14 +553,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
@Test @Test
public void testNestedFieldClass() throws Exception { public void testNestedFieldClass() throws Exception {
MessagePacker packer2 = DynamicCodeGenPacker.create(NestedClass.class); MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
CustomPacker.register(NestedClass.class, packer2); CustomPacker.register(NestedClass.class, packer2);
MessagePacker packer1 = DynamicCodeGenPacker.create(BaseClass.class); MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
CustomPacker.register(BaseClass.class, packer1); CustomPacker.register(BaseClass.class, packer1);
Template tmpl2 = DynamicCodeGenTemplate.create(NestedClass.class); Template tmpl2 = DynamicTemplate.create(NestedClass.class);
CustomUnpacker.register(NestedClass.class, tmpl2); CustomUnpacker.register(NestedClass.class, tmpl2);
CustomConverter.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); CustomUnpacker.register(BaseClass.class, tmpl1);
CustomConverter.register(BaseClass.class, tmpl1); CustomConverter.register(BaseClass.class, tmpl1);
BaseClass src = new BaseClass(); BaseClass src = new BaseClass();
@@ -604,14 +604,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src2.f2 = 2; src2.f2 = 2;
src.f1 = src2; src.f1 = src2;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker.create(BaseClass2.class); MessagePacker packer = DynamicPacker.create(BaseClass2.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext()); assertTrue(it.hasNext());
MessagePackObject mpo = it.next(); MessagePackObject mpo = it.next();
Template tmpl = DynamicCodeGenTemplate.create(BaseClass2.class); Template tmpl = DynamicTemplate.create(BaseClass2.class);
BaseClass2 dst = (BaseClass2) tmpl.convert(mpo); BaseClass2 dst = (BaseClass2) tmpl.convert(mpo);
assertTrue(src.f0 == dst.f0); assertTrue(src.f0 == dst.f0);
assertTrue(src.f1.f2 == dst.f1.f2); assertTrue(src.f1.f2 == dst.f1.f2);
@@ -645,11 +645,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase {
src.f8 = 8; src.f8 = 8;
src.f9 = 9; src.f9 = 9;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleSubClass.class); .create(SampleSubClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate.create(SampleSubClass.class); Template tmpl = DynamicTemplate.create(SampleSubClass.class);
Unpacker pac = new Unpacker(in); Unpacker pac = new Unpacker(in);
Iterator<MessagePackObject> it = pac.iterator(); Iterator<MessagePackObject> it = pac.iterator();
assertTrue(it.hasNext()); 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.f5 = 5;
src.f6 = false; src.f6 = false;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(PrimitiveTypeFieldsClass.class); .create(PrimitiveTypeFieldsClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(PrimitiveTypeFieldsClass.class); .create(PrimitiveTypeFieldsClass.class);
PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl
.unpack(new Unpacker(in)); .unpack(new Unpacker(in));
@@ -79,11 +79,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f8 = "8"; src.f8 = "8";
src.f9 = new byte[] { 0x01, 0x02 }; src.f9 = new byte[] { 0x01, 0x02 };
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(GeneralReferenceTypeFieldsClass.class); .create(GeneralReferenceTypeFieldsClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(GeneralReferenceTypeFieldsClass.class); .create(GeneralReferenceTypeFieldsClass.class);
GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl
.unpack(new Unpacker(in)); .unpack(new Unpacker(in));
@@ -135,11 +135,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
slnt.f1 = "muga"; slnt.f1 = "muga";
src.f4.add(slnt); src.f4.add(slnt);
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleListTypes.class); .create(SampleListTypes.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); 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)); SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in));
assertEquals(src.f0.size(), dst.f0.size()); assertEquals(src.f0.size(), dst.f0.size());
assertEquals(src.f1.size(), dst.f1.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("k2", 2);
src.f2.put("k3", 3); src.f2.put("k3", 3);
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleMapTypes.class); .create(SampleMapTypes.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); 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)); SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in));
assertEquals(src.f0.size(), dst.f0.size()); assertEquals(src.f0.size(), dst.f0.size());
assertEquals(src.f1.size(), dst.f1.size()); assertEquals(src.f1.size(), dst.f1.size());
@@ -240,28 +240,28 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testDefaultConstructorModifiers01() throws Exception { public void testDefaultConstructorModifiers01() throws Exception {
try { try {
DynamicCodeGenPacker.create(NoDefaultConstructorClass.class); DynamicPacker.create(NoDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(PrivateDefaultConstructorClass.class); DynamicPacker.create(PrivateDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(ProtectedDefaultConstructorClass.class); DynamicPacker.create(ProtectedDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(PackageDefaultConstructorClass.class); DynamicPacker.create(PackageDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -272,21 +272,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testDefaultConstructorModifiers02() throws Exception { public void testDefaultConstructorModifiers02() throws Exception {
try { try {
DynamicCodeGenUnpacker.create(NoDefaultConstructorClass.class); DynamicUnpacker.create(NoDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenUnpacker.create(PrivateDefaultConstructorClass.class); DynamicUnpacker.create(PrivateDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenUnpacker DynamicUnpacker
.create(ProtectedDefaultConstructorClass.class); .create(ProtectedDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
@@ -294,7 +294,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenUnpacker.create(PackageDefaultConstructorClass.class); DynamicUnpacker.create(PackageDefaultConstructorClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -325,21 +325,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testClassModifiers01() throws Exception { public void testClassModifiers01() throws Exception {
try { try {
DynamicCodeGenPacker.create(PrivateModifierClass.class); DynamicPacker.create(PrivateModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(ProtectedModifierClass.class); DynamicPacker.create(ProtectedModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(PackageModifierClass.class); DynamicPacker.create(PackageModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -350,21 +350,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testClassModifiers02() throws Exception { public void testClassModifiers02() throws Exception {
try { try {
DynamicCodeGenUnpacker.create(PrivateModifierClass.class); DynamicUnpacker.create(PrivateModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenUnpacker.create(ProtectedModifierClass.class); DynamicUnpacker.create(ProtectedModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenUnpacker.create(PackageModifierClass.class); DynamicUnpacker.create(PackageModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -386,14 +386,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testFinalClassAndAbstractClass01() throws Exception { public void testFinalClassAndAbstractClass01() throws Exception {
try { try {
DynamicCodeGenPacker.create(FinalModifierClass.class); DynamicPacker.create(FinalModifierClass.class);
assertTrue(true); assertTrue(true);
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
fail(); fail();
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenPacker.create(AbstractModifierClass.class); DynamicPacker.create(AbstractModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -404,14 +404,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testFinalClassAndAbstractClass02() throws Exception { public void testFinalClassAndAbstractClass02() throws Exception {
try { try {
DynamicCodeGenUnpacker.create(FinalModifierClass.class); DynamicUnpacker.create(FinalModifierClass.class);
assertTrue(true); assertTrue(true);
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
fail(); fail();
} }
assertTrue(true); assertTrue(true);
try { try {
DynamicCodeGenUnpacker.create(AbstractModifierClass.class); DynamicUnpacker.create(AbstractModifierClass.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -428,7 +428,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testInterfaceType01() throws Exception { public void testInterfaceType01() throws Exception {
try { try {
DynamicCodeGenPacker.create(SampleInterface.class); DynamicPacker.create(SampleInterface.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -439,7 +439,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testInterfaceType02() throws Exception { public void testInterfaceType02() throws Exception {
try { try {
DynamicCodeGenUnpacker.create(SampleInterface.class); DynamicUnpacker.create(SampleInterface.class);
fail(); fail();
} catch (DynamicCodeGenException e) { } catch (DynamicCodeGenException e) {
assertTrue(true); assertTrue(true);
@@ -456,11 +456,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f0 = 0; src.f0 = 0;
src.f1 = SampleEnum.ONE; src.f1 = SampleEnum.ONE;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleEnumFieldClass.class); .create(SampleEnumFieldClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(SampleEnumFieldClass.class); .create(SampleEnumFieldClass.class);
SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl
.unpack(new Unpacker(in)); .unpack(new Unpacker(in));
@@ -490,11 +490,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f3 = 3; src.f3 = 3;
src.f4 = 4; src.f4 = 4;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(FieldModifiersClass.class); .create(FieldModifiersClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
Template tmpl = DynamicCodeGenTemplate Template tmpl = DynamicTemplate
.create(FieldModifiersClass.class); .create(FieldModifiersClass.class);
FieldModifiersClass dst = (FieldModifiersClass) tmpl FieldModifiersClass dst = (FieldModifiersClass) tmpl
.unpack(new Unpacker(in)); .unpack(new Unpacker(in));
@@ -518,14 +518,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
@Test @Test
public void testNestedFieldClass() throws Exception { public void testNestedFieldClass() throws Exception {
MessagePacker packer2 = DynamicCodeGenPacker.create(NestedClass.class); MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
CustomPacker.register(NestedClass.class, packer2); CustomPacker.register(NestedClass.class, packer2);
MessagePacker packer1 = DynamicCodeGenPacker.create(BaseClass.class); MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
CustomPacker.register(BaseClass.class, packer1); CustomPacker.register(BaseClass.class, packer1);
Template tmpl2 = DynamicCodeGenTemplate.create(NestedClass.class); Template tmpl2 = DynamicTemplate.create(NestedClass.class);
CustomUnpacker.register(NestedClass.class, tmpl2); CustomUnpacker.register(NestedClass.class, tmpl2);
CustomConverter.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); CustomUnpacker.register(BaseClass.class, tmpl1);
CustomConverter.register(BaseClass.class, tmpl1); CustomConverter.register(BaseClass.class, tmpl1);
BaseClass src = new BaseClass(); BaseClass src = new BaseClass();
@@ -564,10 +564,10 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src2.f2 = 2; src2.f2 = 2;
src.f1 = src2; src.f1 = src2;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker.create(BaseClass2.class); MessagePacker packer = DynamicPacker.create(BaseClass2.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); 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)); BaseClass2 dst = (BaseClass2) tmpl.unpack(new Unpacker(in));
assertTrue(src.f0 == dst.f0); assertTrue(src.f0 == dst.f0);
assertTrue(src.f1.f2 == dst.f1.f2); assertTrue(src.f1.f2 == dst.f1.f2);
@@ -600,11 +600,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase {
src.f8 = 8; src.f8 = 8;
src.f9 = 9; src.f9 = 9;
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
MessagePacker packer = DynamicCodeGenPacker MessagePacker packer = DynamicPacker
.create(SampleSubClass.class); .create(SampleSubClass.class);
packer.pack(new Packer(out), src); packer.pack(new Packer(out), src);
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); 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)); SampleSubClass dst = (SampleSubClass) tmpl.unpack(new Unpacker(in));
assertTrue(src.f0 == dst.f0); assertTrue(src.f0 == dst.f0);
assertTrue(src.f1 == dst.f1); assertTrue(src.f1 == dst.f1);