From 3f5ac54bf53f251493d475663c6a2a3de9df954e Mon Sep 17 00:00:00 2001 From: Muga Nishizawa Date: Sat, 9 Oct 2010 21:53:49 +0900 Subject: [PATCH] java: refactor the programs in a org.msgpack.util.codegen package --- .../msgpack/util/codegen/BasicConstants.java | 194 ----- .../org/msgpack/util/codegen/Constants.java | 218 +++++- .../msgpack/util/codegen/DynamicCodeGen.java | 665 +++++++----------- .../util/codegen/DynamicCodeGenBase.java | 387 +++++----- ...enConverter.java => DynamicConverter.java} | 4 +- ....java => DynamicOrdinalEnumConverter.java} | 2 +- ...ker.java => DynamicOrdinalEnumPacker.java} | 2 +- ...e.java => DynamicOrdinalEnumTemplate.java} | 2 +- ...r.java => DynamicOrdinalEnumUnpacker.java} | 2 +- ...cCodeGenPacker.java => DynamicPacker.java} | 2 +- ...eGenTemplate.java => DynamicTemplate.java} | 2 +- ...eGenUnpacker.java => DynamicUnpacker.java} | 4 +- .../TestDynamicCodeGenPackerConverter.java | 82 +-- .../TestDynamicCodeGenPackerUnpacker.java | 80 +-- 14 files changed, 729 insertions(+), 917 deletions(-) delete mode 100644 java/src/main/java/org/msgpack/util/codegen/BasicConstants.java rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenConverter.java => DynamicConverter.java} (61%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenOrdinalEnumConverter.java => DynamicOrdinalEnumConverter.java} (91%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenOrdinalEnumPacker.java => DynamicOrdinalEnumPacker.java} (91%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenOrdinalEnumTemplate.java => DynamicOrdinalEnumTemplate.java} (90%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenOrdinalEnumUnpacker.java => DynamicOrdinalEnumUnpacker.java} (91%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenPacker.java => DynamicPacker.java} (93%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenTemplate.java => DynamicTemplate.java} (94%) rename java/src/main/java/org/msgpack/util/codegen/{DynamicCodeGenUnpacker.java => DynamicUnpacker.java} (61%) diff --git a/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java b/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java deleted file mode 100644 index 1e848431..00000000 --- a/java/src/main/java/org/msgpack/util/codegen/BasicConstants.java +++ /dev/null @@ -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"; -} diff --git a/java/src/main/java/org/msgpack/util/codegen/Constants.java b/java/src/main/java/org/msgpack/util/codegen/Constants.java index 91d584eb..e61f0395 100644 --- a/java/src/main/java/org/msgpack/util/codegen/Constants.java +++ b/java/src/main/java/org/msgpack/util/codegen/Constants.java @@ -1,6 +1,6 @@ package org.msgpack.util.codegen; -public interface Constants extends BasicConstants { +public interface Constants { String POSTFIX_TYPE_NAME_PACKER = "_$$_Packer"; String POSTFIX_TYPE_NAME_UNPACKER = "_$$_Unpacker"; @@ -8,4 +8,220 @@ public interface Constants extends BasicConstants { String POSTFIX_TYPE_NAME_CONVERTER = "_$$_Converter"; String POSTFIX_TYPE_NAME_TEMPLATE = "_$$_Template"; + + String KEYWORD_MODIFIER_PUBLIC = "public"; + + String KEYWORD_CATCH = "catch"; + + String KEYWORD_ELSE = "else"; + + String KEYWORD_ELSEIF = "else if"; + + String KEYWORD_FOR = "for"; + + String KEYWORD_IF = "if"; + + String KEYWORD_INSTANCEOF = "instanceof"; + + String KEYWORD_NEW = "new"; + + String KEYWORD_NULL = "null"; + + String KEYWORD_RETURN = "return"; + + String KEYWORD_THROW = "throw"; + + String KEYWORD_THROWS = "throws"; + + String KEYWORD_TRY = "try"; + + String CHAR_NAME_SPACE = " "; + + String CHAR_NAME_COMMA = ","; + + String CHAR_NAME_EQUAL = "="; + + String CHAR_NAME_PLUS = "+"; + + String CHAR_NAME_MINUS = "-"; + + String CHAR_NAME_UNDERSCORE = "_"; + + String CHAR_NAME_LESSTHAN = "<"; + + String CHAR_NAME_RIGHT_PARENTHESIS = ")"; + + String CHAR_NAME_LEFT_PARENTHESIS = "("; + + String CHAR_NAME_RIGHT_CURLY_BRACKET = "}"; + + String CHAR_NAME_LEFT_CURLY_BRACKET = "{"; + + String CHAR_NAME_RIGHT_SQUARE_BRACKET = "]"; + + String CHAR_NAME_LEFT_SQUARE_BRACKET = "["; + + String CHAR_NAME_DOT = "."; + + String CHAR_NAME_SEMICOLON = ";"; + + String VARIABLE_NAME_PK = "_$$_pk"; + + String VARIABLE_NAME_OBJECT = "_$$_obj"; + + String VARIABLE_NAME_TARGET = "_$$_t"; + + String VARIABLE_NAME_SIZE = "_$$_len"; + + String VARIABLE_NAME_ARRAY = "_$$_ary"; + + String VARIABLE_NAME_LIST = "_$$_list"; + + String VARIABLE_NAME_MAP = "_$$_map"; + + String VARIABLE_NAME_KEY = "_$$_key"; + + String VARIABLE_NAME_VAL = "_$$_val"; + + String VARIABLE_NAME_ITER = "_$$_iter"; + + String VARIABLE_NAME_MPO = "_$$_mpo"; + + String VARIABLE_NAME_I = "i"; + + String VARIABLE_NAME_TEMPLATES = "_$$_templates"; + + String VARIABLE_NAME_TEMPLATES0 = "_$$_tmpls"; + + String VARIABLE_NAME_CLIENT = "_$$_client"; + + String VARIABLE_NAME_CLIENT0 = "_$$_c"; + + String METHOD_NAME_VALUEOF = "valueOf"; + + String METHOD_NAME_BOOLEANVALUE = "booleanValue"; + + String METHOD_NAME_BYTEVALUE = "byteValue"; + + String METHOD_NAME_SHORTVALUE = "shortValue"; + + String METHOD_NAME_INTVALUE = "intValue"; + + String METHOD_NAME_FLOATVALUE = "floatValue"; + + String METHOD_NAME_LONGVALUE = "longValue"; + + String METHOD_NAME_DOUBLEVALUE = "doubleValue"; + + String METHOD_NAME_ADD = "add"; + + String METHOD_NAME_PUT = "put"; + + String METHOD_NAME_GET = "get"; + + String METHOD_NAME_SIZE = "size"; + + String METHOD_NAME_KEYSET = "keySet"; + + String METHOD_NAME_ITERATOR = "iterator"; + + String METHOD_NAME_HASNEXT = "hasNext"; + + String METHOD_NAME_NEXT = "next"; + + String METHOD_NAME_ORDINAL = "ordinal"; + + String METHOD_NAME_GETENUMCONSTANTS = "getEnumConstants"; + + String METHOD_NAME_CONVERT = "convert"; + + String METHOD_NAME_MSGCONVERT = "messageConvert"; + + String METHOD_NAME_SETTEMPLATES = "setTemplates"; + + String METHOD_NAME_SETCLIENT = "setClient"; + + String METHOD_NAME_PACK = "pack"; + + String METHOD_NAME_PACKARRAY = "packArray"; + + String METHOD_NAME_UNPACK = "unpack"; + + String METHOD_NAME_UNPACKBOOLEAN = "unpackBoolean"; + + String METHOD_NAME_UNPACKBYTE = "unpackByte"; + + String METHOD_NAME_UNPACKDOUBLE = "unpackDouble"; + + String METHOD_NAME_UNPACKFLOAT = "unpackFloat"; + + String METHOD_NAME_UNPACKINT = "unpackInt"; + + String METHOD_NAME_UNPACKLONG = "unpackLong"; + + String METHOD_NAME_UNPACKSHORT = "unpackShort"; + + String METHOD_NAME_UNPACKSTRING = "unpackString"; + + String METHOD_NAME_UNPACKBIGINTEGER = "unpackBigInteger"; + + String METHOD_NAME_UNPACKOBJECT = "unpackObject"; + + String METHOD_NAME_UNPACKBYTEARRAY = "unpackByteArray"; + + String METHOD_NAME_UNPACKARRAY = "unpackArray"; + + String METHOD_NAME_UNPACKMAP = "unpackMap"; + + String METHOD_NAME_ASARRAY = "asArray"; + + String METHOD_NAME_ASBOOLEAN = "asBoolean"; + + String METHOD_NAME_ASBYTE = "asByte"; + + String METHOD_NAME_ASSHORT = "asShort"; + + String METHOD_NAME_ASINT = "asInt"; + + String METHOD_NAME_ASFLOAT = "asFloat"; + + String METHOD_NAME_ASLONG = "asLong"; + + String METHOD_NAME_ASDOUBLE = "asDouble"; + + String METHOD_NAME_ASSTRING = "asString"; + + String METHOD_NAME_ASBYTEARRAY = "asByteArray"; + + String METHOD_NAME_ASBIGINTEGER = "asBigInteger"; + + String METHOD_NAME_ASLIST = "asList"; + + String METHOD_NAME_ASMAP = "asMap"; + + String STATEMENT_PACKER_PACKERMETHODBODY_01 = "%s _$$_t = (%s)$2; "; + + String STATEMENT_PACKER_PACKERMETHODBODY_02 = "$1.packArray(%d); "; + + String STATEMENT_PACKER_PACKERMETHODBODY_03 = "$1.pack(_$$_t.%s); "; + + String STATEMENT_PACKER_PACKERMETHODBODY_04 = "$1.pack(((java.lang.Enum)_$$_t).ordinal()); "; + + String STATEMENT_PACKER_UNPACKERMETHODBODY_01 = "%s _$$_t = new %s(); "; + + String STATEMENT_PACKER_UNPACKERMETHODBODY_02 = "$1.unpackArray(); "; + + String STATEMENT_PACKER_UNPACKERMETHODBODY_03 = "_$$_t.%s = %s(%s)_$$_templates[%d].unpack($1)%s; "; + + String STATEMENT_PACKER_UNPACKERMETHODBODY_04 = "return _$$_t; "; + + String STATEMENT_PACKER_UNPACKERMETHODBODY_05 = "int i = $1.unpackInt(); "; + + String STATEMENT_PACKER_UNPACKERMETHODBODY_06 = "return %s.class.getEnumConstants()[i]; "; + + String STATEMENT_PACKER_CONVERTMETHODBODY_01 = "%s _$$_ary = $1.asArray(); "; + + String STATEMENT_PACKER_CONVERTMETHODBODY_02 = "_$$_t.%s = %s(%s)_$$_templates[%d].convert(_$$_ary[%d])%s; "; + + String STATEMENT_PACKER_CONVERTMETHODBODY_03 = "int i = _$$_ary[0].asInt(); "; } diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java index ee5667de..3954f177 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGen.java @@ -9,15 +9,10 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.atomic.AtomicInteger; import javassist.CannotCompileException; -import javassist.ClassPool; import javassist.CtClass; -import javassist.CtConstructor; -import javassist.CtField; import javassist.CtMethod; -import javassist.CtNewConstructor; import javassist.CtNewMethod; import javassist.NotFoundException; @@ -44,12 +39,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { private static DynamicCodeGen INSTANCE; - private static AtomicInteger COUNTER = new AtomicInteger(0); - - private static int inc() { - return COUNTER.addAndGet(1); - } - public static DynamicCodeGen getInstance() { if (INSTANCE == null) { LOG.info("create an instance of the type: " @@ -59,37 +48,37 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { return INSTANCE; } - private ClassPool pool; - - private ConcurrentHashMap tmplMap; + private ConcurrentHashMap tmplCache; DynamicCodeGen() { - pool = ClassPool.getDefault(); - tmplMap = new ConcurrentHashMap(); + super(); + tmplCache = new ConcurrentHashMap(); } - public void setTemplates(Class origClass, Template[] tmpls) { - tmplMap.putIfAbsent(origClass.getName(), tmpls); + public void setTemplates(Class type, Template[] tmpls) { + tmplCache.putIfAbsent(type.getName(), tmpls); } - public Template[] getTemplates(Class origClass) { - return tmplMap.get(origClass.getName()); + public Template[] getTemplates(Class type) { + return tmplCache.get(type.getName()); } public Class generateMessagePackerClass(Class origClass) { - LOG.debug("start generating a MessagePacker impl.: " - + origClass.getName()); try { + LOG.debug("start generating a packer class for " + + origClass.getName()); String origName = origClass.getName(); String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc(); - checkClassValidation(origClass); + checkTypeValidation(origClass); checkDefaultConstructorValidation(origClass); CtClass packerCtClass = pool.makeClass(packerName); setInterface(packerCtClass, MessagePacker.class); addDefaultConstructor(packerCtClass); Field[] fields = getDeclaredFields(origClass); - addPackMethod(packerCtClass, origClass, fields); - return createClass(packerCtClass); + addPackMethod(packerCtClass, origClass, fields, false); + Class packerClass = createClass(packerCtClass); + LOG.debug("generated a packer class for " + origClass.getName()); + return packerClass; } catch (NotFoundException e) { LOG.error(e.getMessage(), e); throw new DynamicCodeGenException(e.getMessage(), e); @@ -100,17 +89,19 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { } public Class generateOrdinalEnumPackerClass(Class origClass) { - LOG.debug("start generating a OrdinalEnumPacker impl.: " - + origClass.getName()); try { + LOG.debug("start generating an enum packer for " + + origClass.getName()); String origName = origClass.getName(); String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc(); - checkClassValidation(origClass); + checkTypeValidation(origClass); CtClass packerCtClass = pool.makeClass(packerName); setInterface(packerCtClass, MessagePacker.class); addDefaultConstructor(packerCtClass); - addPackMethodForOrdinalEnumTypes(packerCtClass, origClass); - return createClass(packerCtClass); + addPackMethod(packerCtClass, origClass, null, true); + Class packerClass = createClass(packerCtClass); + LOG.debug("generated an enum class for " + origClass.getName()); + return packerClass; } catch (NotFoundException e) { LOG.error(e.getMessage(), e); throw new DynamicCodeGenException(e.getMessage(), e); @@ -121,123 +112,103 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { } public Class generateTemplateClass(Class origClass) { - LOG.debug("start generating a Template impl.: " + origClass.getName()); try { + LOG.debug("start generating a template class for " + + origClass.getName()); String origName = origClass.getName(); String tmplName = origName + POSTFIX_TYPE_NAME_TEMPLATE + inc(); - checkClassValidation(origClass); + checkTypeValidation(origClass); checkDefaultConstructorValidation(origClass); CtClass tmplCtClass = pool.makeClass(tmplName); - CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName()); setInterface(tmplCtClass, Template.class); setInterface(tmplCtClass, DynamicCodeGenBase.TemplateAccessor.class); addDefaultConstructor(tmplCtClass); Field[] fields = getDeclaredFields(origClass); Template[] tmpls = createTemplates(fields); setTemplates(origClass, tmpls); - addTemplateArrayField(tmplCtClass, acsCtClass); - addSetTemplatesMethod(tmplCtClass, acsCtClass); - addUnpackMethod(tmplCtClass, origClass, fields); - addConvertMethod(tmplCtClass, origClass, fields); - return createClass(tmplCtClass); + addTemplateArrayField(tmplCtClass); + addSetTemplatesMethod(tmplCtClass); + addUnpackMethod(tmplCtClass, origClass, fields, false); + addConvertMethod(tmplCtClass, origClass, fields, false); + Class tmplClass = createClass(tmplCtClass); + LOG.debug("generated a template class for " + origClass.getName()); + return tmplClass; } catch (NotFoundException e) { - LOG.error(e.getMessage(), e); - throw new DynamicCodeGenException(e.getMessage(), e); + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } catch (CannotCompileException e) { - LOG.error(e.getMessage(), e); - throw new DynamicCodeGenException(e.getMessage(), e); + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } } public Class generateOrdinalEnumTemplateClass(Class origClass) { - LOG.debug("start generating a OrdinalEnumTemplate impl.: " - + origClass.getName()); try { + LOG.debug("start generating a enum template class for " + + origClass.getName()); String origName = origClass.getName(); - checkClassValidation(origClass); - CtClass tmplCtClass = makeClass(origName); + checkTypeValidation(origClass); + String tmplName = origName + POSTFIX_TYPE_NAME_TEMPLATE + inc(); + CtClass tmplCtClass = pool.makeClass(tmplName); setInterface(tmplCtClass, Template.class); addDefaultConstructor(tmplCtClass); - addUnpackMethodForOrdinalEnumTypes(tmplCtClass, origClass); - addConvertMethodForOrdinalEnumTypes(tmplCtClass, origClass); - return createClass(tmplCtClass); + addUnpackMethod(tmplCtClass, origClass, null, true); + addConvertMethod(tmplCtClass, origClass, null, true); + // addConvertMethodForOrdinalEnumTypes(tmplCtClass, origClass); + Class tmplClass = createClass(tmplCtClass); + LOG.debug("generated an enum template class for " + + origClass.getName()); + return tmplClass; } catch (NotFoundException e) { - LOG.error(e.getMessage(), e); - throw new DynamicCodeGenException(e.getMessage(), e); + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } catch (CannotCompileException e) { - LOG.error(e.getMessage(), e); - throw new DynamicCodeGenException(e.getMessage(), e); + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } } - private CtClass makeClass(String origName) throws NotFoundException { - StringBuilder sb = new StringBuilder(); - sb.append(origName); - sb.append(POSTFIX_TYPE_NAME_TEMPLATE); - sb.append(inc()); - String invokerName = sb.toString(); - CtClass newCtClass = pool.makeClass(invokerName); - newCtClass.setModifiers(Modifier.PUBLIC); - return newCtClass; - } - - private void checkClassValidation(Class origClass) { + @Override + public void checkTypeValidation(Class origClass) { // not public, abstract int mod = origClass.getModifiers(); if ((!Modifier.isPublic(mod)) || Modifier.isAbstract(mod)) { - throwClassValidationException(origClass, + throwTypeValidationException(origClass, "a class must have a public modifier"); } // interface if (origClass.isInterface()) { - throwClassValidationException(origClass, + throwTypeValidationException(origClass, "cannot generate packer and unpacker for an interface"); } } - private static void throwClassValidationException(Class origClass, - String msg) { - DynamicCodeGenException e = new DynamicCodeGenException(msg + ": " - + origClass.getName()); - LOG.error(e.getMessage(), e); - throw e; - } - - private void checkDefaultConstructorValidation(Class origClass) { + @Override + public void checkDefaultConstructorValidation(Class origClass) { + // check that the zero-argument constructor exists Constructor cons = null; try { cons = origClass.getDeclaredConstructor(new Class[0]); - } catch (Exception e1) { + } catch (Exception e) { throwConstructorValidationException(origClass); } + + // check the modifiers int mod = cons.getModifiers(); if (!Modifier.isPublic(mod)) { throwConstructorValidationException(origClass); } } - private static void throwConstructorValidationException(Class origClass) { - DynamicCodeGenException e = new DynamicCodeGenException( - "it must have a public zero-argument constructor: " - + origClass.getName()); - LOG.error(e.getMessage(), e); - throw e; - } - - private void setInterface(CtClass packerCtClass, Class infClass) - throws NotFoundException { - CtClass infCtClass = pool.get(infClass.getName()); - packerCtClass.addInterface(infCtClass); - } - - private void addDefaultConstructor(CtClass dstCtClass) - throws CannotCompileException { - CtConstructor newCtCons = CtNewConstructor - .defaultConstructor(dstCtClass); - dstCtClass.addConstructor(newCtCons); - } - - private Field[] getDeclaredFields(Class origClass) { + Field[] getDeclaredFields(Class origClass) { ArrayList allFields = new ArrayList(); Class nextClass = origClass; while (nextClass != Object.class) { @@ -247,6 +218,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { checkFieldValidation(field, allFields); allFields.add(field); } catch (DynamicCodeGenException e) { // ignore + LOG.error(e.getMessage(), e); } } nextClass = nextClass.getSuperclass(); @@ -254,7 +226,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { return allFields.toArray(new Field[0]); } - private void checkFieldValidation(Field field, List fields) { + void checkFieldValidation(Field field, List fields) { // check that it has a public modifier int mod = field.getModifiers(); if ((!(Modifier.isPublic(mod))) || Modifier.isStatic(mod) @@ -270,13 +242,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { } } - private static void throwFieldValidationException(Field f) { - DynamicCodeGenException e = new DynamicCodeGenException( - "it must be a public field: " + f.getName()); - LOG.debug(e.getMessage(), e); - throw e; - } - Template[] createTemplates(Field[] fields) { Template[] tmpls = new Template[fields.length]; for (int i = 0; i < tmpls.length; ++i) { @@ -294,19 +259,25 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { } } - private void addPackMethod(CtClass packerCtClass, Class c, Field[] fs) { + private void addPackMethod(CtClass packerCtClass, Class c, Field[] fs, + boolean isEnum) { // void pack(Packer pk, Object target) throws IOException; StringBuilder sb = new StringBuilder(); - StringBuilder bsb = new StringBuilder(); - insertPackMethodBody(bsb, c, fs); - addPublicMethodDecl(sb, METHOD_NAME_PACK, void.class, new Class[] { - Packer.class, Object.class }, new String[] { VARIABLE_NAME_PK, - VARIABLE_NAME_OBJECT }, new Class[] { IOException.class }, bsb - .toString()); - LOG.trace("pack method src: " + sb.toString()); + if (!isEnum) { + insertPackMethodBody(sb, c, fs); + } else { + insertOrdinalEnumPackMethodBody(sb, c); + } try { - CtMethod newCtMethod = CtNewMethod.make(sb.toString(), - packerCtClass); + LOG.trace("pack method src: " + sb.toString()); + int mod = javassist.Modifier.PUBLIC; + CtClass returnType = classToCtClass(void.class); + String mname = METHOD_NAME_PACK; + CtClass[] paramTypes = new CtClass[] { + classToCtClass(Packer.class), classToCtClass(Object.class) }; + CtClass[] exceptTypes = new CtClass[] { classToCtClass(IOException.class) }; + CtMethod newCtMethod = CtNewMethod.make(mod, returnType, mname, + paramTypes, exceptTypes, sb.toString(), packerCtClass); packerCtClass.addMethod(newCtMethod); } catch (CannotCompileException e) { DynamicCodeGenException ex = new DynamicCodeGenException(e @@ -314,21 +285,29 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { + ": " + sb.toString(), e); LOG.error(ex.getMessage(), ex); throw ex; + } catch (NotFoundException e) { + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage() + + ": " + sb.toString(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } } - private void insertPackMethodBody(StringBuilder sb, Class c, Field[] fs) { - insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET); - StringBuilder mc = new StringBuilder(); - insertTypeCast(mc, c, VARIABLE_NAME_OBJECT); - insertValueInsertion(sb, mc.toString()); - insertSemicolon(sb); - insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_PACKARRAY, - new String[] { new Integer(fs.length).toString() }); - insertSemicolon(sb); - for (Field f : fs) { + private void insertPackMethodBody(StringBuilder sb, Class type, + Field[] fields) { + // void pack(Packer packer, Object target) throws IOException; + sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(CHAR_NAME_SPACE); + String typeName = classToString(type); + Object[] args0 = new Object[] { typeName, typeName }; + sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_01, args0)); + Object[] args1 = new Object[] { fields.length }; + sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_02, args1)); + for (Field f : fields) { insertCodeOfPackMethodCall(sb, f); } + sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); } private void insertCodeOfPackMethodCall(StringBuilder sb, Field field) { @@ -352,7 +331,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { ; // ignore } else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) { // @MessagePackMessage - MessagePacker packer = DynamicCodeGenPacker.create(c); + MessagePacker packer = DynamicPacker.create(c); CustomMessage.registerPacker(c, packer); } else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) { // FIXME DelegatePacker @@ -362,7 +341,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { throw e; } else if (CustomMessage.isAnnotated(c, MessagePackOrdinalEnum.class)) { // @MessagePackOrdinalEnum - MessagePacker packer = DynamicCodeGenOrdinalEnumPacker.create(c); + MessagePacker packer = DynamicOrdinalEnumPacker.create(c); CustomMessage.registerPacker(c, packer); } else { MessageTypeException e = new MessageTypeException("unknown type: " @@ -370,106 +349,77 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { LOG.error(e.getMessage(), e); throw e; } - StringBuilder fa = new StringBuilder(); - insertFieldAccess(fa, VARIABLE_NAME_TARGET, field.getName()); - insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_PACK, - new String[] { fa.toString() }); - insertSemicolon(sb); + Object[] args = new Object[] { field.getName() }; + sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_03, args)); } - private void addPackMethodForOrdinalEnumTypes(CtClass packerCtClass, - Class c) throws CannotCompileException, NotFoundException { - // void pack(Packer pk, Object target) throws IOException; + private void insertOrdinalEnumPackMethodBody(StringBuilder sb, Class c) { + // void pack(Packer packer, Object target) throws IOException; + sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(CHAR_NAME_SPACE); + String typeName = classToString(c); + Object[] args0 = new Object[] { typeName, typeName }; + sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_01, args0)); + Object[] args1 = new Object[] { 1 }; + sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_02, args1)); + Object[] args2 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_PACKERMETHODBODY_04, args2)); + sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); + } + + private void addUnpackMethod(CtClass tmplCtClass, Class type, + Field[] fields, boolean isEnum) { + // Object unpack(Unpacker u) throws IOException, MessageTypeException; StringBuilder sb = new StringBuilder(); - StringBuilder bsb = new StringBuilder(); - insertLocalVariableDecl(bsb, c, VARIABLE_NAME_TARGET); - StringBuilder fa = new StringBuilder(); - insertTypeCast(fa, c, VARIABLE_NAME_OBJECT); - insertValueInsertion(bsb, fa.toString()); - insertSemicolon(bsb); - insertMethodCall(bsb, VARIABLE_NAME_PK, METHOD_NAME_PACKARRAY, - new String[] { new Integer(1).toString() }); - insertSemicolon(bsb); - fa = new StringBuilder(); - insertTypeCast(fa, Enum.class, VARIABLE_NAME_TARGET); - String t = fa.toString(); - fa = new StringBuilder(); - insertMethodCall(fa, t, METHOD_NAME_ORDINAL, new String[0]); - insertMethodCall(bsb, VARIABLE_NAME_PK, METHOD_NAME_PACK, - new String[] { fa.toString() }); - insertSemicolon(bsb); - addPublicMethodDecl(sb, METHOD_NAME_PACK, void.class, new Class[] { - Packer.class, Object.class }, new String[] { VARIABLE_NAME_PK, - VARIABLE_NAME_OBJECT }, new Class[] { IOException.class }, bsb - .toString()); - LOG.trace("pack method src: " + sb.toString()); + if (!isEnum) { + insertUnpackMethodBody(sb, type, fields); + } else { + insertOrdinalEnumUnpackMethodBody(sb, type); + } try { - CtMethod newCtMethod = CtNewMethod.make(sb.toString(), - packerCtClass); - packerCtClass.addMethod(newCtMethod); + LOG.trace("unpack method src: " + sb.toString()); + int mod = javassist.Modifier.PUBLIC; + CtClass returnType = classToCtClass(Object.class); + String mname = METHOD_NAME_UNPACK; + CtClass[] paramTypes = new CtClass[] { classToCtClass(Unpacker.class) }; + CtClass[] exceptTypes = new CtClass[] { + classToCtClass(IOException.class), + classToCtClass(MessageTypeException.class) }; + CtMethod newCtMethod = CtNewMethod.make(mod, returnType, mname, + paramTypes, exceptTypes, sb.toString(), tmplCtClass); + tmplCtClass.addMethod(newCtMethod); } catch (CannotCompileException e) { DynamicCodeGenException ex = new DynamicCodeGenException(e .getMessage() + ": " + sb.toString(), e); LOG.error(ex.getMessage(), ex); throw ex; + } catch (NotFoundException e) { + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage() + + ": " + sb.toString(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } } - private void addTemplateArrayField(CtClass newCtClass, CtClass acsCtClass) - throws NotFoundException, CannotCompileException { - CtField tmplsField = acsCtClass - .getDeclaredField(VARIABLE_NAME_TEMPLATES); - CtField tmplsField2 = new CtField(tmplsField.getType(), tmplsField - .getName(), newCtClass); - newCtClass.addField(tmplsField2); - } - - private void addSetTemplatesMethod(CtClass newCtClass, CtClass acsCtClass) - throws NotFoundException, CannotCompileException { - CtMethod settmplsMethod = acsCtClass - .getDeclaredMethod(METHOD_NAME_SETTEMPLATES); - CtMethod settmplsMethod2 = CtNewMethod.copy(settmplsMethod, newCtClass, - null); - newCtClass.addMethod(settmplsMethod2); - } - - private void addUnpackMethod(CtClass unpackerCtClass, Class c, Field[] fs) { - // Object unpack(Unpacker pac) throws IOException, MessageTypeException; - StringBuilder sb = new StringBuilder(); - StringBuilder bsb = new StringBuilder(); - insertUnpackMethodBody(bsb, c, fs); - addPublicMethodDecl(sb, METHOD_NAME_UNPACK, Object.class, - new Class[] { Unpacker.class }, - new String[] { VARIABLE_NAME_PK }, new Class[] { - MessageTypeException.class, IOException.class }, bsb - .toString()); - LOG.trace("unpack method src: " + sb.toString()); - try { - CtMethod newCtMethod = CtNewMethod.make(sb.toString(), - unpackerCtClass); - unpackerCtClass.addMethod(newCtMethod); - } catch (CannotCompileException e) { - DynamicCodeGenException ex = new DynamicCodeGenException(e - .getMessage() - + ": " + sb.toString(), e); - LOG.error(ex.getMessage(), ex); - throw ex; - } - } - - private void insertUnpackMethodBody(StringBuilder sb, Class c, Field[] fs) { - insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET); - StringBuilder mc = new StringBuilder(); - insertDefaultConsCall(mc, c); - insertValueInsertion(sb, mc.toString()); - insertSemicolon(sb); - insertMethodCall(sb, VARIABLE_NAME_PK, METHOD_NAME_UNPACKARRAY, - new String[0]); - insertSemicolon(sb); - insertCodeOfUnpackMethodCalls(sb, fs); - insertReturnStat(sb, VARIABLE_NAME_TARGET); - insertSemicolon(sb); + private void insertUnpackMethodBody(StringBuilder sb, Class type, + Field[] fields) { + // Object unpack(Unpacker u) throws IOException, MessageTypeException; + sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(CHAR_NAME_SPACE); + // Foo _$$_t = new Foo(); + String typeName = classToString(type); + Object[] args0 = new Object[] { typeName, typeName }; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_01, args0)); + // $1.unpackArray(); + Object[] args1 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_02, args1)); + insertCodeOfUnpackMethodCalls(sb, fields); + // return _$$_t; + Object[] args2 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_04, args2)); + sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); } private void insertCodeOfUnpackMethodCalls(StringBuilder sb, Field[] fields) { @@ -481,40 +431,17 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { private void insertCodeOfUnpackMethodCall(StringBuilder sb, Field field, int i) { // target.fi = ((Integer)_$$_tmpls[i].unpack(_$$_pk)).intValue(); - Class type = field.getType(); - insertFieldAccess(sb, VARIABLE_NAME_TARGET, field.getName()); - String castType = null; - String rawValueGetter = null; - if (type.isPrimitive()) { - castType = "(" + primitiveTypeToWrapperType(type).getName() + ")"; - rawValueGetter = getPrimTypeValueMethodName(type); - } else if (type.isArray()) { - castType = "(" + arrayTypeToString(type) + ")"; - } else { - castType = "(" + type.getName() + ")"; - } - StringBuilder mc = new StringBuilder(); - mc.append(castType); - mc.append(VARIABLE_NAME_TEMPLATES); - mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - mc.append(i); - mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - String tname = mc.toString(); - mc = new StringBuilder(); - insertMethodCall(mc, tname, METHOD_NAME_UNPACK, - new String[] { VARIABLE_NAME_PK }); - if (type.isPrimitive()) { - tname = mc.toString(); - mc = new StringBuilder(); - mc.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); - mc.append(tname); - mc.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); - tname = mc.toString(); - mc = new StringBuilder(); - insertMethodCall(mc, tname, rawValueGetter, new String[0]); - } - insertValueInsertion(sb, mc.toString()); - insertSemicolon(sb); + Class returnType = field.getType(); + boolean isPrim = returnType.isPrimitive(); + Object[] args = new Object[] { + field.getName(), + isPrim ? "(" : "", + isPrim ? getPrimToWrapperType(returnType).getName() + : classToString(returnType), + i, + isPrim ? ")." + getPrimTypeValueMethodName(returnType) + "()" + : "" }; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_03, args)); } private void insertCodeOfUnpackMethodCallForMsgUnpackableType( @@ -567,59 +494,41 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { sb.append(CHAR_NAME_SPACE); } - private void addUnpackMethodForOrdinalEnumTypes(CtClass unpackerCtClass, - Class c) { - // Object unpack(Unpacker pac) throws IOException, MessageTypeException; - StringBuilder sb = new StringBuilder(); - StringBuilder bsb = new StringBuilder(); - insertMethodCall(bsb, VARIABLE_NAME_PK, METHOD_NAME_UNPACKARRAY, - new String[0]); - insertSemicolon(bsb); - StringBuilder mc = new StringBuilder(); - insertMethodCall(mc, VARIABLE_NAME_PK, METHOD_NAME_UNPACKINT, - new String[0]); - insertLocalVariableDecl(bsb, int.class, VARIABLE_NAME_I); - insertValueInsertion(bsb, mc.toString()); - insertSemicolon(bsb); - mc = new StringBuilder(); - insertMethodCall(mc, c.getName() + ".class", - METHOD_NAME_GETENUMCONSTANTS, new String[0]); - mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - mc.append(VARIABLE_NAME_I); - mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - insertReturnStat(bsb, mc.toString()); - insertSemicolon(bsb); - addPublicMethodDecl(sb, METHOD_NAME_UNPACK, Object.class, - new Class[] { Unpacker.class }, - new String[] { VARIABLE_NAME_PK }, new Class[] { - MessageTypeException.class, IOException.class }, bsb - .toString()); - LOG.trace("unpack method src: " + sb.toString()); - try { - CtMethod newCtMethod = CtNewMethod.make(sb.toString(), - unpackerCtClass); - unpackerCtClass.addMethod(newCtMethod); - } catch (CannotCompileException e) { - DynamicCodeGenException ex = new DynamicCodeGenException(e - .getMessage() - + ": " + sb.toString(), e); - LOG.error(ex.getMessage(), ex); - throw ex; - } + private void insertOrdinalEnumUnpackMethodBody(StringBuilder sb, + Class type) { + // Object unpack(Unpacker u) throws IOException, MessageTypeException; + sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(CHAR_NAME_SPACE); + // $1.unpackArray(); + Object[] args0 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_02, args0)); + // int i = $1.unapckInt(); + Object[] args1 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_05, args1)); + // return Foo.class.getEnumConstants()[i]; + Object[] args2 = new Object[] { classToString(type) }; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_06, args2)); + sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); } - public void addConvertMethod(CtClass tmplCtClass, Class c, Field[] fs) { - // Object convert(MessagePackObject from) throws MessageTypeException; + public void addConvertMethod(CtClass tmplCtClass, Class type, + Field[] fields, boolean isEnum) { + // Object convert(MessagePackObject mpo) throws MessageTypeException; StringBuilder sb = new StringBuilder(); - StringBuilder bsb = new StringBuilder(); - insertConvertMethodBody(bsb, c, fs); - addPublicMethodDecl(sb, METHOD_NAME_CONVERT, Object.class, - new Class[] { MessagePackObject.class }, - new String[] { VARIABLE_NAME_MPO }, - new Class[] { MessageTypeException.class }, bsb.toString()); - LOG.trace("convert method src: " + sb.toString()); + if (!isEnum) { + insertConvertMethodBody(sb, type, fields); + } else { + insertOrdinalEnumConvertMethodBody(sb, type); + } try { - CtMethod newCtMethod = CtNewMethod.make(sb.toString(), tmplCtClass); + LOG.trace("convert method src: " + sb.toString()); + int mod = javassist.Modifier.PUBLIC; + CtClass returnType = classToCtClass(Object.class); + String mname = METHOD_NAME_CONVERT; + CtClass[] paramTypes = new CtClass[] { classToCtClass(MessagePackObject.class) }; + CtClass[] exceptTypes = new CtClass[] { classToCtClass(MessageTypeException.class) }; + CtMethod newCtMethod = CtNewMethod.make(mod, returnType, mname, + paramTypes, exceptTypes, sb.toString(), tmplCtClass); tmplCtClass.addMethod(newCtMethod); } catch (CannotCompileException e) { DynamicCodeGenException ex = new DynamicCodeGenException(e @@ -627,31 +536,32 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { + ": " + sb.toString(), e); LOG.error(ex.getMessage(), ex); throw ex; + } catch (NotFoundException e) { + DynamicCodeGenException ex = new DynamicCodeGenException(e + .getMessage() + + ": " + sb.toString(), e); + LOG.error(ex.getMessage(), ex); + throw ex; } } - private void insertConvertMethodBody(StringBuilder sb, Class c, - Field[] fs) { - insertLocalVariableDecl(sb, c, VARIABLE_NAME_TARGET); - StringBuilder mc = new StringBuilder(); - insertDefaultConsCall(mc, c); - insertValueInsertion(sb, mc.toString()); - insertSemicolon(sb); - insertCodeOfMessagePackObjectArrayGet(sb); - insertCodeOfConvertMethodCalls(sb, fs); - insertReturnStat(sb, VARIABLE_NAME_TARGET); - insertSemicolon(sb); - } - - private void insertCodeOfMessagePackObjectArrayGet(StringBuilder sb) { - // MessagePackObject[] ary = obj.asArray(); - insertLocalVariableDecl(sb, MessagePackObject.class, - VARIABLE_NAME_ARRAY, 1); - StringBuilder mc = new StringBuilder(); - insertMethodCall(mc, VARIABLE_NAME_MPO, METHOD_NAME_ASARRAY, - new String[0]); - insertValueInsertion(sb, mc.toString()); - insertSemicolon(sb); + private void insertConvertMethodBody(StringBuilder sb, Class type, + Field[] fields) { + // Object convert(MessagePackObject mpo) throws MessageTypeException; + sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(CHAR_NAME_SPACE); + // Foo _$$_t = new Foo(); + String typeName = classToString(type); + Object[] args0 = new Object[] { typeName, typeName }; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_01, args0)); + // MessagePackObject[] _$$_ary = $1.asArray(); + Object[] args1 = new Object[] { classToString(MessagePackObject[].class) }; + sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_01, args1)); + insertCodeOfConvertMethodCalls(sb, fields); + // return _$$_t; + Object[] args2 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_04, args2)); + sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); } private void insertCodeOfConvertMethodCalls(StringBuilder sb, Field[] fields) { @@ -661,46 +571,19 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { } private void insertCodeOfConvMethodCall(StringBuilder sb, Field field, int i) { - // target.f0 = ((Integer)_$$_tmpls[i].convert(_$$_ary[i])).intValue(); - Class type = field.getType(); - insertFieldAccess(sb, VARIABLE_NAME_TARGET, field.getName()); - String castType = null; - String rawValueGetter = null; - if (type.isPrimitive()) { - castType = "(" + primitiveTypeToWrapperType(type).getName() + ")"; - rawValueGetter = getPrimTypeValueMethodName(type); - } else if (type.isArray()) { - castType = "(" + arrayTypeToString(type) + ")"; - } else { - castType = "(" + type.getName() + ")"; - } - StringBuilder mc = new StringBuilder(); - mc.append(castType); - mc.append(VARIABLE_NAME_TEMPLATES); - mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - mc.append(i); - mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - String tname = mc.toString(); - mc = new StringBuilder(); - mc.append(VARIABLE_NAME_ARRAY); - mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - mc.append(i); - mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - String aname = mc.toString(); - mc = new StringBuilder(); - insertMethodCall(mc, tname, METHOD_NAME_CONVERT, new String[] { aname }); - if (type.isPrimitive()) { - tname = mc.toString(); - mc = new StringBuilder(); - mc.append(Constants.CHAR_NAME_LEFT_PARENTHESIS); - mc.append(tname); - mc.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS); - tname = mc.toString(); - mc = new StringBuilder(); - insertMethodCall(mc, tname, rawValueGetter, new String[0]); - } - insertValueInsertion(sb, mc.toString()); - insertSemicolon(sb); + // target.fi = ((Object)_$$_tmpls[i].convert(_$$_ary[i])).intValue(); + Class returnType = field.getType(); + boolean isPrim = returnType.isPrimitive(); + Object[] args = new Object[] { + field.getName(), + isPrim ? "(" : "", + isPrim ? getPrimToWrapperType(returnType).getName() + : classToString(returnType), + i, + i, + isPrim ? ")." + getPrimTypeValueMethodName(returnType) + "()" + : "" }; + sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_02, args)); } private void insertCodeOfMessageConvertCallForMsgConvtblType( @@ -752,50 +635,20 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants { sb.append(CHAR_NAME_SPACE); } - public void addConvertMethodForOrdinalEnumTypes(CtClass tmplCtClass, - Class c) { - // Object convert(MessagePackObject from) throws MessageTypeException; - StringBuilder sb = new StringBuilder(); - StringBuilder bsb = new StringBuilder(); - insertCodeOfMessagePackObjectArrayGet(bsb); - StringBuilder mc = new StringBuilder(); - insertMethodCall(mc, VARIABLE_NAME_ARRAY + "[0]", METHOD_NAME_ASINT, - new String[0]); - insertLocalVariableDecl(bsb, int.class, VARIABLE_NAME_I); - insertValueInsertion(bsb, mc.toString()); - insertSemicolon(bsb); - mc = new StringBuilder(); - insertMethodCall(mc, c.getName() + ".class", - METHOD_NAME_GETENUMCONSTANTS, new String[0]); - mc.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - mc.append(VARIABLE_NAME_I); - mc.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - insertLocalVariableDecl(bsb, Object.class, VARIABLE_NAME_OBJECT); - insertValueInsertion(bsb, mc.toString()); - insertSemicolon(bsb); - mc = new StringBuilder(); - insertTypeCast(mc, c, VARIABLE_NAME_OBJECT); - insertReturnStat(bsb, mc.toString()); - insertSemicolon(bsb); - addPublicMethodDecl(sb, METHOD_NAME_CONVERT, Object.class, - new Class[] { MessagePackObject.class }, - new String[] { VARIABLE_NAME_MPO }, - new Class[] { MessageTypeException.class }, bsb.toString()); - LOG.trace("convert method src: " + sb.toString()); - try { - CtMethod newCtMethod = CtNewMethod.make(sb.toString(), tmplCtClass); - tmplCtClass.addMethod(newCtMethod); - } catch (CannotCompileException e) { - DynamicCodeGenException ex = new DynamicCodeGenException(e - .getMessage() - + ": " + sb.toString(), e); - LOG.error(ex.getMessage(), ex); - throw ex; - } - } - - private Class createClass(CtClass packerCtClass) - throws CannotCompileException { - return packerCtClass.toClass(null, null); + private void insertOrdinalEnumConvertMethodBody(StringBuilder sb, + Class type) { + // Object convert(MessagePackObject mpo) throws MessageTypeException; + sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); + sb.append(CHAR_NAME_SPACE); + // MessagePackObject[] _$$_ary = $1.asArray(); + Object[] args0 = new Object[] { classToString(MessagePackObject[].class) }; + sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_01, args0)); + // int i = _$$_ary[0].asInt(); + Object[] args1 = new Object[0]; + sb.append(String.format(STATEMENT_PACKER_CONVERTMETHODBODY_03, args1)); + // return Foo.class.getEnumConstants()[i]; + Object[] args2 = new Object[] { classToString(type) }; + sb.append(String.format(STATEMENT_PACKER_UNPACKERMETHODBODY_06, args2)); + sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); } } diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java index 6fa6abcf..4bfea8c1 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenBase.java @@ -1,11 +1,24 @@ package org.msgpack.util.codegen; +import java.lang.reflect.Field; import java.lang.reflect.GenericArrayType; +import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.math.BigInteger; import java.util.List; import java.util.Map; +import java.util.concurrent.atomic.AtomicInteger; + +import javassist.CannotCompileException; +import javassist.ClassPool; +import javassist.CtClass; +import javassist.CtConstructor; +import javassist.CtField; +import javassist.CtMethod; +import javassist.CtNewConstructor; +import javassist.CtNewMethod; +import javassist.NotFoundException; import org.msgpack.CustomConverter; import org.msgpack.CustomMessage; @@ -18,7 +31,7 @@ import org.msgpack.annotation.MessagePackOrdinalEnum; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class DynamicCodeGenBase implements BasicConstants { +public class DynamicCodeGenBase implements Constants { public static interface TemplateAccessor { void setTemplates(Template[] templates); } @@ -34,252 +47,104 @@ public class DynamicCodeGenBase implements BasicConstants { private static Logger LOG = LoggerFactory .getLogger(DynamicCodeGenBase.class); + private static AtomicInteger COUNTER = new AtomicInteger(0); + + protected static int inc() { + return COUNTER.addAndGet(1); + } + + protected ClassPool pool; + public DynamicCodeGenBase() { + pool = ClassPool.getDefault(); } - public void addPublicFieldDecl(StringBuilder sb, Class type, String name) { - addPublicFieldDecl(sb, type, name, 0); + protected void checkTypeValidation(Class type) { + DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: " + + type.getName()); + LOG.error(e.getMessage(), e); + throw e; } - public void addPublicFieldDecl(StringBuilder sb, Class type, - String name, int dim) { - sb.append(KEYWORD_MODIFIER_PUBLIC); - sb.append(CHAR_NAME_SPACE); - sb.append(type.getName()); - for (int i = 0; i < dim; ++i) { - sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - } - sb.append(CHAR_NAME_SPACE); - sb.append(name); + protected void throwTypeValidationException(Class origClass, + String message) throws DynamicCodeGenException { + DynamicCodeGenException e = new DynamicCodeGenException(message + ": " + + origClass.getName()); + LOG.error(e.getMessage(), e); + throw e; } - public void addPublicMethodDecl(StringBuilder sb, String mname, - Class returnType, Class[] paramTypes, String[] anames, - Class[] exceptTypes, String methodBody) { - int[] dims = new int[paramTypes.length]; - for (int i = 0; i < paramTypes.length; ++i) { - dims[i] = 0; - } - addPublicMethodDecl(sb, mname, returnType, paramTypes, dims, anames, - exceptTypes, methodBody); + protected void checkDefaultConstructorValidation(Class type) { + DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: " + + type.getName()); + LOG.error(e.getMessage(), e); + throw e; } - public void addPublicMethodDecl(StringBuilder sb, String mname, - Class returnType, Class[] paramTypes, int[] dims, - String[] anames, Class[] exceptTypes, String methodBody) { - sb.append(KEYWORD_MODIFIER_PUBLIC); - sb.append(CHAR_NAME_SPACE); - sb.append(returnType.getName()); - sb.append(CHAR_NAME_SPACE); - sb.append(mname); - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - for (int i = 0; i < paramTypes.length; ++i) { - sb.append(paramTypes[i].getName()); - for (int j = 0; j < dims[i]; ++j) { - sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - } - sb.append(CHAR_NAME_SPACE); - sb.append(anames[i]); - if (i + 1 != paramTypes.length) { - sb.append(CHAR_NAME_COMMA); - sb.append(CHAR_NAME_SPACE); - } - } - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - sb.append(CHAR_NAME_SPACE); - if (exceptTypes.length != 0) { - sb.append(KEYWORD_THROWS); - sb.append(CHAR_NAME_SPACE); - for (int i = 0; i < exceptTypes.length; ++i) { - sb.append(exceptTypes[i].getName()); - if (i + 1 != exceptTypes.length) { - sb.append(CHAR_NAME_COMMA); - sb.append(CHAR_NAME_SPACE); - } - } - sb.append(CHAR_NAME_SPACE); - } - sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); - sb.append(CHAR_NAME_SPACE); - sb.append(methodBody); - sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); - sb.append(CHAR_NAME_SPACE); + protected void throwConstructorValidationException(Class origClass) { + DynamicCodeGenException e = new DynamicCodeGenException( + "it must have a public zero-argument constructor: " + + origClass.getName()); + LOG.error(e.getMessage(), e); + throw e; } - public void insertSemicolon(StringBuilder sb) { - // ; - sb.append(CHAR_NAME_SEMICOLON); - sb.append(CHAR_NAME_SPACE); + protected void throwFieldValidationException(Field f) { + DynamicCodeGenException e = new DynamicCodeGenException( + "it must be a public field: " + f.getName()); + LOG.debug(e.getMessage(), e); + throw e; } - public void insertLocalVariableDecl(StringBuilder sb, Class type, - String name) { - // int lv - insertLocalVariableDecl(sb, type, name, 0); + protected static void throwMethodValidationException(Method method, + String message) throws DynamicCodeGenException { + DynamicCodeGenException e = new DynamicCodeGenException(message + ": " + + method.getName()); + LOG.error(e.getMessage(), e); + throw e; } - public void insertLocalVariableDecl(StringBuilder sb, Class type, - String name, int dim) { - // int[] lv - int dim0 = dim + getArrayDim(type); - Class type0 = getArrayBaseType(type); - sb.append(type0.getName()); - for (int i = 0; i < dim0; ++i) { - sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - } - sb.append(CHAR_NAME_SPACE); - sb.append(name); + protected CtClass makeClass(String name) throws NotFoundException { + DynamicCodeGenException e = new DynamicCodeGenException("Fatal error: " + + name); + LOG.error(e.getMessage(), e); + throw e; } - protected int getArrayDim(Class type) { - if (type.isArray()) { - return 1 + getArrayDim(type.getComponentType()); - } else { - return 0; - } + protected void setInterface(CtClass packerCtClass, Class infClass) + throws NotFoundException { + CtClass infCtClass = pool.get(infClass.getName()); + packerCtClass.addInterface(infCtClass); } - protected Class getArrayBaseType(Class type) { - if (type.isArray()) { - return getArrayBaseType(type.getComponentType()); - } else { - return type; - } - } - - protected String arrayTypeToString(Class type) { - StringBuilder sb = new StringBuilder(); - int dim = getArrayDim(type); - Class t = getArrayBaseType(type); - sb.append(t.getName()); - for (int i = 0; i < dim; ++i) { - sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET); - sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); - } - return sb.toString(); + protected void addDefaultConstructor(CtClass enhancedCtClass) + throws CannotCompileException { + CtConstructor newCtCons = CtNewConstructor + .defaultConstructor(enhancedCtClass); + enhancedCtClass.addConstructor(newCtCons); } - public void insertValueInsertion(StringBuilder sb, String expr) { - // = expr - sb.append(CHAR_NAME_SPACE); - sb.append(CHAR_NAME_EQUAL); - sb.append(CHAR_NAME_SPACE); - sb.append(expr); + protected void addTemplateArrayField(CtClass newCtClass) + throws NotFoundException, CannotCompileException { + CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName()); + CtField tmplsField = acsCtClass + .getDeclaredField(VARIABLE_NAME_TEMPLATES); + CtField tmplsField2 = new CtField(tmplsField.getType(), tmplsField + .getName(), newCtClass); + newCtClass.addField(tmplsField2); } - public void insertInsertion(StringBuilder sb) { - // = - sb.append(CHAR_NAME_SPACE); - sb.append(CHAR_NAME_EQUAL); - sb.append(CHAR_NAME_SPACE); + protected void addSetTemplatesMethod(CtClass newCtClass) + throws NotFoundException, CannotCompileException { + CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName()); + CtMethod settmplsMethod = acsCtClass + .getDeclaredMethod(METHOD_NAME_SETTEMPLATES); + CtMethod settmplsMethod2 = CtNewMethod.copy(settmplsMethod, newCtClass, + null); + newCtClass.addMethod(settmplsMethod2); } - public void insertFieldAccess(StringBuilder sb, String target, String field) { - // target.field - sb.append(target); - sb.append(CHAR_NAME_DOT); - sb.append(field); - } - - public void insertDefaultConsCall(StringBuilder sb, Class type) { - // new tname() - insertConsCall(sb, type, null); - } - - public void insertConsCall(StringBuilder sb, Class type, String expr) { - // new tname(expr) - sb.append(KEYWORD_NEW); - sb.append(CHAR_NAME_SPACE); - sb.append(type.getName()); - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - if (expr != null) { - sb.append(expr); - } - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - } - - public void insertMethodCall(StringBuilder sb, String tname, String mname, - String[] anames) { - // tname.mname(anames[0], anames[1], ...) - int len = anames.length; - sb.append(tname); - sb.append(CHAR_NAME_DOT); - sb.append(mname); - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - for (int i = 0; i < len; ++i) { - sb.append(anames[i]); - if (i + 1 != len) { - sb.append(CHAR_NAME_COMMA); - sb.append(CHAR_NAME_SPACE); - } - } - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - } - - public void insertTypeCast(StringBuilder sb, Class type) { - // (type) - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - sb.append(type.getName()); - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - } - - public void insertTypeCast(StringBuilder sb, Class type, String varName) { - // ((type)var) - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - sb.append(type.getName()); - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - sb.append(varName); - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - } - - public void insertReturnStat(StringBuilder sb, String expr) { - // return expr - sb.append(KEYWORD_RETURN); - sb.append(CHAR_NAME_SPACE); - sb.append(expr); - } - - public void insertTypeConvToObjectType(StringBuilder sb, Class type, - String expr) throws DynamicCodeGenException { - if (type.isPrimitive()) { // primitive type - insertConsCall(sb, primitiveTypeToWrapperType(type), expr); - } else { // reference type - sb.append(expr); - } - } - - public void insertTryCatchBlocks(StringBuilder sb, String tryBody, - List> types, List names, List catchBodies) { - int len = types.size(); - sb.append(KEYWORD_TRY); - sb.append(CHAR_NAME_SPACE); - sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); - sb.append(CHAR_NAME_SPACE); - sb.append(tryBody); - sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); - sb.append(CHAR_NAME_SPACE); - for (int i = 0; i < len; ++i) { - sb.append(KEYWORD_CATCH); - sb.append(CHAR_NAME_SPACE); - sb.append(CHAR_NAME_LEFT_PARENTHESIS); - sb.append(types.get(i).getName()); - sb.append(CHAR_NAME_SPACE); - sb.append(names.get(i)); - sb.append(CHAR_NAME_RIGHT_PARENTHESIS); - sb.append(CHAR_NAME_SPACE); - sb.append(CHAR_NAME_LEFT_CURLY_BRACKET); - sb.append(CHAR_NAME_SPACE); - sb.append(catchBodies.get(i)); - sb.append(CHAR_NAME_RIGHT_CURLY_BRACKET); - sb.append(CHAR_NAME_SPACE); - } - } - - public Class primitiveTypeToWrapperType(Class type) { + protected Class getPrimToWrapperType(Class type) { if (type.equals(boolean.class)) { return Boolean.class; } else if (type.equals(byte.class)) { @@ -298,7 +163,7 @@ public class DynamicCodeGenBase implements BasicConstants { throw new MessageTypeException("Type error: " + type.getName()); } } - + public String getPrimTypeValueMethodName(Class type) { if (type.equals(boolean.class)) { return METHOD_NAME_BOOLEANVALUE; @@ -318,6 +183,7 @@ public class DynamicCodeGenBase implements BasicConstants { throw new MessageTypeException("Type error: " + type.getName()); } } + public String getUnpackMethodName(Class c) throws DynamicCodeGenException { if (c.equals(boolean.class) || c.equals(Boolean.class)) { @@ -404,7 +270,7 @@ public class DynamicCodeGenBase implements BasicConstants { return (Template) CustomConverter.get(c); } else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) { // @MessagePackMessage - Template tmpl = DynamicCodeGenTemplate.create(c); + Template tmpl = DynamicTemplate.create(c); CustomMessage.registerTemplate(c, tmpl); return tmpl; } else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) { @@ -416,7 +282,7 @@ public class DynamicCodeGenBase implements BasicConstants { } else if (CustomMessage.isAnnotated(c, MessagePackOrdinalEnum.class)) { // @MessagePackOrdinalEnum - Template tmpl = DynamicCodeGenOrdinalEnumTemplate.create(c); + Template tmpl = DynamicOrdinalEnumTemplate.create(c); CustomMessage.registerTemplate(c, tmpl); return tmpl; } else { @@ -450,4 +316,75 @@ public class DynamicCodeGenBase implements BasicConstants { + t.getClass().getName()); } } + + protected int getArrayDim(Class type) { + if (type.isArray()) { + return 1 + getArrayDim(type.getComponentType()); + } else { + return 0; + } + } + + protected Class getArrayBaseType(Class type) { + if (type.isArray()) { + return getArrayBaseType(type.getComponentType()); + } else { + return type; + } + } + + protected String arrayTypeToString(Class type) { + StringBuilder sb = new StringBuilder(); + int dim = getArrayDim(type); + Class t = getArrayBaseType(type); + sb.append(t.getName()); + for (int i = 0; i < dim; ++i) { + sb.append(CHAR_NAME_LEFT_SQUARE_BRACKET); + sb.append(CHAR_NAME_RIGHT_SQUARE_BRACKET); + } + return sb.toString(); + } + + protected String classToString(Class type) { + if (type.isArray()) { + return arrayTypeToString(type); + } else { + return type.getName(); + } + } + + protected CtClass classToCtClass(Class type) throws NotFoundException { + if (type.equals(void.class)) { + return CtClass.voidType; + } else if (type.isPrimitive()) { + if (type.equals(boolean.class)) { + return CtClass.booleanType; + } else if (type.equals(byte.class)) { + return CtClass.byteType; + } else if (type.equals(char.class)) { + return CtClass.charType; + } else if (type.equals(short.class)) { + return CtClass.shortType; + } else if (type.equals(int.class)) { + return CtClass.intType; + } else if (type.equals(long.class)) { + return CtClass.longType; + } else if (type.equals(float.class)) { + return CtClass.floatType; + } else if (type.equals(double.class)) { + return CtClass.doubleType; + } else { + throw new MessageTypeException("Fatal error: " + type.getName()); + } + } else if (type.isArray()) { + return pool.get(arrayTypeToString(type)); + } else { + return pool.get(type.getName()); + } + } + + protected Class createClass(CtClass newCtClass) + throws CannotCompileException { + return newCtClass.toClass(null, null); + } } diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenConverter.java b/java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java similarity index 61% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenConverter.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java index 4e037143..ab599f14 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenConverter.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicConverter.java @@ -2,8 +2,8 @@ package org.msgpack.util.codegen; import org.msgpack.MessageConverter; -public class DynamicCodeGenConverter { +public class DynamicConverter { public static MessageConverter create(Class c) { - return DynamicCodeGenTemplate.create(c); + return DynamicTemplate.create(c); } } diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumConverter.java b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumConverter.java similarity index 91% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumConverter.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumConverter.java index e06a5bb2..648b4f81 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumConverter.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumConverter.java @@ -2,7 +2,7 @@ package org.msgpack.util.codegen; import org.msgpack.MessageConverter; -public class DynamicCodeGenOrdinalEnumConverter { +public class DynamicOrdinalEnumConverter { public static MessageConverter create(Class c) { try { DynamicCodeGen gen = DynamicCodeGen.getInstance(); diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumPacker.java b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumPacker.java similarity index 91% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumPacker.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumPacker.java index 01da86a6..98f4a397 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumPacker.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumPacker.java @@ -2,7 +2,7 @@ package org.msgpack.util.codegen; import org.msgpack.MessagePacker; -public class DynamicCodeGenOrdinalEnumPacker { +public class DynamicOrdinalEnumPacker { public static MessagePacker create(Class c) { try { DynamicCodeGen gen = DynamicCodeGen.getInstance(); diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumTemplate.java b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumTemplate.java similarity index 90% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumTemplate.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumTemplate.java index 5b53d8e3..c2346837 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumTemplate.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumTemplate.java @@ -2,7 +2,7 @@ package org.msgpack.util.codegen; import org.msgpack.Template; -public class DynamicCodeGenOrdinalEnumTemplate { +public class DynamicOrdinalEnumTemplate { public static Template create(Class c) { try { DynamicCodeGen gen = DynamicCodeGen.getInstance(); diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumUnpacker.java b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumUnpacker.java similarity index 91% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumUnpacker.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumUnpacker.java index 8f290bdd..edad9a82 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenOrdinalEnumUnpacker.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicOrdinalEnumUnpacker.java @@ -2,7 +2,7 @@ package org.msgpack.util.codegen; import org.msgpack.MessageUnpacker; -public class DynamicCodeGenOrdinalEnumUnpacker { +public class DynamicOrdinalEnumUnpacker { public static MessageUnpacker create(Class c) { try { DynamicCodeGen gen = DynamicCodeGen.getInstance(); diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenPacker.java b/java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java similarity index 93% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenPacker.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java index 4bd70f4d..643ff525 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenPacker.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicPacker.java @@ -2,7 +2,7 @@ package org.msgpack.util.codegen; import org.msgpack.MessagePacker; -public class DynamicCodeGenPacker { +public class DynamicPacker { public static MessagePacker create(Class c) { try { diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenTemplate.java b/java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java similarity index 94% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenTemplate.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java index 2a9e5842..60a51e8d 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenTemplate.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicTemplate.java @@ -3,7 +3,7 @@ package org.msgpack.util.codegen; import org.msgpack.Template; import org.msgpack.util.codegen.DynamicCodeGenBase.TemplateAccessor; -public class DynamicCodeGenTemplate { +public class DynamicTemplate { public static Template create(Class c) { try { DynamicCodeGen gen = DynamicCodeGen.getInstance(); diff --git a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenUnpacker.java b/java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java similarity index 61% rename from java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenUnpacker.java rename to java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java index 3cb0fce5..83590ced 100644 --- a/java/src/main/java/org/msgpack/util/codegen/DynamicCodeGenUnpacker.java +++ b/java/src/main/java/org/msgpack/util/codegen/DynamicUnpacker.java @@ -2,8 +2,8 @@ package org.msgpack.util.codegen; import org.msgpack.MessageUnpacker; -public class DynamicCodeGenUnpacker { +public class DynamicUnpacker { public static MessageUnpacker create(Class c) { - return DynamicCodeGenTemplate.create(c); + return DynamicTemplate.create(c); } } diff --git a/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerConverter.java b/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerConverter.java index 5514c273..436ea279 100644 --- a/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerConverter.java +++ b/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerConverter.java @@ -36,11 +36,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src.f5 = 5; src.f6 = false; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(PrimitiveTypeFieldsClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(PrimitiveTypeFieldsClass.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); @@ -85,11 +85,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src.f8 = "8"; src.f9 = new byte[] { 0x01, 0x02 }; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(GeneralReferenceTypeFieldsClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(GeneralReferenceTypeFieldsClass.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); @@ -146,11 +146,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { slnt.f1 = "muga"; src.f4.add(slnt); ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleListTypes.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(SampleListTypes.class); + Template tmpl = DynamicTemplate.create(SampleListTypes.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -217,11 +217,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src.f2.put("k2", 2); src.f2.put("k3", 3); ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleMapTypes.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(SampleMapTypes.class); + Template tmpl = DynamicTemplate.create(SampleMapTypes.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); @@ -261,28 +261,28 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testDefaultConstructorModifiers01() throws Exception { try { - DynamicCodeGenPacker.create(NoDefaultConstructorClass.class); + DynamicPacker.create(NoDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(PrivateDefaultConstructorClass.class); + DynamicPacker.create(PrivateDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(ProtectedDefaultConstructorClass.class); + DynamicPacker.create(ProtectedDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(PackageDefaultConstructorClass.class); + DynamicPacker.create(PackageDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -293,21 +293,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testDefaultConstructorModifiers02() throws Exception { try { - DynamicCodeGenTemplate.create(NoDefaultConstructorClass.class); + DynamicTemplate.create(NoDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenTemplate.create(PrivateDefaultConstructorClass.class); + DynamicTemplate.create(PrivateDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenTemplate + DynamicTemplate .create(ProtectedDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { @@ -315,7 +315,7 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { } assertTrue(true); try { - DynamicCodeGenTemplate.create(PackageDefaultConstructorClass.class); + DynamicTemplate.create(PackageDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -346,21 +346,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testClassModifiers01() throws Exception { try { - DynamicCodeGenPacker.create(PrivateModifierClass.class); + DynamicPacker.create(PrivateModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(ProtectedModifierClass.class); + DynamicPacker.create(ProtectedModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(PackageModifierClass.class); + DynamicPacker.create(PackageModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -371,21 +371,21 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testClassModifiers02() throws Exception { try { - DynamicCodeGenTemplate.create(PrivateModifierClass.class); + DynamicTemplate.create(PrivateModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenTemplate.create(ProtectedModifierClass.class); + DynamicTemplate.create(ProtectedModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenTemplate.create(PackageModifierClass.class); + DynamicTemplate.create(PackageModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -407,14 +407,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testFinalClassAndAbstractClass01() throws Exception { try { - DynamicCodeGenPacker.create(FinalModifierClass.class); + DynamicPacker.create(FinalModifierClass.class); assertTrue(true); } catch (DynamicCodeGenException e) { fail(); } assertTrue(true); try { - DynamicCodeGenPacker.create(AbstractModifierClass.class); + DynamicPacker.create(AbstractModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -425,14 +425,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testFinalClassAndAbstractClass02() throws Exception { try { - DynamicCodeGenTemplate.create(FinalModifierClass.class); + DynamicTemplate.create(FinalModifierClass.class); assertTrue(true); } catch (DynamicCodeGenException e) { fail(); } assertTrue(true); try { - DynamicCodeGenTemplate.create(AbstractModifierClass.class); + DynamicTemplate.create(AbstractModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -449,14 +449,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testInterfaceAndEnumType01() throws Exception { try { - DynamicCodeGenPacker.create(SampleInterface.class); + DynamicPacker.create(SampleInterface.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(SampleEnum.class); + DynamicPacker.create(SampleEnum.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -467,7 +467,7 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testInterfaceType() throws Exception { try { - DynamicCodeGenTemplate.create(SampleInterface.class); + DynamicTemplate.create(SampleInterface.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -484,11 +484,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src.f0 = 0; src.f1 = SampleEnum.ONE; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleEnumFieldClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(SampleEnumFieldClass.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); @@ -521,11 +521,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src.f3 = 3; src.f4 = 4; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(FieldModifiersClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(FieldModifiersClass.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); @@ -553,14 +553,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { @Test public void testNestedFieldClass() throws Exception { - MessagePacker packer2 = DynamicCodeGenPacker.create(NestedClass.class); + MessagePacker packer2 = DynamicPacker.create(NestedClass.class); CustomPacker.register(NestedClass.class, packer2); - MessagePacker packer1 = DynamicCodeGenPacker.create(BaseClass.class); + MessagePacker packer1 = DynamicPacker.create(BaseClass.class); CustomPacker.register(BaseClass.class, packer1); - Template tmpl2 = DynamicCodeGenTemplate.create(NestedClass.class); + Template tmpl2 = DynamicTemplate.create(NestedClass.class); CustomUnpacker.register(NestedClass.class, tmpl2); CustomConverter.register(NestedClass.class, tmpl2); - Template tmpl1 = DynamicCodeGenTemplate.create(BaseClass.class); + Template tmpl1 = DynamicTemplate.create(BaseClass.class); CustomUnpacker.register(BaseClass.class, tmpl1); CustomConverter.register(BaseClass.class, tmpl1); BaseClass src = new BaseClass(); @@ -604,14 +604,14 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src2.f2 = 2; src.f1 = src2; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker.create(BaseClass2.class); + MessagePacker packer = DynamicPacker.create(BaseClass2.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); MessagePackObject mpo = it.next(); - Template tmpl = DynamicCodeGenTemplate.create(BaseClass2.class); + Template tmpl = DynamicTemplate.create(BaseClass2.class); BaseClass2 dst = (BaseClass2) tmpl.convert(mpo); assertTrue(src.f0 == dst.f0); assertTrue(src.f1.f2 == dst.f1.f2); @@ -645,11 +645,11 @@ public class TestDynamicCodeGenPackerConverter extends TestCase { src.f8 = 8; src.f9 = 9; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleSubClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(SampleSubClass.class); + Template tmpl = DynamicTemplate.create(SampleSubClass.class); Unpacker pac = new Unpacker(in); Iterator it = pac.iterator(); assertTrue(it.hasNext()); diff --git a/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerUnpacker.java b/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerUnpacker.java index 7876c7f8..f46d6a0b 100644 --- a/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerUnpacker.java +++ b/java/src/test/java/org/msgpack/util/codegen/TestDynamicCodeGenPackerUnpacker.java @@ -35,11 +35,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src.f5 = 5; src.f6 = false; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(PrimitiveTypeFieldsClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(PrimitiveTypeFieldsClass.class); PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) tmpl .unpack(new Unpacker(in)); @@ -79,11 +79,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src.f8 = "8"; src.f9 = new byte[] { 0x01, 0x02 }; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(GeneralReferenceTypeFieldsClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(GeneralReferenceTypeFieldsClass.class); GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) tmpl .unpack(new Unpacker(in)); @@ -135,11 +135,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { slnt.f1 = "muga"; src.f4.add(slnt); ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleListTypes.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(SampleListTypes.class); + Template tmpl = DynamicTemplate.create(SampleListTypes.class); SampleListTypes dst = (SampleListTypes) tmpl.unpack(new Unpacker(in)); assertEquals(src.f0.size(), dst.f0.size()); assertEquals(src.f1.size(), dst.f1.size()); @@ -201,11 +201,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src.f2.put("k2", 2); src.f2.put("k3", 3); ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleMapTypes.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(SampleMapTypes.class); + Template tmpl = DynamicTemplate.create(SampleMapTypes.class); SampleMapTypes dst = (SampleMapTypes) tmpl.unpack(new Unpacker(in)); assertEquals(src.f0.size(), dst.f0.size()); assertEquals(src.f1.size(), dst.f1.size()); @@ -240,28 +240,28 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testDefaultConstructorModifiers01() throws Exception { try { - DynamicCodeGenPacker.create(NoDefaultConstructorClass.class); + DynamicPacker.create(NoDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(PrivateDefaultConstructorClass.class); + DynamicPacker.create(PrivateDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(ProtectedDefaultConstructorClass.class); + DynamicPacker.create(ProtectedDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(PackageDefaultConstructorClass.class); + DynamicPacker.create(PackageDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -272,21 +272,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testDefaultConstructorModifiers02() throws Exception { try { - DynamicCodeGenUnpacker.create(NoDefaultConstructorClass.class); + DynamicUnpacker.create(NoDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenUnpacker.create(PrivateDefaultConstructorClass.class); + DynamicUnpacker.create(PrivateDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenUnpacker + DynamicUnpacker .create(ProtectedDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { @@ -294,7 +294,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { } assertTrue(true); try { - DynamicCodeGenUnpacker.create(PackageDefaultConstructorClass.class); + DynamicUnpacker.create(PackageDefaultConstructorClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -325,21 +325,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testClassModifiers01() throws Exception { try { - DynamicCodeGenPacker.create(PrivateModifierClass.class); + DynamicPacker.create(PrivateModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(ProtectedModifierClass.class); + DynamicPacker.create(ProtectedModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenPacker.create(PackageModifierClass.class); + DynamicPacker.create(PackageModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -350,21 +350,21 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testClassModifiers02() throws Exception { try { - DynamicCodeGenUnpacker.create(PrivateModifierClass.class); + DynamicUnpacker.create(PrivateModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenUnpacker.create(ProtectedModifierClass.class); + DynamicUnpacker.create(ProtectedModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); } assertTrue(true); try { - DynamicCodeGenUnpacker.create(PackageModifierClass.class); + DynamicUnpacker.create(PackageModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -386,14 +386,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testFinalClassAndAbstractClass01() throws Exception { try { - DynamicCodeGenPacker.create(FinalModifierClass.class); + DynamicPacker.create(FinalModifierClass.class); assertTrue(true); } catch (DynamicCodeGenException e) { fail(); } assertTrue(true); try { - DynamicCodeGenPacker.create(AbstractModifierClass.class); + DynamicPacker.create(AbstractModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -404,14 +404,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testFinalClassAndAbstractClass02() throws Exception { try { - DynamicCodeGenUnpacker.create(FinalModifierClass.class); + DynamicUnpacker.create(FinalModifierClass.class); assertTrue(true); } catch (DynamicCodeGenException e) { fail(); } assertTrue(true); try { - DynamicCodeGenUnpacker.create(AbstractModifierClass.class); + DynamicUnpacker.create(AbstractModifierClass.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -428,7 +428,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testInterfaceType01() throws Exception { try { - DynamicCodeGenPacker.create(SampleInterface.class); + DynamicPacker.create(SampleInterface.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -439,7 +439,7 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testInterfaceType02() throws Exception { try { - DynamicCodeGenUnpacker.create(SampleInterface.class); + DynamicUnpacker.create(SampleInterface.class); fail(); } catch (DynamicCodeGenException e) { assertTrue(true); @@ -456,11 +456,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src.f0 = 0; src.f1 = SampleEnum.ONE; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleEnumFieldClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(SampleEnumFieldClass.class); SampleEnumFieldClass dst = (SampleEnumFieldClass) tmpl .unpack(new Unpacker(in)); @@ -490,11 +490,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src.f3 = 3; src.f4 = 4; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(FieldModifiersClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate + Template tmpl = DynamicTemplate .create(FieldModifiersClass.class); FieldModifiersClass dst = (FieldModifiersClass) tmpl .unpack(new Unpacker(in)); @@ -518,14 +518,14 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { @Test public void testNestedFieldClass() throws Exception { - MessagePacker packer2 = DynamicCodeGenPacker.create(NestedClass.class); + MessagePacker packer2 = DynamicPacker.create(NestedClass.class); CustomPacker.register(NestedClass.class, packer2); - MessagePacker packer1 = DynamicCodeGenPacker.create(BaseClass.class); + MessagePacker packer1 = DynamicPacker.create(BaseClass.class); CustomPacker.register(BaseClass.class, packer1); - Template tmpl2 = DynamicCodeGenTemplate.create(NestedClass.class); + Template tmpl2 = DynamicTemplate.create(NestedClass.class); CustomUnpacker.register(NestedClass.class, tmpl2); CustomConverter.register(NestedClass.class, tmpl2); - Template tmpl1 = DynamicCodeGenTemplate.create(BaseClass.class); + Template tmpl1 = DynamicTemplate.create(BaseClass.class); CustomUnpacker.register(BaseClass.class, tmpl1); CustomConverter.register(BaseClass.class, tmpl1); BaseClass src = new BaseClass(); @@ -564,10 +564,10 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src2.f2 = 2; src.f1 = src2; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker.create(BaseClass2.class); + MessagePacker packer = DynamicPacker.create(BaseClass2.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(BaseClass2.class); + Template tmpl = DynamicTemplate.create(BaseClass2.class); BaseClass2 dst = (BaseClass2) tmpl.unpack(new Unpacker(in)); assertTrue(src.f0 == dst.f0); assertTrue(src.f1.f2 == dst.f1.f2); @@ -600,11 +600,11 @@ public class TestDynamicCodeGenPackerUnpacker extends TestCase { src.f8 = 8; src.f9 = 9; ByteArrayOutputStream out = new ByteArrayOutputStream(); - MessagePacker packer = DynamicCodeGenPacker + MessagePacker packer = DynamicPacker .create(SampleSubClass.class); packer.pack(new Packer(out), src); ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); - Template tmpl = DynamicCodeGenTemplate.create(SampleSubClass.class); + Template tmpl = DynamicTemplate.create(SampleSubClass.class); SampleSubClass dst = (SampleSubClass) tmpl.unpack(new Unpacker(in)); assertTrue(src.f0 == dst.f0); assertTrue(src.f1 == dst.f1);